@xyo-network/bridge-pub-sub 2.94.11 → 2.94.13

package/dist/browser/index.js

@@ -10,7 +10,7 @@ var AbstractModuleHost = class extends Base {
 };
 
 // src/AsyncQueryBus/AsyncQueryBusClient.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
+import { assertEx } from "@xylabs/assert";
 import { delay } from "@xylabs/delay";
 import { forget } from "@xylabs/forget";
 import { clearTimeoutEx, setTimeoutEx } from "@xylabs/timer";
@@ -20,7 +20,6 @@ import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { LRUCache as LRUCache2 } from "lru-cache";
 
 // src/AsyncQueryBus/AsyncQueryBusBase.ts
-import { assertEx } from "@xylabs/assert";
 import { Base as Base2, toJsonString } from "@xylabs/object";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 import { asDivinerInstance } from "@xyo-network/diviner-model";
@@ -34,13 +33,13 @@ var AsyncQueryBusBase = class extends Base2 {
   _targetQueries = {};
   _lastQueriesArchivistAttempt;
   _lastQueriesDivinerAttempt;
-  _lastResponseArchivistAttempt;
-  _lastResponseDivinerAttempt;
+  _lastResponsesArchivistAttempt;
+  _lastResponsesDivinerAttempt;
   _queriesArchivist;
   _queriesDiviner;
-  _reResolveDelay = 5e3;
-  _responseArchivist;
-  _responseDiviner;
+  _reResolveDelay = 5e4;
+  _responsesArchivist;
+  _responsesDiviner;
   constructor(params) {
     super(params);
   }
@@ -68,46 +67,81 @@ var AsyncQueryBusBase = class extends Base2 {
     if (this._queriesArchivist) {
       return this._queriesArchivist;
     }
-    if (this._lastQueriesArchivistAttempt && Date.now() - this._lastQueriesArchivistAttempt < this._reResolveDelay) {
+    if (Date.now() - (this._lastQueriesArchivistAttempt ?? 0) < this._reResolveDelay) {
       return;
     }
-    const resolved = await this.resolver.resolve(this.config?.intersect?.queries?.archivist, {
-      direction: "up"
-    });
-    const existingResolved = assertEx(resolved, () => `Unable to resolve queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
-    const result = asArchivistInstance(existingResolved, () => `Unable to resolve queriesArchivist as correct type [${this.config?.intersect?.queries?.archivist}][${existingResolved?.constructor?.name}]: ${toJsonString(existingResolved)}`);
-    this._queriesArchivist = result;
-    return result;
+    this._lastQueriesArchivistAttempt = Date.now();
+    const resolved = await this.resolver.resolve(this.config?.intersect?.queries?.archivist);
+    if (resolved) {
+      const typedResolve = asArchivistInstance(resolved);
+      if (typedResolve) {
+        return typedResolve;
+      } else {
+        this.logger?.warn(`Unable to resolve queriesArchivist as correct type [${this.config?.intersect?.queries?.archivist}][${resolved?.constructor?.name}]: ${toJsonString(resolved)}`);
+      }
+    } else {
+      this.logger?.log(`Unable to resolve queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    }
   }
   async queriesDiviner() {
     if (this._queriesDiviner) {
       return this._queriesDiviner;
     }
-    if (this._lastQueriesDivinerAttempt && Date.now() - this._lastQueriesDivinerAttempt < this._reResolveDelay) {
+    if (Date.now() - (this._lastQueriesDivinerAttempt ?? 0) < this._reResolveDelay) {
       return;
     }
-    this._queriesDiviner = assertEx(asDivinerInstance(await this.resolver.resolve(this.config?.intersect?.queries?.boundWitnessDiviner)), () => `Unable to resolve queriesDiviner [${this.config?.intersect?.queries?.boundWitnessDiviner}]`);
-    return this._queriesDiviner;
+    this._lastQueriesDivinerAttempt = Date.now();
+    const resolved = await this.resolver.resolve(this.config?.intersect?.queries?.boundWitnessDiviner);
+    if (resolved) {
+      const typedResolve = asDivinerInstance(resolved);
+      if (typedResolve) {
+        return typedResolve;
+      } else {
+        this.logger?.warn(`Unable to resolve queriesDiviner as correct type [${this.config?.intersect?.queries?.boundWitnessDiviner}][${resolved?.constructor?.name}]: ${toJsonString(resolved)}`);
+      }
+    } else {
+      this.logger?.log(`Unable to resolve queriesDiviner [${this.config?.intersect?.queries?.boundWitnessDiviner}]`);
+    }
   }
   async responsesArchivist() {
-    if (this._responseArchivist) {
-      return this._responseArchivist;
+    if (this._responsesArchivist) {
+      return this._responsesArchivist;
     }
-    if (this._lastResponseArchivistAttempt && Date.now() - this._lastResponseArchivistAttempt < this._reResolveDelay) {
+    if (Date.now() - (this._lastResponsesArchivistAttempt ?? 0) < this._reResolveDelay) {
       return;
     }
-    this._responseArchivist = assertEx(asArchivistInstance(await this.resolver.resolve(this.config?.intersect?.responses?.archivist)), () => `Unable to resolve responsesArchivist [${this.config?.intersect?.responses?.archivist}]`);
-    return this._responseArchivist;
+    this._lastResponsesArchivistAttempt = Date.now();
+    const resolved = await this.resolver.resolve(this.config?.intersect?.responses?.archivist);
+    if (resolved) {
+      const typedResolve = asArchivistInstance(resolved);
+      if (typedResolve) {
+        return typedResolve;
+      } else {
+        this.logger?.warn(`Unable to resolve responseArchivist as correct type [${this.config?.intersect?.responses?.archivist}][${resolved?.constructor?.name}]: ${toJsonString(resolved)}`);
+      }
+    } else {
+      this.logger?.log(`Unable to resolve responseArchivist [${this.config?.intersect?.responses?.archivist}]`);
+    }
   }
   async responsesDiviner() {
-    if (this._responseDiviner) {
-      return this._responseDiviner;
+    if (this._responsesDiviner) {
+      return this._responsesDiviner;
     }
-    if (this._lastResponseDivinerAttempt && Date.now() - this._lastResponseDivinerAttempt < this._reResolveDelay) {
+    if (Date.now() - (this._lastResponsesDivinerAttempt ?? 0) < this._reResolveDelay) {
       return;
     }
-    this._responseDiviner = assertEx(asDivinerInstance(await this.resolver.resolve(this.config?.intersect?.responses?.boundWitnessDiviner)), () => `Unable to resolve responsesDiviner [${this.config?.intersect?.responses?.boundWitnessDiviner}]`);
-    return this._responseDiviner;
+    this._lastResponsesDivinerAttempt = Date.now();
+    const resolved = await this.resolver.resolve(this.config?.intersect?.responses?.boundWitnessDiviner);
+    if (resolved) {
+      const typedResolve = asDivinerInstance(resolved);
+      if (typedResolve) {
+        return typedResolve;
+      } else {
+        this.logger?.warn(`Unable to resolve responsesDiviner as correct type [${this.config?.intersect?.responses?.boundWitnessDiviner}][${resolved?.constructor?.name}]: ${toJsonString(resolved)}`);
+      }
+    } else {
+      this.logger?.log(`Unable to resolve responsesDiviner [${this.config?.intersect?.responses?.boundWitnessDiviner}]`);
+    }
   }
   /**
   * Commit the internal state of the process. This is similar
@@ -196,7 +230,7 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
       ...query,
       $meta
     });
-    const queryArchivist = assertEx2(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const queryArchivist = assertEx(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
     const routedQueryHash = (
       // Trust the signed hash if it's there
       routedQuery?.$hash ?? // TODO: What is the right way to find the dataHash
@@ -272,34 +306,38 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
   * Background process for processing incoming responses to previously issued queries
   */
   processIncomingResponses = async () => {
-    const responseArchivist = assertEx2(await this.responsesArchivist(), () => `Unable to contact the responsesArchivist [${this.config?.intersect?.responses?.archivist}]`);
-    const responseBoundWitnessDiviner = assertEx2(await this.responsesDiviner(), () => `Unable to contact responsesDiviner [${this.config?.intersect?.responses?.boundWitnessDiviner}]`);
-    const pendingCommands = [
-      ...this.queryCache.entries()
-    ].filter(([_, status]) => status === Pending);
-    await Promise.allSettled(pendingCommands.map(async ([sourceQuery, status]) => {
-      if (status === Pending) {
-        const divinerQuery = {
-          schema: BoundWitnessDivinerQuerySchema,
-          sourceQuery
-        };
-        const result = await responseBoundWitnessDiviner.divine([
-          divinerQuery
-        ]);
-        if (result && result.length > 0) {
-          const response = result.find(isBoundWitnessWithMeta);
-          if (response && response?.$meta?.sourceQuery === sourceQuery) {
-            this.logger?.debug(`Found response to query: ${sourceQuery}`);
-            const payloads = response.payload_hashes?.length > 0 ? await responseArchivist.get(response.payload_hashes) : [];
-            this.queryCache.set(sourceQuery, [
-              response,
-              payloads,
-              []
+    const responseArchivist = await this.responsesArchivist();
+    if (responseArchivist) {
+      const responseBoundWitnessDiviner = await this.responsesDiviner();
+      if (responseBoundWitnessDiviner) {
+        const pendingCommands = [
+          ...this.queryCache.entries()
+        ].filter(([_, status]) => status === Pending);
+        await Promise.allSettled(pendingCommands.map(async ([sourceQuery, status]) => {
+          if (status === Pending) {
+            const divinerQuery = {
+              schema: BoundWitnessDivinerQuerySchema,
+              sourceQuery
+            };
+            const result = await responseBoundWitnessDiviner.divine([
+              divinerQuery
             ]);
+            if (result && result.length > 0) {
+              const response = result.find(isBoundWitnessWithMeta);
+              if (response && response?.$meta?.sourceQuery === sourceQuery) {
+                this.logger?.debug(`Found response to query: ${sourceQuery}`);
+                const payloads = response.payload_hashes?.length > 0 ? await responseArchivist.get(response.payload_hashes) : [];
+                this.queryCache.set(sourceQuery, [
+                  response,
+                  payloads,
+                  []
+                ]);
+              }
+            }
           }
-        }
+        }));
       }
-    }));
+    }
   };
   start() {
     if (this._pollCount === 0) {
@@ -320,7 +358,7 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
 
 // src/AsyncQueryBus/AsyncQueryBusHost.ts
 import { containsAll } from "@xylabs/array";
-import { assertEx as assertEx3 } from "@xylabs/assert";
+import { assertEx as assertEx2 } from "@xylabs/assert";
 import { clearTimeoutEx as clearTimeoutEx2, setTimeoutEx as setTimeoutEx2 } from "@xylabs/timer";
 import { isQueryBoundWitnessWithMeta } from "@xyo-network/boundwitness-model";
 import { BoundWitnessDivinerQuerySchema as BoundWitnessDivinerQuerySchema2 } from "@xyo-network/diviner-boundwitness-model";
@@ -347,7 +385,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
   }
   expose(address, options = {}) {
     const { failOnAlreadyExposed } = options;
-    assertEx3(!failOnAlreadyExposed || !this._exposedAddresses.has(address), () => `Address already exposed [${address}]`);
+    assertEx2(!failOnAlreadyExposed || !this._exposedAddresses.has(address), () => `Address already exposed [${address}]`);
     this._exposedAddresses.add(address);
     this._exposeOptions[address] = {
       ...options
@@ -359,7 +397,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
       ...this.config?.listeningModules ?? [],
       ...this.exposedAddresses.values()
     ];
-    const mods = await Promise.all(exposedModules.map(async (listeningModule) => assertEx3(asModuleInstance(await this.resolver.resolve(listeningModule)), () => `Unable to resolve listeningModule [${listeningModule}]`)));
+    const mods = await Promise.all(exposedModules.map(async (listeningModule) => assertEx2(asModuleInstance(await this.resolver.resolve(listeningModule)), () => `Unable to resolve listeningModule [${listeningModule}]`)));
     return mods;
   }
   start() {
@@ -377,15 +415,15 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
     this._pollId = void 0;
   }
   unexpose(address, validate = true) {
-    assertEx3(!validate || this._exposedAddresses.has(address), () => `Address not exposed [${address}]`);
+    assertEx2(!validate || this._exposedAddresses.has(address), () => `Address not exposed [${address}]`);
     this._exposedAddresses.delete(address);
     delete this._exposeOptions[address];
     this.logger?.debug(`${address} unexposed`);
   }
   callLocalModule = async (localModule, query) => {
     const localModuleName = localModule.config.name ?? localModule.address;
-    const queryArchivist = assertEx3(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
-    const responsesArchivist = assertEx3(await this.responsesArchivist(), () => `Unable to contact responsesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const queryArchivist = assertEx2(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const responsesArchivist = assertEx2(await this.responsesArchivist(), () => `Unable to contact responsesArchivist [${this.config?.intersect?.queries?.archivist}]`);
     const queryDestination = query.$meta?.destination;
     if (queryDestination && queryDestination?.includes(localModule.address)) {
       const queryIndex = query.payload_hashes.indexOf(query.query);
@@ -432,26 +470,30 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
   * @param address The address to find commands for
   */
   findQueriesToAddress = async (address) => {
-    const queryBoundWitnessDiviner = assertEx3(await this.queriesDiviner(), () => `Unable to resolve queriesDiviner [${this.config?.intersect?.queries?.boundWitnessDiviner}]`);
-    const timestamp = await this.retrieveState(address);
-    const destination = [
-      address
-    ];
-    const limit = this.perAddressBatchQueryLimit;
-    const divinerQuery = {
-      destination,
-      limit,
-      schema: BoundWitnessDivinerQuerySchema2,
-      sort: "asc",
-      timestamp
-    };
-    const result = await queryBoundWitnessDiviner.divine([
-      divinerQuery
-    ]);
-    const queries = result.filter(isQueryBoundWitnessWithMeta);
-    const nextState = queries.length > 0 ? Math.max(...queries.map((c) => c.timestamp ?? 0)) + 1 : timestamp;
-    await this.commitState(address, nextState);
-    return queries;
+    const queryBoundWitnessDiviner = await this.queriesDiviner();
+    if (queryBoundWitnessDiviner) {
+      const timestamp = await this.retrieveState(address);
+      const destination = [
+        address
+      ];
+      const limit = this.perAddressBatchQueryLimit;
+      const divinerQuery = {
+        destination,
+        limit,
+        schema: BoundWitnessDivinerQuerySchema2,
+        sort: "asc",
+        timestamp
+      };
+      const result = await queryBoundWitnessDiviner.divine([
+        divinerQuery
+      ]);
+      const queries = result.filter(isQueryBoundWitnessWithMeta);
+      const nextState = queries.length > 0 ? Math.max(...queries.map((c) => c.timestamp ?? 0)) + 1 : timestamp;
+      await this.commitState(address, nextState);
+      return queries;
+    } else {
+      this.logger?.warn(`Unable to resolve queryBoundWitnessDiviner [${this.config?.intersect?.queries?.boundWitnessDiviner}]`);
+    }
   };
   /**
   * Runs the background divine process on a loop with a delay
@@ -481,7 +523,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
       try {
         const localModuleName = localModule.config.name ?? localModule.address;
         this.logger?.debug(`Checking for inbound queries to ${localModuleName} [${localModule.address}]`);
-        const queries = await this.findQueriesToAddress(localModule.address);
+        const queries = await this.findQueriesToAddress(localModule.address) ?? [];
         if (queries.length === 0)
           return;
         this.logger?.debug(`Found queries addressed to local module: ${localModuleName}`);
@@ -544,13 +586,13 @@ var PubSubBridgeSchema = "network.xyo.bridge.pubsub";
 var PubSubBridgeConfigSchema = `${PubSubBridgeSchema}.config`;
 
 // src/PubSubBridge.ts
-import { assertEx as assertEx5 } from "@xylabs/assert";
+import { assertEx as assertEx4 } from "@xylabs/assert";
 import { exists } from "@xylabs/exists";
 import { AbstractBridge } from "@xyo-network/abstract-bridge";
 import { creatableModule } from "@xyo-network/module-model";
 
 // src/PubSubBridgeModuleResolver.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx3 } from "@xylabs/assert";
 import { isAddress } from "@xylabs/hex";
 import { AbstractBridgeModuleResolver, wrapModuleWithType } from "@xyo-network/abstract-bridge";
 import { Account } from "@xyo-network/account";
@@ -567,16 +609,16 @@ var PubSubBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
     }
     const idParts = id.split(":");
     const firstPart = idParts.shift();
-    assertEx4(isAddress(firstPart), () => `Invalid module address: ${firstPart}`);
+    assertEx3(isAddress(firstPart), () => `Invalid module address: ${firstPart}`);
     const remainderParts = idParts.join(":");
     const account = Account.randomSync();
     const params = {
       account,
-      busClient: this.options.busClient,
+      busClient: this.params.busClient,
       config: {
         schema: ModuleConfigSchema2
       },
-      host: this.options.bridge,
+      host: this.params.bridge,
       moduleAddress: firstPart
     };
     const proxy = new AsyncQueryBusModuleProxy(params);
@@ -584,13 +626,13 @@ var PubSubBridgeModuleResolver = class extends AbstractBridgeModuleResolver {
       const state = await proxy.state();
       if (state) {
         const configSchema = state.find((payload) => payload.schema === ConfigSchema)?.config;
-        const config = assertEx4(state.find((payload) => payload.schema === configSchema), () => "Unable to locate config");
+        const config = assertEx3(state.find((payload) => payload.schema === configSchema), () => "Unable to locate config");
         proxy.setConfig(config);
       }
     }
     await proxy.start?.();
     const wrapped = wrapModuleWithType(proxy, account);
-    const as = assertEx4(asModuleInstance2(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
+    const as = assertEx3(asModuleInstance2(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
     proxy.upResolver.add(as);
     proxy.downResolver.add(as);
     this.add(as);
@@ -629,7 +671,7 @@ var PubSubBridge = class extends AbstractBridge {
   get resolver() {
     this._resolver = this._resolver ?? new PubSubBridgeModuleResolver({
       bridge: this,
-      busClient: assertEx5(this.busClient(), () => "busClient not configured"),
+      busClient: assertEx4(this.busClient(), () => "busClient not configured"),
       wrapperAccount: this.account
     });
     return this._resolver;
@@ -638,7 +680,7 @@ var PubSubBridge = class extends AbstractBridge {
     return `${this.config.name ?? moduleName}`;
   }
   get roots() {
-    return assertEx5(this.config.roots, () => "roots not configured");
+    return assertEx4(this.config.roots, () => "roots not configured");
   }
   async discoverRoots() {
     const rootInstances = (await Promise.all(this.roots.map(async (root) => await this.resolver.resolve(root)))).filter(exists);
@@ -649,9 +691,9 @@ var PubSubBridge = class extends AbstractBridge {
   }
   async exposeHandler(id, options) {
     const { maxDepth = 2, direction = "all" } = options ?? {};
-    const module = assertEx5(await super.resolve(id), () => `Expose failed to locate module [${id}]`);
+    const module = assertEx4(await super.resolve(id), () => `Expose failed to locate module [${id}]`);
     if (module) {
-      const host = assertEx5(this.busHost(), () => "Not configured as a host");
+      const host = assertEx4(this.busHost(), () => "Not configured as a host");
       host.expose(module.address);
       const children = await module.resolve("*", {
         direction,
@@ -685,7 +727,7 @@ var PubSubBridge = class extends AbstractBridge {
     };
     const module = await super.resolve(id, filterOptions);
     if (module) {
-      const host = assertEx5(this.busHost(), () => "Not configured as a host");
+      const host = assertEx4(this.busHost(), () => "Not configured as a host");
       host.unexpose(module.address);
       const children = await module.resolve("*", {
         direction,