@xyo-network/bridge-pub-sub 2.94.15 → 2.94.17

package/dist/browser/index.cjs

@@ -43,7 +43,7 @@ var AbstractModuleHost = class extends import_object.Base {
 };
 
 // src/AsyncQueryBus/AsyncQueryBusClient.ts
-var import_assert = require("@xylabs/assert");
+var import_assert2 = require("@xylabs/assert");
 var import_delay = require("@xylabs/delay");
 var import_forget = require("@xylabs/forget");
 var import_timer = require("@xylabs/timer");
@@ -53,9 +53,12 @@ var import_payload_builder = require("@xyo-network/payload-builder");
 var import_lru_cache2 = require("lru-cache");
 
 // src/AsyncQueryBus/AsyncQueryBusBase.ts
+var import_assert = require("@xylabs/assert");
 var import_object2 = require("@xylabs/object");
 var import_archivist_model = require("@xyo-network/archivist-model");
 var import_diviner_model = require("@xyo-network/diviner-model");
+var import_module_model = require("@xyo-network/module-model");
+var import_async_mutex = require("async-mutex");
 var import_lru_cache = require("lru-cache");
 var AsyncQueryBusBase = class extends import_object2.Base {
   static {
@@ -64,13 +67,11 @@ var AsyncQueryBusBase = class extends import_object2.Base {
   _lastState;
   _targetConfigs = {};
   _targetQueries = {};
-  _lastQueriesArchivistAttempt;
-  _lastQueriesDivinerAttempt;
-  _lastResponsesArchivistAttempt;
-  _lastResponsesDivinerAttempt;
+  _lastResolveAttempt = {};
   _queriesArchivist;
   _queriesDiviner;
-  _reResolveDelay = 5e4;
+  _reResolveDelay = 1e3 * 5;
+  _resolveMutex = new import_async_mutex.Mutex();
   _responsesArchivist;
   _responsesDiviner;
   constructor(params) {
@@ -97,84 +98,20 @@ var AsyncQueryBusBase = class extends import_object2.Base {
     return this._lastState;
   }
   async queriesArchivist() {
-    if (this._queriesArchivist) {
-      return this._queriesArchivist;
-    }
-    if (Date.now() - (this._lastQueriesArchivistAttempt ?? 0) < this._reResolveDelay) {
-      return;
-    }
-    this._lastQueriesArchivistAttempt = Date.now();
-    const resolved = await this.resolver.resolve(this.config?.intersect?.queries?.archivist);
-    if (resolved) {
-      const typedResolve = (0, import_archivist_model.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}]: ${(0, import_object2.toJsonString)(resolved)}`);
-      }
-    } else {
-      this.logger?.log(`Unable to resolve queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
-    }
+    this._queriesArchivist = this._queriesArchivist ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.queries?.archivist, () => "No queries Archivist defined"), import_archivist_model.isArchivistInstance);
+    return this._queriesArchivist;
   }
   async queriesDiviner() {
-    if (this._queriesDiviner) {
-      return this._queriesDiviner;
-    }
-    if (Date.now() - (this._lastQueriesDivinerAttempt ?? 0) < this._reResolveDelay) {
-      return;
-    }
-    this._lastQueriesDivinerAttempt = Date.now();
-    const resolved = await this.resolver.resolve(this.config?.intersect?.queries?.boundWitnessDiviner);
-    if (resolved) {
-      const typedResolve = (0, import_diviner_model.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}]: ${(0, import_object2.toJsonString)(resolved)}`);
-      }
-    } else {
-      this.logger?.log(`Unable to resolve queriesDiviner [${this.config?.intersect?.queries?.boundWitnessDiviner}]`);
-    }
+    this._queriesDiviner = this._queriesDiviner ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.queries?.boundWitnessDiviner, () => "No queries Diviner defined"), import_diviner_model.isDivinerInstance);
+    return this._queriesDiviner;
   }
   async responsesArchivist() {
-    if (this._responsesArchivist) {
-      return this._responsesArchivist;
-    }
-    if (Date.now() - (this._lastResponsesArchivistAttempt ?? 0) < this._reResolveDelay) {
-      return;
-    }
-    this._lastResponsesArchivistAttempt = Date.now();
-    const resolved = await this.resolver.resolve(this.config?.intersect?.responses?.archivist);
-    if (resolved) {
-      const typedResolve = (0, import_archivist_model.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}]: ${(0, import_object2.toJsonString)(resolved)}`);
-      }
-    } else {
-      this.logger?.log(`Unable to resolve responseArchivist [${this.config?.intersect?.responses?.archivist}]`);
-    }
+    this._responsesArchivist = this._responsesArchivist ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.responses?.archivist, () => "No responses Archivist defined"), import_archivist_model.isArchivistInstance);
+    return this._responsesArchivist;
   }
   async responsesDiviner() {
-    if (this._responsesDiviner) {
-      return this._responsesDiviner;
-    }
-    if (Date.now() - (this._lastResponsesDivinerAttempt ?? 0) < this._reResolveDelay) {
-      return;
-    }
-    this._lastResponsesDivinerAttempt = Date.now();
-    const resolved = await this.resolver.resolve(this.config?.intersect?.responses?.boundWitnessDiviner);
-    if (resolved) {
-      const typedResolve = (0, import_diviner_model.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}]: ${(0, import_object2.toJsonString)(resolved)}`);
-      }
-    } else {
-      this.logger?.log(`Unable to resolve responsesDiviner [${this.config?.intersect?.responses?.boundWitnessDiviner}]`);
-    }
+    this._responsesDiviner = this._responsesDiviner ?? await this.resolve((0, import_assert.assertEx)(this.config?.intersect?.responses?.boundWitnessDiviner, () => "No responses Diviner defined"), import_diviner_model.isDivinerInstance);
+    return this._responsesDiviner;
   }
   /**
   * Commit the internal state of the process. This is similar
@@ -206,6 +143,27 @@ var AsyncQueryBusBase = class extends import_object2.Base {
       return state;
     }
   }
+  async resolve(id, typeCheck) {
+    return await this._resolveMutex.runExclusive(async () => {
+      if (this._queriesArchivist) {
+        return this._queriesArchivist;
+      }
+      if (Date.now() - (this._lastResolveAttempt[id] ?? 0) < this._reResolveDelay) {
+        return;
+      }
+      this._lastResolveAttempt[id] = Date.now();
+      const resolved = await this.resolver.resolve(id);
+      if (resolved) {
+        if (typeCheck(resolved)) {
+          return resolved;
+        } else {
+          this.logger?.warn(`Unable to resolve responsesDiviner as correct type [${id}][${resolved?.constructor?.name}]: ${resolved.id}`);
+        }
+      } else {
+        this.logger?.log(`Unable to resolve queriesArchivist [${id}] [${await (0, import_module_model.traceModuleIdentifier)(this.resolver, id)}]`);
+      }
+    });
+  }
 };
 
 // src/AsyncQueryBus/model/QueryStatus.ts
@@ -263,7 +221,7 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
       ...query,
       $meta
     });
-    const queryArchivist = (0, import_assert.assertEx)(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const queryArchivist = (0, import_assert2.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
@@ -391,11 +349,11 @@ var AsyncQueryBusClient = class extends AsyncQueryBusBase {
 
 // src/AsyncQueryBus/AsyncQueryBusHost.ts
 var import_array = require("@xylabs/array");
-var import_assert2 = require("@xylabs/assert");
+var import_assert3 = require("@xylabs/assert");
 var import_timer2 = require("@xylabs/timer");
 var import_boundwitness_model2 = require("@xyo-network/boundwitness-model");
 var import_diviner_boundwitness_model2 = require("@xyo-network/diviner-boundwitness-model");
-var import_module_model = require("@xyo-network/module-model");
+var import_module_model2 = require("@xyo-network/module-model");
 var import_payload_builder2 = require("@xyo-network/payload-builder");
 var AsyncQueryBusHost = class extends AsyncQueryBusBase {
   static {
@@ -416,21 +374,32 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
   get started() {
     return !!this._pollId;
   }
-  expose(address, options = {}) {
-    const { failOnAlreadyExposed } = options;
-    (0, import_assert2.assertEx)(!failOnAlreadyExposed || !this._exposedAddresses.has(address), () => `Address already exposed [${address}]`);
-    this._exposedAddresses.add(address);
-    this._exposeOptions[address] = {
-      ...options
-    };
-    this.logger?.debug(`${address} exposed`);
+  async expose(id, options) {
+    const { failOnAlreadyExposed, required = true } = options ?? {};
+    const module2 = (0, import_module_model2.asModuleInstance)(await this.resolver.resolve(id, {
+      maxDepth: 10
+    }));
+    if (!module2 && required) {
+      throw new Error(`Unable to resolve module to expose [${id}]`);
+    }
+    if (module2) {
+      (0, import_assert3.assertEx)(!failOnAlreadyExposed || !this._exposedAddresses.has(module2.address), () => `Address already exposed: ${id} [${module2.address}]`);
+      this._exposedAddresses.add(module2.address);
+      this._exposeOptions[module2.address] = {
+        ...options
+      };
+      this.logger?.debug(`${id} exposed [${module2.address}]`);
+      return module2;
+    }
   }
   async listeningModules() {
     const exposedModules = [
       ...this.config?.listeningModules ?? [],
       ...this.exposedAddresses.values()
     ];
-    const mods = await Promise.all(exposedModules.map(async (listeningModule) => (0, import_assert2.assertEx)((0, import_module_model.asModuleInstance)(await this.resolver.resolve(listeningModule)), () => `Unable to resolve listeningModule [${listeningModule}]`)));
+    const mods = await Promise.all(exposedModules.map(async (exposedModule) => (0, import_assert3.assertEx)((0, import_module_model2.asModuleInstance)(await this.resolver.resolve(exposedModule, {
+      maxDepth: 10
+    })), () => `Unable to resolve listeningModule [${exposedModule}]`)));
     return mods;
   }
   start() {
@@ -447,16 +416,22 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
       (0, import_timer2.clearTimeoutEx)(this._pollId);
     this._pollId = void 0;
   }
-  unexpose(address, validate = true) {
-    (0, import_assert2.assertEx)(!validate || this._exposedAddresses.has(address), () => `Address not exposed [${address}]`);
-    this._exposedAddresses.delete(address);
-    delete this._exposeOptions[address];
-    this.logger?.debug(`${address} unexposed`);
+  async unexpose(id, validate = true) {
+    const module2 = (0, import_module_model2.asModuleInstance)(await this.resolver.resolve(id, {
+      maxDepth: 10
+    }));
+    if (module2) {
+      (0, import_assert3.assertEx)(!validate || this._exposedAddresses.has(module2.address), () => `Address not exposed [${module2.address}][${module2.id}]`);
+      this._exposedAddresses.delete(module2.address);
+      delete this._exposeOptions[module2.address];
+      this.logger?.debug(`${module2.address} [${module2.id}] unexposed`);
+    }
+    return module2;
   }
   callLocalModule = async (localModule, query) => {
     const localModuleName = localModule.config.name ?? localModule.address;
-    const queryArchivist = (0, import_assert2.assertEx)(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
-    const responsesArchivist = (0, import_assert2.assertEx)(await this.responsesArchivist(), () => `Unable to contact responsesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const queryArchivist = (0, import_assert3.assertEx)(await this.queriesArchivist(), () => `Unable to contact queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
+    const responsesArchivist = (0, import_assert3.assertEx)(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);
@@ -475,7 +450,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
             this.logger?.debug(`Issuing query ${querySchema2} (${queryHash}) addressed to module: ${localModuleName}`);
             const response = await localModule.query(query, queryPayloads, {
               allowedQueries: this._exposeOptions[localModule.address]?.allowedQueries,
-              schema: import_module_model.ModuleConfigSchema
+              schema: import_module_model2.ModuleConfigSchema
             });
             const [bw, payloads, errors] = response;
             this.logger?.debug(`Replying to query ${queryHash} addressed to module: ${localModuleName}`);
@@ -619,18 +594,18 @@ var PubSubBridgeSchema = "network.xyo.bridge.pubsub";
 var PubSubBridgeConfigSchema = `${PubSubBridgeSchema}.config`;
 
 // src/PubSubBridge.ts
-var import_assert4 = require("@xylabs/assert");
+var import_assert5 = require("@xylabs/assert");
 var import_exists = require("@xylabs/exists");
 var import_abstract_bridge3 = require("@xyo-network/abstract-bridge");
-var import_module_model3 = require("@xyo-network/module-model");
+var import_module_model4 = require("@xyo-network/module-model");
 
 // src/PubSubBridgeModuleResolver.ts
-var import_assert3 = require("@xylabs/assert");
+var import_assert4 = require("@xylabs/assert");
 var import_hex = require("@xylabs/hex");
 var import_abstract_bridge2 = require("@xyo-network/abstract-bridge");
 var import_account = require("@xyo-network/account");
 var import_config_payload_plugin = require("@xyo-network/config-payload-plugin");
-var import_module_model2 = require("@xyo-network/module-model");
+var import_module_model3 = require("@xyo-network/module-model");
 var PubSubBridgeModuleResolver = class extends import_abstract_bridge2.AbstractBridgeModuleResolver {
   static {
     __name(this, "PubSubBridgeModuleResolver");
@@ -642,14 +617,14 @@ var PubSubBridgeModuleResolver = class extends import_abstract_bridge2.AbstractB
     }
     const idParts = id.split(":");
     const firstPart = idParts.shift();
-    (0, import_assert3.assertEx)((0, import_hex.isAddress)(firstPart), () => `Invalid module address: ${firstPart}`);
+    (0, import_assert4.assertEx)((0, import_hex.isAddress)(firstPart), () => `Invalid module address: ${firstPart}`);
     const remainderParts = idParts.join(":");
     const account = import_account.Account.randomSync();
     const params = {
       account,
       busClient: this.params.busClient,
       config: {
-        schema: import_module_model2.ModuleConfigSchema
+        schema: import_module_model3.ModuleConfigSchema
       },
       host: this.params.bridge,
       moduleAddress: firstPart
@@ -659,13 +634,13 @@ var PubSubBridgeModuleResolver = class extends import_abstract_bridge2.AbstractB
       const state = await proxy.state();
       if (state) {
         const configSchema = state.find((payload) => payload.schema === import_config_payload_plugin.ConfigSchema)?.config;
-        const config = (0, import_assert3.assertEx)(state.find((payload) => payload.schema === configSchema), () => "Unable to locate config");
+        const config = (0, import_assert4.assertEx)(state.find((payload) => payload.schema === configSchema), () => "Unable to locate config");
         proxy.setConfig(config);
       }
     }
     await proxy.start?.();
     const wrapped = (0, import_abstract_bridge2.wrapModuleWithType)(proxy, account);
-    const as = (0, import_assert3.assertEx)((0, import_module_model2.asModuleInstance)(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
+    const as = (0, import_assert4.assertEx)((0, import_module_model3.asModuleInstance)(wrapped, {}), () => `Failed to asModuleInstance [${id}]`);
     proxy.upResolver.add(as);
     proxy.downResolver.add(as);
     this.add(as);
@@ -704,7 +679,7 @@ var PubSubBridge = class extends import_abstract_bridge3.AbstractBridge {
   get resolver() {
     this._resolver = this._resolver ?? new PubSubBridgeModuleResolver({
       bridge: this,
-      busClient: (0, import_assert4.assertEx)(this.busClient(), () => "busClient not configured"),
+      busClient: (0, import_assert5.assertEx)(this.busClient(), () => "busClient not configured"),
       wrapperAccount: this.account
     });
     return this._resolver;
@@ -713,7 +688,7 @@ var PubSubBridge = class extends import_abstract_bridge3.AbstractBridge {
     return `${this.config.name ?? moduleName}`;
   }
   get roots() {
-    return (0, import_assert4.assertEx)(this.config.roots, () => "roots not configured");
+    return (0, import_assert5.assertEx)(this.config.roots, () => "roots not configured");
   }
   async discoverRoots() {
     const rootInstances = (await Promise.all(this.roots.map(async (root) => await this.resolver.resolve(root)))).filter(import_exists.exists);
@@ -723,22 +698,24 @@ var PubSubBridge = class extends import_abstract_bridge3.AbstractBridge {
     return rootInstances;
   }
   async exposeHandler(id, options) {
-    const { maxDepth = 2, direction = "all" } = options ?? {};
-    const module2 = (0, import_assert4.assertEx)(await super.resolve(id), () => `Expose failed to locate module [${id}]`);
+    const { maxDepth = 2, direction = "all", required = true } = options ?? {};
+    const host = (0, import_assert5.assertEx)(this.busHost(), () => "Not configured as a host");
+    const module2 = await host.expose(id, {
+      required
+    });
     if (module2) {
-      const host = (0, import_assert4.assertEx)(this.busHost(), () => "Not configured as a host");
-      host.expose(module2.address);
-      const children = await module2.resolve("*", {
+      const children = maxDepth > 0 ? await module2.resolve("*", {
         direction,
         maxDepth,
         visibility: "public"
-      });
-      for (const child of children) {
-        host.expose(child.address);
-      }
+      }) : [];
+      const exposedChildren = (await Promise.all(children.map((child) => this.exposeHandler(child.address, {
+        maxDepth: maxDepth - 1,
+        required: false
+      })))).flat().filter(import_exists.exists);
       return [
         module2,
-        ...children
+        ...exposedChildren
       ];
     }
     return [];
@@ -754,25 +731,22 @@ var PubSubBridge = class extends import_abstract_bridge3.AbstractBridge {
     return await super.startHandler();
   }
   async unexposeHandler(id, options) {
-    const { maxDepth = 10, direction } = options ?? {};
-    const filterOptions = {
-      direction
-    };
-    const module2 = await super.resolve(id, filterOptions);
+    const { maxDepth = 2, direction = "all", required = true } = options ?? {};
+    const host = (0, import_assert5.assertEx)(this.busHost(), () => "Not configured as a host");
+    const module2 = await host.unexpose(id, required);
     if (module2) {
-      const host = (0, import_assert4.assertEx)(this.busHost(), () => "Not configured as a host");
-      host.unexpose(module2.address);
-      const children = await module2.resolve("*", {
+      const children = maxDepth > 0 ? await module2.resolve("*", {
         direction,
         maxDepth,
         visibility: "public"
-      });
-      for (const child of children) {
-        host.unexpose(child.address);
-      }
+      }) : [];
+      const exposedChildren = (await Promise.all(children.map((child) => this.unexposeHandler(child.address, {
+        maxDepth: maxDepth - 1,
+        required: false
+      })))).flat().filter(import_exists.exists);
       return [
         module2,
-        ...children
+        ...exposedChildren
       ];
     }
     return [];
@@ -803,6 +777,6 @@ var PubSubBridge = class extends import_abstract_bridge3.AbstractBridge {
   }
 };
 PubSubBridge = _ts_decorate([
-  (0, import_module_model3.creatableModule)()
+  (0, import_module_model4.creatableModule)()
 ], PubSubBridge);
 //# sourceMappingURL=index.cjs.map