Enhanced SubjectEntity Query System

CHANGELOG

@@ -25,6 +25,7 @@ This project _loosely_ adheres to [Semantic Versioning](https://semver.org/spec/
 - Fix error after spawning AI task [PR#559](https://github.com/coasys/ad4m/pull/559)
 - Fix some problems with perspective.removeLinks() with a proper implementation [PR#563](https://github.com/coasys/ad4m/pull/563)
 - Ad4mConnect detects running local ADAM agent on first open - no need to click try again [](https://github.com/coasys/ad4m/pull/570)
+- Fix multiple synchronous addSignalHandler calls losing the first handler - fixing usage of NH.sendSignal() [PR#576](https://github.com/coasys/ad4m/pull/576)
 
 ### Added
 - Prolog predicates needed in new Flux mention notification trigger:
@@ -52,8 +53,9 @@ This project _loosely_ adheres to [Semantic Versioning](https://semver.org/spec/
 - Models can also be added straight from a local file [PR#565](https://github.com/coasys/ad4m/pull/565)
 - Enable fine-tuning of voice detection parameters for transcription streams [PR#566](https://github.com/coasys/ad4m/pull/566)
 - Neighbourhood p2p signal: optional loopback sending signals to all connected apps/UIs of the sending agent [PR#568](https://github.com/coasys/ad4m/pull/568)
-- DB and Perspective to JSON exports and imports [PR#569](https://github.com/coasys/ad4m/pull/569)
-
+- DB and Perspective to JSON exports and imports [PR#569](https://github.com/coasys/ad4m/pull/569) 
+- Enhanced SubjectEntity query mechanism with where-queries, that compiles complex queries down to Prolog which can be subscribed to [PR#575](https://github.com/coasys/ad4m/pull/575)
+
 ### Changed
 - Partially migrated the Runtime service to Rust. (DM language installation for agents is pending.) [PR#466](https://github.com/coasys/ad4m/pull/466)
 - Improved performance of SDNA / SubjectClass functions by moving code from client into executor and saving a lot of client <-> executor roundtrips [PR#480](https://github.com/coasys/ad4m/pull/480)

core/src/Literal.ts

@@ -27,7 +27,7 @@ export class Literal {
     toUrl(): string {
         if(this.#url && !this.#literal)
             return this.#url
-        if(!this.#url && !this.#literal)
+        if(!this.#url && (this.#literal === undefined || this.#literal === "" || this.#literal === null))
             throw new Error("Can't turn empty Literal into URL")
 
         let encoded
@@ -38,6 +38,9 @@ export class Literal {
             case 'number':
                 encoded = `number:${encodeRFC3986URIComponent(this.#literal)}`
                 break;
+            case 'boolean':
+                encoded = `boolean:${encodeRFC3986URIComponent(this.#literal)}`
+                break;
             case 'object':
                 encoded = `json:${encodeRFC3986URIComponent(JSON.stringify(this.#literal))}`
                 break;

core/src/perspectives/PerspectiveClient.ts

@@ -10,6 +10,7 @@ import { Perspective } from "./Perspective";
 import { PerspectiveHandle, PerspectiveState } from "./PerspectiveHandle";
 import { LinkStatus, PerspectiveProxy } from './PerspectiveProxy';
 import { AIClient } from "../ai/AIClient";
+import { AllInstancesResult } from "../subject/SubjectEntity";
 
 const LINK_EXPRESSION_FIELDS = `
 author
@@ -154,7 +155,7 @@ export class PerspectiveClient {
         return JSON.parse(perspectiveQueryProlog)
     }
 
-    async subscribeQuery(uuid: string, query: string): Promise<{ subscriptionId: string, result: string }> {
+    async subscribeQuery(uuid: string, query: string): Promise<{ subscriptionId: string, result: AllInstancesResult }> {
         const { perspectiveSubscribeQuery } = unwrapApolloResult(await this.#apolloClient.mutate({
             mutation: gql`mutation perspectiveSubscribeQuery($uuid: String!, $query: String!) {
                 perspectiveSubscribeQuery(uuid: $uuid, query: $query) {
@@ -164,11 +165,17 @@ export class PerspectiveClient {
             }`,
             variables: { uuid, query }
         }))
-
-        return perspectiveSubscribeQuery
+        const { subscriptionId, result } = perspectiveSubscribeQuery
+        let finalResult = result;
+        try {
+            finalResult = JSON.parse(result)
+        } catch (e) {
+            console.error('Error parsing perspectiveSubscribeQuery result:', e)
+        }
+        return { subscriptionId, result: finalResult }
     }
 
-    subscribeToQueryUpdates(subscriptionId: string, onData: (result: string) => void): () => void {
+    subscribeToQueryUpdates(subscriptionId: string, onData: (result: AllInstancesResult) => void): () => void {
         const subscription = this.#apolloClient.subscribe({
             query: gql`
                 subscription perspectiveQuerySubscription($subscriptionId: String!) {
@@ -181,7 +188,13 @@ export class PerspectiveClient {
         }).subscribe({
             next: (result) => {
                 if (result.data && result.data.perspectiveQuerySubscription) {
-                    onData(result.data.perspectiveQuerySubscription);
+                    let finalResult = result.data.perspectiveQuerySubscription;
+                    try {
+                        finalResult = JSON.parse(result.data.perspectiveQuerySubscription)
+                    } catch (e) {
+                        console.error('Error parsing perspectiveQuerySubscription:', e)
+                    }
+                    onData(finalResult);
                 }
             },
             error: (e) => console.error('Error in query subscription:', e)

core/src/perspectives/PerspectiveProxy.ts

@@ -12,8 +12,9 @@ import { NeighbourhoodExpression } from "../neighbourhood/Neighbourhood";
 import { AIClient } from "../ai/AIClient";
 import { PERSPECTIVE_QUERY_SUBSCRIPTION } from "./PerspectiveResolver";
 import { gql } from "@apollo/client/core";
+import { AllInstancesResult } from "../subject/SubjectEntity";
 
-type QueryCallback = (result: string) => void;
+type QueryCallback = (result: AllInstancesResult) => void;
 
 // Generic subscription interface that matches Apollo's Subscription
 interface Unsubscribable {
@@ -53,7 +54,7 @@ export class QuerySubscriptionProxy {
     #callbacks: Set<QueryCallback>;
     #keepaliveTimer: number;
     #unsubscribe?: () => void;
-    #latestResult: string;
+    #latestResult: AllInstancesResult;
     #disposed: boolean = false;
 
     /** Creates a new query subscription
@@ -62,7 +63,7 @@ export class QuerySubscriptionProxy {
      * @param initialResult - The initial query result
      * @param client - The PerspectiveClient instance to use for communication
      */
-    constructor(uuid: string, subscriptionId: string, initialResult: string, client: PerspectiveClient) {
+    constructor(uuid: string, subscriptionId: string, initialResult: AllInstancesResult, client: PerspectiveClient) {
         this.#uuid = uuid;
         this.#subscriptionId = subscriptionId;
         this.#client = client;
@@ -109,7 +110,7 @@ export class QuerySubscriptionProxy {
      * 
      * @returns The latest query result as a string (usually a JSON array of bindings)
      */
-    get result(): string {
+    get result(): AllInstancesResult {
         return this.#latestResult;
     }
 
@@ -138,7 +139,7 @@ export class QuerySubscriptionProxy {
     }
 
     /** Internal method to notify all callbacks of a new result */
-    #notifyCallbacks(result: string) {
+    #notifyCallbacks(result: AllInstancesResult) {
         for (const callback of this.#callbacks) {
             try {
                 callback(result);
@@ -450,7 +451,7 @@ export class PerspectiveProxy {
         }
     }
 
-    async stringOrTemplateObjectToSubjectClass<T>(subjectClass: T): Promise<string> {
+    async stringOrTemplateObjectToSubjectClassName<T>(subjectClass: T): Promise<string> {
         if(typeof subjectClass === "string")
             return subjectClass
         else {
@@ -505,7 +506,7 @@ export class PerspectiveProxy {
      * @param exprAddr The address of the expression to be turned into a subject instance
      */
     async removeSubject<T>(subjectClass: T, exprAddr: string) {
-        let className = await this.stringOrTemplateObjectToSubjectClass(subjectClass)
+        let className = await this.stringOrTemplateObjectToSubjectClassName(subjectClass)
         let result = await this.infer(`subject_class("${className}", C), destructor(C, Actions)`)
         if(!result.length) {
             throw "No constructor found for given subject class: " + className
@@ -522,7 +523,7 @@ export class PerspectiveProxy {
      * that matches the given properties will be used.
     */
     async isSubjectInstance<T>(expression: string, subjectClass: T): Promise<boolean> {
-        let className = await this.stringOrTemplateObjectToSubjectClass(subjectClass)
+        let className = await this.stringOrTemplateObjectToSubjectClassName(subjectClass)
         let isInstance = false;
         const maxAttempts = 5;
         let attempts = 0;
@@ -549,7 +550,7 @@ export class PerspectiveProxy {
         if(!await this.isSubjectInstance(base, subjectClass)) {
             throw `Expression ${base} is not a subject instance of given class: ${JSON.stringify(subjectClass)}`
         }
-        let className = await this.stringOrTemplateObjectToSubjectClass(subjectClass)
+        let className = await this.stringOrTemplateObjectToSubjectClassName(subjectClass)
         let subject = new Subject(this, base, className)
         await subject.init()
         return subject as unknown as T

core/src/subject/Subject.ts

@@ -7,18 +7,18 @@ import { collectionSetterToName, collectionToAdderName, collectionToRemoverName,
  */
 export class Subject {
     #baseExpression: string;
-    #subjectClass: string;
+    #subjectClassName: string;
     #perspective: PerspectiveProxy
 
     /**
      * Constructs a new subject.
      * @param perspective - The perspective that the subject belongs to.
      * @param baseExpression - The base expression of the subject.
-     * @param subjectClass - The class of the subject.
+     * @param subjectClassName - The class name of the subject.
      */
-    constructor(perspective: PerspectiveProxy, baseExpression: string, subjectClass: string) {
+    constructor(perspective: PerspectiveProxy, baseExpression: string, subjectClassName: string) {
         this.#baseExpression = baseExpression
-        this.#subjectClass = subjectClass
+        this.#subjectClassName = subjectClassName
         this.#perspective = perspective
     }
 
@@ -36,21 +36,21 @@ export class Subject {
      */
     async init() {
         // Check if the subject is a valid instance of the subject class
-        let isInstance = await this.#perspective.isSubjectInstance(this.#baseExpression, this.#subjectClass)
+        let isInstance = await this.#perspective.isSubjectInstance(this.#baseExpression, this.#subjectClassName)
         if(!isInstance) {
-            throw `Not a valid subject instance of ${this.#subjectClass} for ${this.#baseExpression}`
+            throw `Not a valid subject instance of ${this.#subjectClassName} for ${this.#baseExpression}`
         }
 
         // Define properties and collections dynamically
-        let results = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), property(C, Property)`)
+        let results = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), property(C, Property)`)
         let properties = results.map(result => result.Property)
 
         for(let p of properties) {
-            const resolveExpressionURI = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), property_resolve(C, "${p}")`)
+            const resolveExpressionURI = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), property_resolve(C, "${p}")`)
             Object.defineProperty(this, p, {
                 configurable: true,
                 get: async () => {
-                    let results = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), property_getter(C, "${this.#baseExpression}", "${p}", Value)`)
+                    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) {
@@ -81,13 +81,13 @@ export class Subject {
         }
 
         // Define setters
-        const setters = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), property_setter(C, Property, Setter)`)
+        const setters = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), property_setter(C, Property, Setter)`)
 
         for(let setter of (setters ? setters : [])) {
             if(setter) {
                 const property = setter.Property
                 const actions = eval(setter.Setter)
-                const resolveLanguageResults = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), property_resolve_language(C, "${property}", Language)`)
+                const resolveLanguageResults = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), property_resolve_language(C, "${property}", Language)`)
                 let resolveLanguage
                 if(resolveLanguageResults && resolveLanguageResults.length > 0) {
                     resolveLanguage = resolveLanguageResults[0].Language
@@ -102,15 +102,15 @@ export class Subject {
         }
 
         // Define collections
-        let results2 = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), collection(C, Collection)`)
+        let results2 = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), collection(C, Collection)`)
         if(!results2) results2 = []
         let collections = results2.map(result => result.Collection)
 
         for(let c of collections) {
             Object.defineProperty(this, c, {
                 configurable: true,
                 get: async () => {
-                    let results = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), collection_getter(C, "${this.#baseExpression}", "${c}", Value)`)
+                    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
@@ -122,7 +122,7 @@ export class Subject {
         }
 
         // Define collection adders
-        let adders = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), collection_adder(C, Collection, Adder)`)
+        let adders = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), collection_adder(C, Collection, Adder)`)
         if(!adders) adders = []
 
         for(let adder of adders) {
@@ -140,7 +140,7 @@ export class Subject {
         }
 
         // Define collection removers
-        let removers = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), collection_remover(C, Collection, Remover)`)
+        let removers = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), collection_remover(C, Collection, Remover)`)
         if(!removers) removers = []
 
         for(let remover of removers) {
@@ -158,7 +158,7 @@ export class Subject {
         }
 
         // Define collection setters
-        let collectionSetters = await this.#perspective.infer(`subject_class("${this.#subjectClass}", C), collection_setter(C, Collection, Setter)`)
+        let collectionSetters = await this.#perspective.infer(`subject_class("${this.#subjectClassName}", C), collection_setter(C, Collection, Setter)`)
         if(!collectionSetters) collectionSetters = []
 
         for(let collectionSetter of collectionSetters) {