Add where to SubjectEntity's query()

CHANGELOG

@@ -44,6 +44,7 @@ This project _loosely_ adheres to [Semantic Versioning](https://semver.org/spec/
 - Add `author` and `timestamp` to SubjectEntity objects [PR#557](https://github.com/coasys/ad4m/pull/557)
 - Make `SubjectEntity.#perspective` protected to enable subclasses to implement complex fields and methods [PR#557](https://github.com/coasys/ad4m/pull/557)
 - Add AI client to PerspectiveProxy to enable SubjectEntity sub-classes (subject classes) to use AI processes without having to rely on ad4m-connect or similar to access the AI client. [PR#558](https://github.com/coasys/ad4m/pull/558)
+- SubjectEntity.query() with `where: { propertyName: "value" }` and `where: { condition: 'triple(Base, _, "...")'} [PR#560](https://github.com/coasys/ad4m/pull/560)
 
 ### Changed
 - Partially migrated the Runtime service to Rust. (DM language installation for agents is pending.) [PR#466](https://github.com/coasys/ad4m/pull/466)

core/src/subject/SubjectEntity.ts

@@ -264,13 +264,27 @@ export class SubjectEntity {
     let subjectClass = await perspective.stringOrTemplateObjectToSubjectClass(this)
 
     let res = [];
+    let instanceConditions = `subject_class("${subjectClass}", C), instance(C, Base), link("${source}", Predicate, Base, Timestamp, Author)`
+
+    if (query) {  
+      if(query.where) {
+        if(query.where["condition"]) {
+          instanceConditions += ", " + query.where["condition"]
+        } else {
+          const pairs = Object.entries(query.where);
+          for(let p of pairs) {
+            const propertyName = p[0];
+            const propertyValue = p[1];
+            instanceConditions += `, property_getter(C, Base, "${propertyName}", "${propertyValue}")`
+          }
+        }
+      }
 
-    if (query) {
       try {
-        const queryResponse = (await perspective.infer(`findall([Timestamp, Base], (subject_class("${subjectClass}", C), instance(C, Base), link("${source}", Predicate, Base, Timestamp, Author)), AllData), sort(AllData, SortedData), length(SortedData, DataLength).`))[0]
+        const queryResponse = (await perspective.infer(`findall([Timestamp, Base], (${instanceConditions}), AllData), sort(AllData, SortedData), length(SortedData, DataLength).`))[0]
 
         if (queryResponse.DataLength >= query.size) {
-          const mainQuery = `findall([Timestamp, Base], (subject_class("${subjectClass}", C), instance(C, Base), link("${source}", Predicate, Base, Timestamp, Author)), AllData), sort(AllData, SortedData), reverse(SortedData, ReverseSortedData), paginate(ReverseSortedData, ${query.page}, ${query.size}, PageData).`
+          const mainQuery = `findall([Timestamp, Base], (${instanceConditions}), AllData), sort(AllData, SortedData), reverse(SortedData, ReverseSortedData), paginate(ReverseSortedData, ${query.page}, ${query.size}, PageData).`
 
           res = await perspective.infer(mainQuery);
 
@@ -279,17 +293,13 @@ export class SubjectEntity {
             Timestamp: r[0]
           }))
         } else {
-          res = await perspective.infer(
-            `subject_class("${subjectClass}", C), instance(C, Base), triple("${source}", Predicate, Base).`
-          );
+          res = await perspective.infer(instanceConditions);
         }
       } catch (e) {
         console.log("Query failed", e);
       }
     } else {
-      res = await perspective.infer(
-        `subject_class("${subjectClass}", C), instance(C, Base), triple("${source}", Predicate, Base).`
-      );
+      res = await perspective.infer(instanceConditions);
     }
 
     if (!res) return [];
@@ -320,4 +330,7 @@ export type SubjectEntityQueryParam = {
 
   // The page of the query.
   page?: number;
+
+  // conditions on properties
+  where?: { condition?: string } | object;
 }

tests/js/tests/prolog-and-literals.test.ts

@@ -694,24 +694,43 @@ describe("Prolog + Literals", () => {
 
                 it("query()", async () => {
                     let recipes = await Recipe.query(perspective!, { page: 1, size: 2 });
-
                     expect(recipes.length).to.equal(2)
 
                     recipes = await Recipe.query(perspective!, { page: 2, size: 1 });
+                    expect(recipes.length).to.equal(1)
+
+                    const testName = "recipe://where_test"
+
+                    recipes = await Recipe.query(perspective!, { where: { name: testName }})
+                    expect(recipes.length).to.equal(0)
+
+                    let root = Literal.from("Where test").toUrl()
+                    const whereTestRecipe = new Recipe(perspective!, root)
+                    whereTestRecipe.name = testName
+                    await whereTestRecipe.save()
 
+                    recipes = await Recipe.query(perspective!, { where: { name: testName }})
                     expect(recipes.length).to.equal(1)
+
+                    recipes = await Recipe.query(perspective!, { where: { condition: `triple(Base, _, "ad4m://test_self")` }})
+                    expect(recipes.length).to.equal(0)
+
+                    await perspective?.add({source: root, target: "ad4m://test_self"})
+                    recipes = await Recipe.query(perspective!, { where: { condition: `triple(Base, _, "ad4m://test_self")` }})
+                    expect(recipes.length).to.equal(1)
+
                 })
 
                 it("delete()", async () => {
                     const recipe2 = await Recipe.all(perspective!);
 
-                    expect(recipe2.length).to.equal(3)
+                    expect(recipe2.length).to.equal(4)
 
                     await recipe2[0].delete();
 
                     const recipe3 = await Recipe.all(perspective!);
 
-                    expect(recipe3.length).to.equal(2)
+                    expect(recipe3.length).to.equal(3)
                 })
 
                 it("can constrain collection entries through 'where' clause with prolog condition", async () => {