Memory Optimizations

core/src/model/Subject.ts

@@ -50,31 +50,12 @@ export class Subject {
             Object.defineProperty(this, p, {
                 configurable: true,
                 get: async () => {
-                    let results = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), property_getter(C, "${this.#baseExpression}", "${p}", Value)`)
-                    if(results && results.length > 0) {
-                        let expressionURI = results[0].Value
-                        if(resolveExpressionURI) {
-                            try {
-                                if (expressionURI) {
-                                    const expression = await this.#perspective.getExpression(expressionURI)
-                                    try {
-                                        return JSON.parse(expression.data)
-                                    } catch(e) {
-                                        return expression.data
-                                    }
-                                } else {
-                                    return expressionURI
-                                }
-                            } catch (err) {
-                                return expressionURI
-                            }
-                        } else {
-                            return expressionURI
-                        }
-                    } else if(results) {
-                        return results
-                    } else {
-                        return undefined
+                    // Use SurrealDB for data queries
+                    try {
+                        return await this.#perspective.getPropertyValueViaSurreal(this.#baseExpression, this.#subjectClassName, p);
+                    } catch (err) {
+                        console.warn(`Failed to get property ${p} via SurrealDB:`, err);
+                        return undefined;
                     }
                 }
             })
@@ -110,12 +91,12 @@ export class Subject {
             Object.defineProperty(this, c, {
                 configurable: true,
                 get: async () => {
-                    let results = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), collection_getter(C, "${this.#baseExpression}", "${c}", Value)`)
-                    if(results && results.length > 0 && results[0].Value) {
-                        let collectionContent = results[0].Value.filter((v: any) => v !== "" && v !== '')
-                        return collectionContent
-                    } else {
-                        return []
+                    // Use SurrealDB for data queries
+                    try {
+                        return await this.#perspective.getCollectionValuesViaSurreal(this.#baseExpression, this.#subjectClassName, c);
+                    } catch (err) {
+                        console.warn(`Failed to get collection ${c} via SurrealDB:`, err);
+                        return [];
                     }
                 }
             })

core/src/model/decorators.ts

@@ -97,21 +97,48 @@ export function InstanceQuery(options?: InstanceQueryParams) {
                 query += ', ' + options.condition
             }
 
-            let results = await perspective.infer(query)
-            if(results == false) {
-                return instances
-            }
-            if(typeof results == "string") {
-                throw results
+            // Try Prolog first
+            try {
+                let results = await perspective.infer(query)
+                if(results && results !== false && typeof results !== "string" && results.length > 0) {
+                    for(let result of results) {
+                        let instance = result.Instance
+                        let subject = new Subject(perspective, instance, subjectClassName)
+                        await subject.init()
+                        instances.push(subject as T)
+                    }
+                    return instances
+                }
+            } catch (e) {
+                // Prolog failed, fall through to SurrealDB
             }
-            for(let result of results) {
-                let instance = result.Instance
-                let subject = new Subject(perspective, instance, subjectClassName)
-                await subject.init()
-                instances.push(subject as T)
+
+            // Fallback to SurrealDB (SdnaOnly mode)
+            // Get all instances first
+            let allInstances = await perspective.getAllSubjectInstances(subjectClassName)
+
+            // Filter by where clause if provided
+            if(options && options.where) {
+                let filtered = []
+                for(let instance of allInstances) {
+                    let matches = true
+                    for(let prop in options.where) {
+                        let expectedValue = options.where[prop]
+                        //@ts-ignore
+                        let actualValue = await instance[prop]
+                        if(actualValue !== expectedValue) {
+                            matches = false
+                            break
+                        }
+                    }
+                    if(matches) {
+                        filtered.push(instance as T)
+                    }
+                }
+                return filtered
             }
 
-            return instances
+            return allInstances as T[]
         }
     };
 }