@xyo-network/bridge-pub-sub 2.91.2 → 2.92.0-rc.2

package/dist/browser/index.js

@@ -1,162 +1,11 @@
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
-// src/AbstractModuleProxy/AbstractModuleProxy.ts
-import { assertEx } from "@xylabs/assert";
-import { compact } from "@xylabs/lodash";
+// src/AbstractModuleHost/AbstractModuleHost.ts
 import { Base } from "@xylabs/object";
-import { PromiseEx } from "@xylabs/promise";
-import { QueryBoundWitnessBuilder } from "@xyo-network/boundwitness-builder";
-import { BoundWitnessWrapper } from "@xyo-network/boundwitness-wrapper";
-import { AddressPreviousHashSchema, ModuleAddressQuerySchema, ModuleConfigSchema, ModuleDescribeQuerySchema, ModuleDiscoverQuerySchema, ModuleManifestQuerySchema } from "@xyo-network/module-model";
-import { ModuleErrorSchema } from "@xyo-network/payload-model";
-var AbstractModuleProxy = class extends Base {
+var AbstractModuleHost = class extends Base {
   static {
-    __name(this, "AbstractModuleProxy");
-  }
-  static requiredQueries = [
-    ModuleDiscoverQuerySchema
-  ];
-  eventData = {};
-  proxyParams;
-  constructor(params) {
-    super({
-      config: {
-        schema: ModuleConfigSchema
-      }
-    });
-    this.proxyParams = params;
-  }
-  get account() {
-    return this.proxyParams.account;
-  }
-  get address() {
-    return this.proxyParams.moduleAddress;
-  }
-  get config() {
-    return this.params.config;
-  }
-  get downResolver() {
-    throw new Error("Unsupported");
-  }
-  get id() {
-    return this.proxyParams.moduleAddress;
-  }
-  get queries() {
-    return this.proxyParams.queries;
-  }
-  get upResolver() {
-    throw new Error("Unsupported");
-  }
-  static hasRequiredQueries(module) {
-    return this.missingRequiredQueries(module).length === 0;
-  }
-  static missingRequiredQueries(module) {
-    const moduleQueries = module.queries;
-    return compact(this.requiredQueries.map((query) => {
-      return moduleQueries.includes(query) ? null : query;
-    }));
-  }
-  async addressPreviousHash() {
-    const queryPayload = {
-      schema: ModuleAddressQuerySchema
-    };
-    return assertEx((await this.sendQuery(queryPayload)).find((payload) => payload.schema === AddressPreviousHashSchema), "Result did not include correct payload");
-  }
-  clearListeners(_eventNames) {
-    throw new Error("Unsupported");
-  }
-  //TODO: Make ModuleDescription into real payload
-  async describe() {
-    const queryPayload = {
-      schema: ModuleDescribeQuerySchema
-    };
-    return (await this.sendQuery(queryPayload))[0];
-  }
-  async discover() {
-    const queryPayload = {
-      schema: ModuleDiscoverQuerySchema
-    };
-    return await this.sendQuery(queryPayload);
-  }
-  emit(_eventName, _eventArgs) {
-    throw new Error("Unsupported");
-  }
-  emitSerial(_eventName, _eventArgs) {
-    throw new Error("Unsupported");
-  }
-  listenerCount(_eventNames) {
-    throw new Error("Unsupported");
-  }
-  async manifest(maxDepth) {
-    const queryPayload = {
-      schema: ModuleManifestQuerySchema,
-      ...maxDepth === void 0 ? {} : {
-        maxDepth
-      }
-    };
-    return (await this.sendQuery(queryPayload))[0];
-  }
-  async moduleAddress() {
-    const queryPayload = {
-      schema: ModuleAddressQuerySchema
-    };
-    return await this.sendQuery(queryPayload);
-  }
-  off(_eventNames, _listener) {
-    throw new Error("Unsupported");
-  }
-  offAny(_listener) {
-    throw new Error("Unsupported");
-  }
-  on(_eventNames, _listener) {
-    throw new Error("Unsupported");
-  }
-  onAny(_listener) {
-    throw new Error("Unsupported");
-  }
-  once(_eventName, _listener) {
-    throw new Error("Unsupported");
-  }
-  async previousHash() {
-    const queryPayload = {
-      schema: ModuleAddressQuerySchema
-    };
-    return (await this.sendQuery(queryPayload)).pop().previousHash;
-  }
-  queryable(_query, _payloads) {
-    return true;
-  }
-  resolve(nameOrAddressOrFilter, _options) {
-    return typeof nameOrAddressOrFilter === "string" ? void 0 : [];
-  }
-  state() {
-    return [];
-  }
-  bindQuery(query, payloads, account = this.account) {
-    const promise = new PromiseEx(async (resolve) => {
-      const result = await this.bindQueryInternal(query, payloads, account);
-      resolve?.(result);
-      return result;
-    }, account);
-    return promise;
-  }
-  async bindQueryInternal(query, payloads, account = this.account) {
-    const builder = await new QueryBoundWitnessBuilder().payloads(payloads).query(query);
-    const result = await (account ? builder.witness(account) : builder).build();
-    return result;
-  }
-  async filterErrors(result) {
-    const wrapper = await BoundWitnessWrapper.wrap(result[0], result[1]);
-    return wrapper.payloadsBySchema(ModuleErrorSchema);
-  }
-  async sendQuery(queryPayload, payloads) {
-    const query = await this.bindQuery(queryPayload, payloads);
-    const [, resultPayloads, errors] = await this.query(query[0], query[1]);
-    if (errors && errors.length > 0) {
-      throw errors[0];
-    }
-    return resultPayloads;
+    __name(this, "AbstractModuleHost");
   }
 };
 
@@ -170,7 +19,7 @@ import { PayloadBuilder } from "@xyo-network/payload-builder";
 import { LRUCache as LRUCache2 } from "lru-cache";
 
 // src/AsyncQueryBus/AsyncQueryBusBase.ts
-import { assertEx as assertEx2 } from "@xylabs/assert";
+import { assertEx } from "@xylabs/assert";
 import { Base as Base2 } from "@xylabs/object";
 import { asArchivistInstance } from "@xyo-network/archivist-model";
 import { asDivinerInstance } from "@xyo-network/diviner-model";
@@ -179,6 +28,7 @@ var AsyncQueryBusBase = class extends Base2 {
   static {
     __name(this, "AsyncQueryBusBase");
   }
+  _exposedAddresses = /* @__PURE__ */ new Set();
   _lastState;
   _targetConfigs = {};
   _targetQueries = {};
@@ -205,17 +55,25 @@ var AsyncQueryBusBase = class extends Base2 {
     this._lastState = this._lastState ?? new LRUCache(requiredConfig);
     return this._lastState;
   }
+  expose(address, validate = true) {
+    assertEx(!validate || !this._exposedAddresses.has(address), () => `Address already exposed [${address}]`);
+    this._exposedAddresses.add(address);
+  }
   async queriesArchivist() {
-    return assertEx2(asArchivistInstance(await this.resolver.resolve(this.config?.clearingHouse?.queries?.archivist)), () => `Unable to resolve queriesArchivist [${this.config?.clearingHouse?.queries?.archivist}]`);
+    return assertEx(asArchivistInstance(await this.resolver.resolve(this.config?.intersect?.queries?.archivist)), () => `Unable to resolve queriesArchivist [${this.config?.intersect?.queries?.archivist}]`);
   }
   async queriesDiviner() {
-    return assertEx2(asDivinerInstance(await this.resolver.resolve(this.config?.clearingHouse?.queries?.boundWitnessDiviner)), () => `Unable to resolve queriesDiviner [${this.config?.clearingHouse?.queries?.boundWitnessDiviner}]`);
+    return assertEx(asDivinerInstance(await this.resolver.resolve(this.config?.intersect?.queries?.boundWitnessDiviner)), () => `Unable to resolve queriesDiviner [${this.config?.intersect?.queries?.boundWitnessDiviner}]`);
   }
   async responsesArchivist() {
-    return assertEx2(asArchivistInstance(await this.resolver.resolve(this.config?.clearingHouse?.responses?.archivist)), () => `Unable to resolve responsesArchivist [${this.config?.clearingHouse?.responses?.archivist}]`);
+    return assertEx(asArchivistInstance(await this.resolver.resolve(this.config?.intersect?.responses?.archivist)), () => `Unable to resolve responsesArchivist [${this.config?.intersect?.responses?.archivist}]`);
   }
   async responsesDiviner() {
-    return assertEx2(asDivinerInstance(await this.resolver.resolve(this.config?.clearingHouse?.responses?.boundWitnessDiviner)), () => `Unable to resolve responsesDiviner [${this.config?.clearingHouse?.responses?.boundWitnessDiviner}]`);
+    return assertEx(asDivinerInstance(await this.resolver.resolve(this.config?.intersect?.responses?.boundWitnessDiviner)), () => `Unable to resolve responsesDiviner [${this.config?.intersect?.responses?.boundWitnessDiviner}]`);
+  }
+  unexpose(address, validate = true) {
+    assertEx(!validate || this._exposedAddresses.has(address), () => `Address not exposed [${address}]`);
+    this._exposedAddresses.delete(address);
   }
   /**
   * Commit the internal state of the process. This is similar
@@ -249,7 +107,7 @@ var AsyncQueryBusBase = class extends Base2 {
   }
 };
 
-// src/AsyncQueryBus/Config.ts
+// src/AsyncQueryBus/model/QueryStatus.ts
 var Pending = "pending";
 
 // src/AsyncQueryBus/AsyncQueryBusClient.ts
@@ -434,7 +292,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";
@@ -455,7 +313,7 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
     return !!this._pollId;
   }
   async listeningModules() {
-    const mods = this.config?.listeningModules ? await Promise.all(this.config.listeningModules.map(async (listeningModule) => assertEx3(asModuleInstance(await this.resolver.resolve(listeningModule)), () => `Unable to resolve listeningModule [${listeningModule}]`))) : await this.resolver.resolve(void 0, {
+    const mods = this.config?.listeningModules ? await Promise.all(this.config.listeningModules.map(async (listeningModule) => assertEx2(asModuleInstance(await this.resolver.resolve(listeningModule)), () => `Unable to resolve listeningModule [${listeningModule}]`))) : await this.resolver.resolve(void 0, {
       direction: "down"
     });
     return mods;
@@ -478,38 +336,39 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
     const localModuleName = localModule.config.name ?? localModule.address;
     const queryArchivist = await this.queriesArchivist();
     const responseArchivist = await this.responsesArchivist();
-    const commandDestination = query.$meta?.destination;
-    if (commandDestination && commandDestination?.includes(localModule.address)) {
+    const queryDestination = query.$meta?.destination;
+    if (queryDestination && queryDestination?.includes(localModule.address)) {
       const queryIndex = query.payload_hashes.indexOf(query.query);
       if (queryIndex !== -1) {
         const querySchema = query.payload_schemas[queryIndex];
         if (localModule.queries.includes(querySchema)) {
-          const commandPayloads = await queryArchivist.get(query.payload_hashes);
-          const commandPayloadsDict = await PayloadBuilder2.toAllHashMap(commandPayloads);
-          const commandHash = (await PayloadBuilder2.build(query)).$hash;
-          if (!containsAll(Object.keys(commandPayloadsDict), query.payload_hashes)) {
-            this.logger?.error(`Error processing command ${commandHash} for module ${localModuleName}, missing payloads`);
+          const queryPayloads = await queryArchivist.get(query.payload_hashes);
+          const queryPayloadsDict = await PayloadBuilder2.toAllHashMap(queryPayloads);
+          const queryHash = (await PayloadBuilder2.build(query)).$hash;
+          if (!containsAll(Object.keys(queryPayloadsDict), query.payload_hashes)) {
+            this.logger?.error(`Error processing command ${queryHash} for module ${localModuleName}, missing payloads`);
             return;
           }
           try {
-            const commandSchema = commandPayloadsDict[query.query].schema;
-            this.logger?.debug(`Issuing command ${commandSchema} (${commandHash}) addressed to module: ${localModuleName}`);
-            const response = await localModule.query(query, commandPayloads);
+            const querySchema2 = queryPayloadsDict[query.query].schema;
+            this.logger?.debug(`Issuing query ${querySchema2} (${queryHash}) addressed to module: ${localModuleName}`);
+            const response = await localModule.query(query, queryPayloads);
             const [bw, payloads, errors] = response;
-            this.logger?.debug(`Replying to command ${commandHash} addressed to module: ${localModuleName}`);
+            this.logger?.debug(`Replying to query ${queryHash} addressed to module: ${localModuleName}`);
             const insertResult = await responseArchivist.insert([
               bw,
               ...payloads,
               ...errors
             ]);
             if (insertResult.length === 0) {
-              this.logger?.error(`Error replying to command ${commandHash} addressed to module: ${localModuleName}`);
+              this.logger?.error(`Error replying to query ${queryHash} addressed to module: ${localModuleName}`);
             }
             if (query?.timestamp) {
               await this.commitState(localModule.address, query.timestamp);
             }
           } catch (error) {
-            this.logger?.error(`Error processing command ${commandHash} for module ${localModuleName}: ${error}`);
+            this.logger?.error(`Error processing query ${queryHash} for module ${localModuleName}: ${error}`);
+            console.error(`Error processing query ${queryHash} for module ${localModuleName}: ${error}`);
           }
         }
       }
@@ -560,37 +419,29 @@ var AsyncQueryBusHost = class extends AsyncQueryBusBase {
     }, this.pollFrequencyConfig);
   }
   /**
-  * Background process for checking for inbound commands
+  * Background process for checking for inbound queries
   */
   processIncomingQueries = async () => {
-    this.logger?.debug("Checking for inbound commands");
+    this.logger?.debug("Checking for inbound queries");
     const localModules = await this.listeningModules();
     await Promise.allSettled(localModules.map(async (localModule) => {
       try {
         const localModuleName = localModule.config.name ?? localModule.address;
-        this.logger?.debug(`Checking for inbound commands to ${localModuleName}`);
+        this.logger?.debug(`Checking for inbound queries to ${localModuleName}`);
         const queries = await this.findQueriesToAddress(localModule.address);
         if (queries.length === 0)
           return;
-        this.logger?.debug(`Found commands addressed to local module: ${localModuleName}`);
+        this.logger?.debug(`Found queries addressed to local module: ${localModuleName}`);
         for (const query of queries) {
           await this.callLocalModule(localModule, query);
         }
       } catch (error) {
-        this.logger?.error(`Error processing commands for address ${localModule.address}: ${error}`);
+        this.logger?.error(`Error processing queries for address ${localModule.address}: ${error}`);
       }
     }));
   };
 };
 
-// src/AbstractModuleHost/AbstractModuleHost.ts
-import { Base as Base3 } from "@xylabs/object";
-var AbstractModuleHost = class extends Base3 {
-  static {
-    __name(this, "AbstractModuleHost");
-  }
-};
-
 // src/AsyncQueryBus/ModuleHost/ModuleHost.ts
 var AsyncQueryBusModuleHost = class extends AbstractModuleHost {
   static {
@@ -620,12 +471,13 @@ var AsyncQueryBusModuleHost = class extends AbstractModuleHost {
 };
 
 // src/AsyncQueryBus/ModuleProxy/ModuleProxy.ts
+import { AbstractModuleProxy } from "@xyo-network/abstract-bridge";
 var AsyncQueryBusModuleProxy = class extends AbstractModuleProxy {
   static {
     __name(this, "AsyncQueryBusModuleProxy");
   }
   async query(query, payloads) {
-    return await this.proxyParams.bridgeClient.send(this.address, query, payloads);
+    return await this.proxyParams.busClient.send(this.address, query, payloads);
   }
 };
 
@@ -636,12 +488,10 @@ var PubSubBridgeSchema = "network.xyo.bridge.pubsub";
 var PubSubBridgeConfigSchema = `${PubSubBridgeSchema}.config`;
 
 // src/PubSubBridge.ts
-import { assertEx as assertEx4 } from "@xylabs/assert";
+import { assertEx as assertEx3 } from "@xylabs/assert";
 import { AbstractBridge } from "@xyo-network/abstract-bridge";
-import { ModuleManifestPayloadSchema } from "@xyo-network/manifest-model";
-import { creatableModule, ModuleManifestQuerySchema as ModuleManifestQuerySchema2 } from "@xyo-network/module-model";
-import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
-import { LRUCache as LRUCache3 } from "lru-cache";
+import { Account } from "@xyo-network/account";
+import { creatableModule } from "@xyo-network/module-model";
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
@@ -664,94 +514,52 @@ var PubSubBridge = class extends AbstractBridge {
   _configRootAddress = "";
   _configStateStoreArchivist = "";
   _configStateStoreBoundWitnessDiviner = "";
-  _discoverCache;
+  _exposedAddresses = [];
   _lastState;
-  _targetConfigs = {};
-  _targetQueries = {};
   _busClient;
   _busHost;
-  get discoverCache() {
-    const config = this.discoverCacheConfig;
-    this._discoverCache = this._discoverCache ?? new LRUCache3({
-      ttlAutopurge: true,
-      ...config
-    });
-    return this._discoverCache;
-  }
-  get discoverCacheConfig() {
-    const discoverCacheConfig = this.config.discoverCache === true ? {} : this.config.discoverCache;
-    return {
-      max: 100,
-      ttl: 1e3 * 60 * 5,
-      ...discoverCacheConfig
-    };
-  }
   get moduleName() {
     return `${this.config.name ?? moduleName}`;
   }
-  get rootAddress() {
-    return this._configRootAddress;
-  }
-  // protected get stateStoreArchivistConfig() {
-  //   return this._configStateStoreArchivist
-  // }
-  // protected get stateStoreBoundWitnessDivinerConfig() {
-  //   return this._configStateStoreBoundWitnessDiviner
-  // }
-  connect() {
-    this.connected = true;
-    return true;
-  }
-  async disconnect() {
-    await Promise.resolve();
-    this.connected = false;
-    return true;
-  }
-  getRootAddress() {
-    return this.rootAddress;
-  }
-  targetConfig(address) {
-    return assertEx4(this._targetConfigs[address], () => `targetConfig not set [${address}]`);
-  }
-  async targetDiscover(address, _maxDepth) {
-    if (!this.connected)
-      throw new Error("Not connected");
-    const cachedResult = this.discoverCache?.get(address ?? "root ");
-    if (cachedResult) {
-      return cachedResult;
+  async exposeHandler(id, options) {
+    const filterOptions = {
+      direction: options?.direction
+    };
+    const module = await super.resolve(id, filterOptions);
+    if (module) {
+      const host = assertEx3(this.busHost(), "Not configured as a host");
+      host.expose(module.address);
+      return [
+        module.address
+      ];
     }
-    await this.started("throw");
-    const addressToDiscover = address ?? await this.getRootAddress();
-    this.logger?.debug(`${this.moduleName}: Begin issuing targetDiscover to: ${addressToDiscover}`);
     return [];
   }
-  async targetManifest(address, maxDepth) {
-    const addressToCall = address ?? this.getRootAddress();
-    const queryPayload = {
-      maxDepth,
-      schema: ModuleManifestQuerySchema2
+  resolveHandler(id, _options) {
+    const account = Account.randomSync();
+    const params = {
+      account,
+      busClient: assertEx3(this.busClient(), "Bus client not initialized"),
+      moduleAddress: id
     };
-    const boundQuery = await this.bindQuery(queryPayload);
-    const manifest = assertEx4(await this.targetQuery(addressToCall, boundQuery[0], boundQuery[1]), () => `Unable to resolve [${address}]`)[1];
-    return assertEx4(manifest.find(isPayloadOfSchemaType(ModuleManifestPayloadSchema)), "Did not receive manifest");
-  }
-  targetQueries(address) {
-    if (!this.connected)
-      throw new Error("Not connected");
-    return assertEx4(this._targetQueries[address], () => `targetQueries not set [${address}]`);
-  }
-  async targetQuery(address, query, payloads) {
-    if (!this.connected)
-      throw new Error("Not connected");
-    await this.started("throw");
-    const bus = this.busClient();
-    return bus.send(address, query, payloads);
-  }
-  targetQueryable(_address, _query, _payloads, _queryConfig) {
-    return true;
+    return new AsyncQueryBusModuleProxy(params);
+  }
+  async unexposeHandler(id, options) {
+    const filterOptions = {
+      direction: options?.direction
+    };
+    const module = await super.resolve(id, filterOptions);
+    if (module) {
+      const host = assertEx3(this.busHost(), "Not configured as a host");
+      host.unexpose(module.address);
+      return [
+        module.address
+      ];
+    }
+    return [];
   }
   busClient() {
-    if (!this._busClient) {
+    if (!this._busClient && this.config.client) {
       this._busClient = new AsyncQueryBusClient({
         config: this.config.client,
         logger: this.logger,
@@ -761,7 +569,7 @@ var PubSubBridge = class extends AbstractBridge {
     return this._busClient;
   }
   busHost() {
-    if (!this._busHost) {
+    if (!this._busHost && this.config.host) {
       this._busHost = new AsyncQueryBusHost({
         config: this.config.host,
         logger: this.logger,
@@ -770,13 +578,12 @@ var PubSubBridge = class extends AbstractBridge {
     }
     return this._busHost;
   }
-  async startHandler() {
-    await Promise.resolve(this.connect());
-    this.busHost().start();
-    return true;
+  startHandler() {
+    this.busHost()?.start();
+    return Promise.resolve(true);
   }
   stopHandler(_timeout) {
-    this.busHost().stop();
+    this.busHost()?.stop();
     return true;
   }
 };
@@ -784,7 +591,7 @@ PubSubBridge = _ts_decorate([
   creatableModule()
 ], PubSubBridge);
 export {
-  AbstractModuleProxy,
+  AbstractModuleHost,
   AsyncQueryBusClient,
   AsyncQueryBusHost,
   AsyncQueryBusModuleHost,