Memory Optimizations

core/src/model/Ad4mModel.ts

@@ -614,6 +614,81 @@ export class Ad4mModel {
     return this.#perspective;
   }
 
+  /**
+   * Get property metadata from decorator (Phase 1: Prolog-free refactor)
+   * @private
+   */
+  private getPropertyMetadata(key: string): PropertyOptions | undefined {
+    const proto = Object.getPrototypeOf(this);
+    return proto.__properties?.[key];
+  }
+
+  /**
+   * Get collection metadata from decorator (Phase 1: Prolog-free refactor)
+   * @private
+   */
+  private getCollectionMetadata(key: string): CollectionOptions | undefined {
+    const proto = Object.getPrototypeOf(this);
+    return proto.__collections?.[key];
+  }
+
+  /**
+   * Generate property setter action from metadata (Phase 1: Prolog-free refactor)
+   * Replaces Prolog query: property_setter(C, key, Setter)
+   * @private
+   */
+  private generatePropertySetterAction(key: string, metadata: PropertyOptions): any[] {
+    if (metadata.setter) {
+      // Custom setter - throw error for now (Phase 2)
+      throw new Error(
+        `Custom setter for property "${key}" not yet supported without Prolog. ` +
+        `Use standard @Property decorator or enable Prolog for custom setters.`
+      );
+    }
+
+    if (!metadata.through) {
+      throw new Error(`Property "${key}" has no 'through' predicate defined`);
+    }
+
+    return [{
+      action: "setSingleTarget",
+      source: "this",
+      predicate: metadata.through,
+      target: "value",
+      ...(metadata.local && { local: true })
+    }];
+  }
+
+  /**
+   * Generate collection action from metadata (Phase 1: Prolog-free refactor)
+   * Replaces Prolog queries: collection_adder, collection_remover, collection_setter
+   * @private
+   */
+  private generateCollectionAction(key: string, actionType: 'adder' | 'remover' | 'setter'): any[] {
+    const metadata = this.getCollectionMetadata(key);
+    if (!metadata) {
+      throw new Error(`Collection "${key}" has no metadata defined`);
+    }
+
+    if (!metadata.through) {
+      throw new Error(`Collection "${key}" has no 'through' predicate defined`);
+    }
+
+    const actionMap = {
+      adder: "addLink",
+      remover: "removeLink",
+      setter: "collectionSetter"
+    };
+
+    return [{
+      action: actionMap[actionType],
+      source: "this",
+      predicate: metadata.through,
+      target: "value",
+      ...(metadata.local && { local: true })
+    }];
+  }
+
   public static async assignValuesToInstance(perspective: PerspectiveProxy, instance: Ad4mModel, values: ValueTuple[]) {
     // Map properties to object
     const propsObject = Object.fromEntries(
@@ -675,11 +750,100 @@ export class Ad4mModel {
       ${subQueries.join(", ")}
     `;
 
-    const result = await this.#perspective.infer(fullQuery);
-    if (result?.[0]) {
-      const { Properties, Collections, Timestamp, Author } = result?.[0];
-      const values = [...Properties, ...Collections, ["timestamp", Timestamp], ["author", Author]];
-      await Ad4mModel.assignValuesToInstance(this.#perspective, this, values);
+    // Try Prolog first
+    try {
+      const result = await this.#perspective.infer(fullQuery);
+      if (result?.[0] && result[0].Properties && result[0].Properties.length > 0) {
+        const { Properties, Collections, Timestamp, Author } = result[0];
+        const values = [...Properties, ...Collections, ["timestamp", Timestamp], ["author", Author]];
+        await Ad4mModel.assignValuesToInstance(this.#perspective, this, values);
+        return this;
+      }
+    } catch (e) {
+      console.log(`Prolog getData failed for ${this.#baseExpression}, falling back to SurrealDB`);
+    }
+
+    // Fallback to SurrealDB (SdnaOnly mode)
+    try {
+      const ctor = this.constructor as typeof Ad4mModel;
+      const metadata = ctor.getModelMetadata();
+
+      // Query for all links from this specific node (base expression)
+      const linksQuery = `
+        SELECT id, predicate, out.uri AS target, author, timestamp
+        FROM link
+        WHERE in.uri = '${this.#baseExpression}'
+        ORDER BY timestamp ASC
+      `;
+      const links = await this.#perspective.querySurrealDB(linksQuery);
+
+      if (links && links.length > 0) {
+        let maxTimestamp = null;
+        let latestAuthor = null;
+
+        // Process properties
+        for (const [propName, propMeta] of Object.entries(metadata.properties)) {
+          const matching = links.filter((l: any) => l.predicate === propMeta.predicate);
+          if (matching.length > 0) {
+            const link = matching[0]; // Take first/latest
+            let value = link.target;
+
+            // Track timestamp/author
+            if (link.timestamp && (!maxTimestamp || link.timestamp > maxTimestamp)) {
+              maxTimestamp = link.timestamp;
+              latestAuthor = link.author;
+            }
+
+            // Handle resolveLanguage
+            if (propMeta.resolveLanguage && propMeta.resolveLanguage !== 'literal') {
+              try {
+                const expression = await this.#perspective.getExpression(value);
+                if (expression) {
+                  try {
+                    value = JSON.parse(expression.data);
+                  } catch {
+                    value = expression.data;
+                  }
+                }
+              } catch (e) {
+                console.warn(`Failed to resolve expression for ${propName}:`, e);
+              }
+            } else if (typeof value === 'string' && value.startsWith('literal://')) {
+              // Parse literal URL
+              try {
+                const parsed = Literal.fromUrl(value).get();
+                value = parsed.data !== undefined ? parsed.data : parsed;
+              } catch (e) {
+                // Keep original value
+              }
+            }
+
+            // Apply transform if exists
+            if (propMeta.transform && typeof propMeta.transform === 'function') {
+              value = propMeta.transform(value);
+            }
+
+            (this as any)[propName] = value;
+          }
+        }
+
+        // Process collections
+        for (const [collName, collMeta] of Object.entries(metadata.collections)) {
+          const matching = links.filter((l: any) => l.predicate === collMeta.predicate);
+          // Links are already sorted by timestamp ASC from the query, so map preserves order
+          (this as any)[collName] = matching.map((l: any) => l.target);
+        }
+
+        // Set author and timestamp
+        if (latestAuthor) {
+          (this as any).author = latestAuthor;
+        }
+        if (maxTimestamp) {
+          (this as any).timestamp = maxTimestamp;
+        }
+      }
+    } catch (e) {
+      console.error(`SurrealDB getData also failed for ${this.#baseExpression}:`, e);
     }
 
     return this;
@@ -1320,7 +1484,7 @@ WHERE ${whereConditions.join(' AND ')}
                 let convertedValue = target;
 
                 // Only process if target has a value
-                if (target !== undefined && target !== null) {
+                if (target !== undefined && target !== null && target !== '') {
                   // Check if we need to resolve a non-literal language expression
                   if (propMeta.resolveLanguage != undefined && propMeta.resolveLanguage !== 'literal' && typeof target === 'string') {
                     // For non-literal languages, resolve the expression via perspective.getExpression()
@@ -1337,7 +1501,8 @@ WHERE ${whereConditions.join(' AND ')}
                         }
                       }
                     } catch (e) {
-                      console.warn(`Failed to resolve expression for ${propName}:`, e);
+                      console.warn(`Failed to resolve expression for ${propName} with target "${target}":`, e);
+                      console.warn("Falling back to raw value");
                       convertedValue = target; // Fall back to raw value
                     }
                   } else if (typeof target === 'string' && target.startsWith('literal://')) {
@@ -1817,90 +1982,95 @@ WHERE ${whereConditions.join(' AND ')}
   }
 
   private async setProperty(key: string, value: any, batchId?: string) {
-    const setters = await this.#perspective.infer(
-      `subject_class("${this.#subjectClassName}", C), property_setter(C, "${key}", Setter)`
-    );
-    if (setters && setters.length > 0) {
-      const actions = eval(setters[0].Setter);
-      const resolveLanguageResults = await this.#perspective.infer(
-        `subject_class("${this.#subjectClassName}", C), property_resolve_language(C, "${key}", Language)`
-      );
-      let resolveLanguage;
-      if (resolveLanguageResults && resolveLanguageResults.length > 0) {
-        resolveLanguage = resolveLanguageResults[0].Language;
-      }
+    // Phase 1: Use metadata instead of Prolog queries
+    const metadata = this.getPropertyMetadata(key);
+    if (!metadata) {
+      console.warn(`Property "${key}" has no metadata, skipping`);
+      return;
+    }
 
-      if (resolveLanguage) {
-        value = await this.#perspective.createExpression(value, resolveLanguage);
-      }
-      await this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value }], batchId);
+    // Generate actions from metadata (replaces Prolog query)
+    const actions = this.generatePropertySetterAction(key, metadata);
+
+    // Get resolve language from metadata (replaces Prolog query)
+    let resolveLanguage = metadata.resolveLanguage;
+
+    if (resolveLanguage) {
+      value = await this.#perspective.createExpression(value, resolveLanguage);
     }
+
+    await this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value }], batchId);
   }
 
   private async setCollectionSetter(key: string, value: any, batchId?: string) {
-    let collectionSetters = await this.#perspective.infer(
-      `subject_class("${this.#subjectClassName}", C), collection_setter(C, "${singularToPlural(key)}", Setter)`
-    );
-    if (!collectionSetters) collectionSetters = [];
-
-    if (collectionSetters.length > 0) {
-      const actions = eval(collectionSetters[0].Setter);
-
-      if (value) {
-        if (Array.isArray(value)) {
-          await this.#perspective.executeAction(
-            actions,
-            this.#baseExpression,
-            value.map((v) => ({ name: "value", value: v })),
-            batchId
-          );
-        } else {
-          await this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value }], batchId);
-        }
+    // Phase 1: Use metadata instead of Prolog queries
+    const metadata = this.getCollectionMetadata(key);
+    if (!metadata) {
+      console.warn(`Collection "${key}" has no metadata, skipping`);
+      return;
+    }
+
+    // Generate actions from metadata (replaces Prolog query)
+    const actions = this.generateCollectionAction(key, 'setter');
+
+    if (value) {
+      if (Array.isArray(value)) {
+        await this.#perspective.executeAction(
+          actions,
+          this.#baseExpression,
+          value.map((v) => ({ name: "value", value: v })),
+          batchId
+        );
+      } else {
+        await this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value }], batchId);
       }
     }
   }
 
   private async setCollectionAdder(key: string, value: any, batchId?: string) {
-    let adders = await this.#perspective.infer(
-      `subject_class("${this.#subjectClassName}", C), collection_adder(C, "${singularToPlural(key)}", Adder)`
-    );
-    if (!adders) adders = [];
-
-    if (adders.length > 0) {
-      const actions = eval(adders[0].Adder);
-      if (value) {
-        if (Array.isArray(value)) {
-          await Promise.all(
-            value.map((v) =>
-              this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value: v }], batchId)
-            )
-          );
-        } else {
-          await this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value }], batchId);
-        }
+    // Phase 1: Use metadata instead of Prolog queries
+    const metadata = this.getCollectionMetadata(key);
+    if (!metadata) {
+      console.warn(`Collection "${key}" has no metadata, skipping`);
+      return;
+    }
+
+    // Generate actions from metadata (replaces Prolog query)
+    const actions = this.generateCollectionAction(key, 'adder');
+
+    if (value) {
+      if (Array.isArray(value)) {
+        await Promise.all(
+          value.map((v) =>
+            this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value: v }], batchId)
+          )
+        );
+      } else {
+        await this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value }], batchId);
       }
     }
   }
 
   private async setCollectionRemover(key: string, value: any, batchId?: string) {
-    let removers = await this.#perspective.infer(
-      `subject_class("${this.#subjectClassName}", C), collection_remover(C, "${singularToPlural(key)}", Remover)`
-    );
-    if (!removers) removers = [];
-
-    if (removers.length > 0) {
-      const actions = eval(removers[0].Remover);
-      if (value) {
-        if (Array.isArray(value)) {
-          await Promise.all(
-            value.map((v) =>
-              this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value: v }], batchId)
-            )
-          );
-        } else {
-          await this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value }], batchId);
-        }
+    // Phase 1: Use metadata instead of Prolog queries
+    const metadata = this.getCollectionMetadata(key);
+    if (!metadata) {
+      console.warn(`Collection "${key}" has no metadata, skipping`);
+      return;
+    }
+
+    // Generate actions from metadata (replaces Prolog query)
+    const actions = this.generateCollectionAction(key, 'remover');
+
+    if (value) {
+      if (Array.isArray(value)) {
+        await Promise.all(
+          value.map((v) =>
+            this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value: v }], batchId)
+          )
+        );
+      } else {
+        await this.#perspective.executeAction(actions, this.#baseExpression, [{ name: "value", value }], batchId);
       }
     }
   }
@@ -2003,10 +2173,20 @@ WHERE ${whereConditions.join(' AND ')}
               await this.setCollectionSetter(key, value.value, batchId);
               break;
           }
-        } else if (Array.isArray(value) && value.length > 0) {
-          await this.setCollectionSetter(key, value, batchId);
+        } else if (Array.isArray(value)) {
+          // Handle all arrays as collections, even empty ones
+          if (value.length > 0) {
+            await this.setCollectionSetter(key, value, batchId);
+          }
+          // Skip empty arrays - don't try to set them as properties
         } else if (value !== undefined && value !== null && value !== "") {
           if (setProperties) {
+            // Check if this is a collection property (has collection metadata)
+            const collMetadata = this.getCollectionMetadata(key);
+            if (collMetadata) {
+              // Skip - it's a collection, not a regular property
+              continue;
+            }
             await this.setProperty(key, value, batchId);
           }
         }