@xyo-network/bridge-abstract 2.102.0

package/dist/browser/index.cjs

@@ -0,0 +1,585 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AbstractBridge: () => AbstractBridge,
+  AbstractBridgeModuleResolver: () => AbstractBridgeModuleResolver,
+  AbstractModuleProxy: () => AbstractModuleProxy,
+  ModuleProxyResolver: () => ModuleProxyResolver,
+  wrapModuleWithType: () => wrapModuleWithType
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AbstractBridge.ts
+var import_assert = require("@xylabs/assert");
+var import_exists = require("@xylabs/exists");
+var import_forget = require("@xylabs/forget");
+var import_object = require("@xylabs/object");
+var import_address_payload_plugin = require("@xyo-network/address-payload-plugin");
+var import_archivist_model = require("@xyo-network/archivist-model");
+var import_boundwitness_wrapper = require("@xyo-network/boundwitness-wrapper");
+var import_bridge_model = require("@xyo-network/bridge-model");
+var import_module_abstract = require("@xyo-network/module-abstract");
+var import_module_model = require("@xyo-network/module-model");
+var import_payload_model = require("@xyo-network/payload-model");
+var AbstractBridge = class _AbstractBridge extends import_module_abstract.AbstractModuleInstance {
+  static {
+    __name(this, "AbstractBridge");
+  }
+  static configSchemas = [
+    ...super.configSchemas,
+    import_bridge_model.BridgeConfigSchema
+  ];
+  static defaultConfigSchema = import_bridge_model.BridgeConfigSchema;
+  static uniqueName = (0, import_object.globallyUnique)("AbstractBridge", _AbstractBridge, "xyo");
+  _roots;
+  get allowNameResolution() {
+    return this.params.allowNameResolution ?? true;
+  }
+  get queries() {
+    return [
+      import_bridge_model.BridgeConnectQuerySchema,
+      import_bridge_model.BridgeDisconnectQuerySchema,
+      import_bridge_model.BridgeExposeQuerySchema,
+      import_bridge_model.BridgeUnexposeQuerySchema,
+      ...super.queries
+    ];
+  }
+  get resolver() {
+    return (0, import_assert.assertEx)(this.params.resolver, () => "No resolver provided");
+  }
+  get _queryAccountPaths() {
+    return {
+      "network.xyo.query.bridge.connect": "1/1",
+      "network.xyo.query.bridge.disconnect": "1/2",
+      "network.xyo.query.bridge.expose": "1/4",
+      "network.xyo.query.bridge.unexpose": "1/5"
+    };
+  }
+  async expose(id, options) {
+    this._noOverride("expose");
+    (0, import_assert.assertEx)(id !== "*", () => "Exposing '*' not supported");
+    const addressToExpose = (0, import_assert.assertEx)(await (0, import_module_model.resolvePathToAddress)(this, id), () => `Module to expose not found [${id}]`);
+    console.log(`expose: ${addressToExpose}`);
+    const modules = await this.exposeHandler(addressToExpose, options);
+    await this.emit("exposed", {
+      module: this,
+      modules
+    });
+    return modules;
+  }
+  async exposed() {
+    this._noOverride("exposed");
+    return await this.exposedHandler();
+  }
+  // eslint-disable-next-line complexity
+  async resolve(idOrFilter = "*", options = {}) {
+    const roots = this._roots ?? [];
+    const workingSet = options.direction === "up" ? [
+      this
+    ] : [
+      ...roots,
+      this
+    ];
+    if (idOrFilter === "*") {
+      const remainingDepth = (options.maxDepth ?? 5) - 1;
+      return remainingDepth <= 0 ? workingSet : [
+        ...workingSet,
+        ...(await Promise.all(roots.map((mod) => mod.resolve("*", {
+          ...options,
+          maxDepth: remainingDepth
+        })))).flat()
+      ];
+    }
+    switch (typeof idOrFilter) {
+      case "string": {
+        const parts = idOrFilter.split(":");
+        const first = parts.shift();
+        const result = workingSet.find((mod) => {
+          return first === mod.address || first === mod.modName;
+        });
+        return parts.length === 0 ? result : result?.resolve(parts.join(":"), options);
+      }
+      case "object": {
+        const results = [];
+        if ((0, import_module_model.isNameModuleFilter)(idOrFilter)) {
+          for (const mod of workingSet) {
+            if (mod.modName && idOrFilter.name.includes(mod.modName))
+              results.push(mod);
+          }
+        }
+        if ((0, import_module_model.isAddressModuleFilter)(idOrFilter)) {
+          for (const mod of workingSet) {
+            if (mod.modName && idOrFilter.address.includes(mod.address))
+              results.push(mod);
+          }
+        }
+        return results;
+      }
+      default: {
+        return;
+      }
+    }
+  }
+  async startHandler() {
+    const { discoverRoots } = this.config;
+    if (discoverRoots === "lazy") {
+      (0, import_forget.forget)(this.getRoots());
+    } else {
+      await this.getRoots();
+    }
+    return true;
+  }
+  async unexpose(id, options) {
+    this._noOverride("unexpose");
+    const addressToUnexpose = (0, import_assert.assertEx)(await (0, import_module_model.resolvePathToAddress)(this, id), () => `Module to unexpose not found [${id}]`);
+    const modules = await this.unexposeHandler(addressToUnexpose, options);
+    await this.emit("unexposed", {
+      module: this,
+      modules
+    });
+    return modules;
+  }
+  async queryHandler(query, payloads) {
+    const wrapper = await import_boundwitness_wrapper.QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const queryPayload = await wrapper.getQuery();
+    const resultPayloads = [];
+    switch (queryPayload.schema) {
+      case import_bridge_model.BridgeExposeQuerySchema: {
+        const filterPayloads = (payloads ?? []).filter((0, import_payload_model.isPayloadOfSchemaType)(import_bridge_model.ModuleFilterPayloadSchema));
+        (0, import_assert.assertEx)(filterPayloads, () => "At least one filter is required");
+        await Promise.all(filterPayloads.map(async (filter) => {
+          const { id, ...options } = filter;
+          const modules = await this.expose(id, options);
+          modules.map((module2) => {
+            const addressPayload = {
+              address: module2.address,
+              schema: import_address_payload_plugin.AddressSchema
+            };
+            resultPayloads.push(addressPayload);
+          });
+        }));
+        break;
+      }
+      case import_bridge_model.BridgeUnexposeQuerySchema: {
+        const filterPayloads = (payloads ?? []).filter((0, import_payload_model.isPayloadOfSchemaType)(import_bridge_model.ModuleFilterPayloadSchema));
+        (0, import_assert.assertEx)(filterPayloads, () => "At least one filter is required");
+        await Promise.all(filterPayloads.map(async (filter) => {
+          const { id, ...options } = filter;
+          const modules = await this.unexpose(id, options);
+          modules.map((module2) => {
+            const addressPayload = {
+              address: module2.address,
+              schema: import_address_payload_plugin.AddressSchema
+            };
+            resultPayloads.push(addressPayload);
+          });
+        }));
+        break;
+      }
+      default: {
+        return await super.queryHandler(query, payloads);
+      }
+    }
+    return resultPayloads;
+  }
+  async resolveArchivingArchivists() {
+    const archivists = this.archiving?.archivists;
+    if (!archivists)
+      return [];
+    const resolvedAddresses = (await Promise.all(archivists.map(async (archivist) => (await Promise.all((await this.parents()).map((parent) => (0, import_module_model.resolvePathToAddress)(parent, archivist)))).filter(import_exists.exists)))).flat().filter(import_exists.exists);
+    const resolved = (await Promise.all(resolvedAddresses.map((address) => (0, import_module_model.resolveAddressToInstance)(this, address)))).filter(import_exists.exists);
+    return resolved.map((mod) => (0, import_archivist_model.asArchivistInstance)(mod)).filter(import_exists.exists);
+  }
+};
+
+// src/AbstractBridgeModuleResolver.ts
+var import_module_model2 = require("@xyo-network/module-model");
+var import_module_resolver = require("@xyo-network/module-resolver");
+var AbstractBridgeModuleResolver = class extends import_module_resolver.CompositeModuleResolver {
+  static {
+    __name(this, "AbstractBridgeModuleResolver");
+  }
+  get priority() {
+    return import_module_model2.ObjectResolverPriority.VeryLow;
+  }
+  async resolveHandler(id, options, _params) {
+    if (id === "*") {
+      return [];
+    }
+    return await super.resolveHandler(id, options);
+  }
+};
+
+// src/AbstractModuleProxy/AbstractModuleProxy.ts
+var import_assert3 = require("@xylabs/assert");
+var import_forget2 = require("@xylabs/forget");
+var import_hex = require("@xylabs/hex");
+var import_lodash = require("@xylabs/lodash");
+var import_object2 = require("@xylabs/object");
+var import_boundwitness_wrapper2 = require("@xyo-network/boundwitness-wrapper");
+var import_manifest_model = require("@xyo-network/manifest-model");
+var import_module_abstract2 = require("@xyo-network/module-abstract");
+var import_module_model4 = require("@xyo-network/module-model");
+var import_module_wrapper = require("@xyo-network/module-wrapper");
+var import_payload_builder = require("@xyo-network/payload-builder");
+var import_payload_model2 = require("@xyo-network/payload-model");
+var import_query_payload_plugin = require("@xyo-network/query-payload-plugin");
+var import_lru_cache = require("lru-cache");
+
+// src/AbstractModuleProxy/ModuleProxyResolver.ts
+var import_assert2 = require("@xylabs/assert");
+var import_exists2 = require("@xylabs/exists");
+var import_account = require("@xyo-network/account");
+var import_module_model3 = require("@xyo-network/module-model");
+var import_module_resolver2 = require("@xyo-network/module-resolver");
+
+// src/wrapModuleWithType.ts
+var import_archivist_model2 = require("@xyo-network/archivist-model");
+var import_archivist_wrapper = require("@xyo-network/archivist-wrapper");
+var import_diviner_model = require("@xyo-network/diviner-model");
+var import_diviner_wrapper = require("@xyo-network/diviner-wrapper");
+var import_node_model = require("@xyo-network/node-model");
+var import_node_wrapper = require("@xyo-network/node-wrapper");
+var import_sentinel_model = require("@xyo-network/sentinel-model");
+var import_sentinel_wrapper = require("@xyo-network/sentinel-wrapper");
+var import_witness_model = require("@xyo-network/witness-model");
+var import_witness_wrapper = require("@xyo-network/witness-wrapper");
+var wrapModuleWithType = /* @__PURE__ */ __name((module2, account) => {
+  if ((0, import_archivist_model2.isArchivistModule)(module2)) {
+    return import_archivist_wrapper.ArchivistWrapper.wrap(module2, account);
+  }
+  if ((0, import_diviner_model.isDivinerModule)(module2)) {
+    return import_diviner_wrapper.DivinerWrapper.wrap(module2, account);
+  }
+  if ((0, import_node_model.isNodeModule)(module2)) {
+    return import_node_wrapper.NodeWrapper.wrap(module2, account);
+  }
+  if ((0, import_sentinel_model.isSentinelModule)(module2)) {
+    return import_sentinel_wrapper.SentinelWrapper.wrap(module2, account);
+  }
+  if ((0, import_witness_model.isWitnessModule)(module2)) {
+    return import_witness_wrapper.WitnessWrapper.wrap(module2, account);
+  }
+  throw "Failed to wrap";
+}, "wrapModuleWithType");
+
+// src/AbstractModuleProxy/ModuleProxyResolver.ts
+var ModuleProxyResolver = class {
+  static {
+    __name(this, "ModuleProxyResolver");
+  }
+  options;
+  downResolver;
+  constructor(options) {
+    this.options = options;
+    this.downResolver = new import_module_resolver2.CompositeModuleResolver({
+      moduleIdentifierTransformers: options.moduleIdentifierTransformers,
+      root: this.root
+    });
+  }
+  get priority() {
+    return import_module_model3.ObjectResolverPriority.VeryLow;
+  }
+  get root() {
+    return this.options.module;
+  }
+  get childAddressMap() {
+    return this.options.childAddressMap;
+  }
+  get host() {
+    return this.options.host;
+  }
+  get module() {
+    return this.options.module;
+  }
+  addResolver(_resolver) {
+    throw new Error("Not supported");
+  }
+  removeResolver(_resolver) {
+    throw new Error("Not supported");
+  }
+  async resolve(idOrFilter = "*", options) {
+    const direction = options?.direction ?? "all";
+    if (idOrFilter === "*") {
+      const childAddresses = Object.keys(this.childAddressMap);
+      const resolvedChildren = await Promise.all(childAddresses.map((address) => this.resolve(address, options)));
+      return resolvedChildren.filter(import_exists2.exists);
+    } else if (typeof idOrFilter === "string") {
+      const idParts = idOrFilter.split(":");
+      const firstPart = (0, import_assert2.assertEx)(idParts.shift(), () => "Invalid module identifier at first position");
+      const firstPartAddress = await this.resolveIdentifier(firstPart);
+      if (firstPartAddress) {
+        const remainingParts = idParts.length > 0 ? idParts.join(":") : void 0;
+        if (direction === "down" || direction === "all") {
+          const downResolverModule = await this.downResolver.resolve(firstPartAddress);
+          if (downResolverModule) {
+            return remainingParts ? downResolverModule.resolve(remainingParts, options) : downResolverModule;
+          }
+          const addressToProxy = Object.keys(this.childAddressMap).includes(firstPartAddress) ? firstPartAddress : Object.entries(this.childAddressMap).find(([_, value]) => value === firstPartAddress)?.[0];
+          if (addressToProxy) {
+            const proxy = await this.host.resolve(addressToProxy, {
+              ...options,
+              direction: "down"
+            });
+            if (proxy) {
+              const wrapped = wrapModuleWithType(proxy, import_account.Account.randomSync());
+              return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped;
+            }
+            return;
+          }
+        }
+      }
+      return;
+    } else {
+      const filter = idOrFilter;
+      if ((0, import_module_model3.isAddressModuleFilter)(filter)) {
+        const results = (await Promise.all(filter.address.map((item) => this.resolve(item, options)))).filter(import_exists2.exists);
+        return results;
+      } else if ((0, import_module_model3.isNameModuleFilter)(filter)) {
+        return (await Promise.all(filter.name.map((item) => this.resolve(item, options)))).filter(import_exists2.exists);
+      }
+    }
+  }
+  resolveIdentifier(id, _options) {
+    if (this.childAddressMap[id]) {
+      return id;
+    }
+    const addressFromName = Object.entries(this.childAddressMap).find(([, name]) => name === id)?.[0];
+    if (addressFromName) {
+      return addressFromName;
+    }
+  }
+  async resolvePrivate(id, _options) {
+    if (id === "*")
+      return await Promise.resolve([]);
+  }
+};
+
+// src/AbstractModuleProxy/AbstractModuleProxy.ts
+var AbstractModuleProxy = class _AbstractModuleProxy extends import_module_abstract2.AbstractModuleInstance {
+  static {
+    __name(this, "AbstractModuleProxy");
+  }
+  static requiredQueries = [
+    import_module_model4.ModuleStateQuerySchema
+  ];
+  _config;
+  _publicChildren;
+  _state = void 0;
+  _stateInProcess = false;
+  _spamTrap = new import_lru_cache.LRUCache({
+    max: 1e3,
+    ttl: 1e3 * 60,
+    ttlAutopurge: true
+  });
+  constructor(params) {
+    params.addToResolvers = false;
+    super(_AbstractModuleProxy.privateConstructorKey, params, params.account);
+  }
+  get address() {
+    return this.params.moduleAddress;
+  }
+  get archiving() {
+    return this.params?.archiving;
+  }
+  get config() {
+    return (0, import_assert3.assertEx)(this._config, () => "Config not set");
+  }
+  get queries() {
+    const queryPayloads = (0, import_assert3.assertEx)(this._state, () => "Module state not found.  Make sure proxy has been started").filter((item) => (0, import_payload_model2.isPayloadOfSchemaType)(import_query_payload_plugin.QuerySchema)(item));
+    return queryPayloads.map((payload) => payload.query);
+  }
+  get _queryAccountPaths() {
+    return this._baseModuleQueryAccountPaths;
+  }
+  static hasRequiredQueries(module2) {
+    return this.missingRequiredQueries(module2).length === 0;
+  }
+  static missingRequiredQueries(module2) {
+    const moduleQueries = module2.queries;
+    return (0, import_lodash.compact)(this.requiredQueries.map((query) => {
+      return moduleQueries.includes(query) ? null : query;
+    }));
+  }
+  async addressPreviousHash() {
+    const queryPayload = {
+      schema: import_module_model4.ModuleAddressQuerySchema
+    };
+    const result = (0, import_assert3.assertEx)((await this.sendQuery(queryPayload, void 0, this.account)).find((0, import_payload_model2.isPayloadOfSchemaType)(import_module_model4.AddressPreviousHashSchema)), () => "Result did not include correct payload");
+    return result;
+  }
+  childAddressByName(name) {
+    const nodeManifests = this._state?.filter((0, import_payload_model2.isPayloadOfSchemaType)(import_manifest_model.NodeManifestPayloadSchema));
+    const childPairs = nodeManifests?.flatMap((nodeManifest) => Object.entries(nodeManifest.status?.children ?? {}));
+    return (0, import_hex.asAddress)(childPairs?.find(([_, childName]) => childName === name)?.[0]);
+  }
+  async childAddressMap() {
+    const state = await this.state();
+    const result = {};
+    const nodeManifests = state.filter((0, import_payload_model2.isPayloadOfSchemaType)(import_manifest_model.NodeManifestPayloadSchema));
+    for (const manifest of nodeManifests) {
+      const children = manifest.modules?.public ?? [];
+      for (const child of children) {
+        if (typeof child === "object") {
+          const address = child.status?.address;
+          if (address) {
+            result[address] = child.config.name ?? null;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  async manifest(maxDepth) {
+    const queryPayload = {
+      schema: import_module_model4.ModuleManifestQuerySchema,
+      ...maxDepth === void 0 ? {} : {
+        maxDepth
+      }
+    };
+    return (await this.sendQuery(queryPayload))[0];
+  }
+  async moduleAddress() {
+    const queryPayload = {
+      schema: import_module_model4.ModuleAddressQuerySchema
+    };
+    return await this.sendQuery(queryPayload);
+  }
+  async previousHash() {
+    const queryPayload = {
+      schema: import_module_model4.ModuleAddressQuerySchema
+    };
+    return (await this.sendQuery(queryPayload)).pop().previousHash;
+  }
+  async publicChildren() {
+    this._publicChildren = this._publicChildren ?? await super.publicChildren();
+    return this._publicChildren;
+  }
+  async query(query, payloads) {
+    this._checkDead();
+    return await this.busy(async () => {
+      try {
+        await this.checkSpam(query);
+        this.params.onQuerySendStarted?.({
+          payloads,
+          query
+        });
+        const result = await this.proxyQueryHandler(query, payloads);
+        this.params.onQuerySendFinished?.({
+          payloads,
+          query,
+          result,
+          status: "success"
+        });
+        if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
+          (0, import_forget2.forget)(this.storeToArchivists(result.flat()));
+        }
+        (0, import_forget2.forget)(this.emit("moduleQueried", {
+          module: this,
+          payloads,
+          query,
+          result
+        }));
+        return result;
+      } catch (ex) {
+        this.params.onQuerySendFinished?.({
+          payloads,
+          query,
+          status: "failure"
+        });
+        const error = ex;
+        this._lastError = error;
+        const deadError = new import_module_model4.DeadModuleError(this.address, error);
+        const errorPayload = {
+          message: deadError.message,
+          name: deadError.name,
+          schema: import_payload_model2.ModuleErrorSchema
+        };
+        const sourceQuery = await import_payload_builder.PayloadBuilder.build((0, import_assert3.assertEx)(import_boundwitness_wrapper2.QueryBoundWitnessWrapper.unwrap(query), () => "Invalid query"));
+        return await this.bindQueryResult(sourceQuery, [], void 0, [
+          errorPayload
+        ]);
+      }
+    });
+  }
+  queryHandler(_query, _payloads, _queryConfig) {
+    throw new Error("queryHandler should never be called");
+  }
+  async queryable(_query, _payloads, _queryConfig) {
+    return await Promise.resolve(true);
+  }
+  async resolveArchivingArchivists() {
+    return await this.params.archiving?.resolveArchivists() ?? [];
+  }
+  setConfig(config) {
+    this._config = config;
+  }
+  async startHandler() {
+    const state = await this.state();
+    const manifestPayload = state.find((payload) => (0, import_payload_model2.isPayloadOfSchemaType)(import_manifest_model.NodeManifestPayloadSchema)(payload) || (0, import_payload_model2.isPayloadOfSchemaType)(import_manifest_model.ModuleManifestPayloadSchema)(payload));
+    const manifest = (0, import_assert3.assertEx)(manifestPayload, () => "Can't find manifest payload");
+    this.setConfig({
+      ...manifest.config
+    });
+    this.downResolver.addResolver(new ModuleProxyResolver({
+      childAddressMap: await this.childAddressMap(),
+      host: this.params.host,
+      module: this,
+      moduleIdentifierTransformers: this.params.moduleIdentifierTransformers
+    }));
+    return await super.startHandler();
+  }
+  async state() {
+    if (this._state === void 0) {
+      const stateQueryPayload = {
+        query: import_module_model4.ModuleStateQuerySchema,
+        schema: import_query_payload_plugin.QuerySchema
+      };
+      const manifestQueryPayload = {
+        query: import_module_model4.ModuleManifestQuerySchema,
+        schema: import_query_payload_plugin.QuerySchema
+      };
+      this._state = [
+        stateQueryPayload,
+        manifestQueryPayload
+      ];
+      const wrapper = import_module_wrapper.ModuleWrapper.wrap(this, this.account);
+      this._state = await wrapper.state();
+    }
+    return this._state;
+  }
+  async filterErrors(result) {
+    const wrapper = await import_boundwitness_wrapper2.BoundWitnessWrapper.wrap(result[0], result[1]);
+    return wrapper.payloadsBySchema(import_payload_model2.ModuleErrorSchema);
+  }
+  //this checks and warns if we are getting spammed by the same query
+  async checkSpam(query) {
+    const hash = await import_payload_builder.PayloadBuilder.hash(query);
+    const previousCount = this._spamTrap.get(hash) ?? 0;
+    if (previousCount > 0) {
+      this.logger?.warn(`Spam trap triggered for query: ${hash} from ${(0, import_object2.toJsonString)(query.addresses)}`);
+    }
+    this._spamTrap.set(hash, previousCount + 1);
+  }
+};
+//# sourceMappingURL=index.cjs.map