@xyo-network/bridge-abstract 2.102.0

package/dist/browser/index.js

@@ -0,0 +1,564 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/AbstractBridge.ts
+import { assertEx } from "@xylabs/assert";
+import { exists } from "@xylabs/exists";
+import { forget } from "@xylabs/forget";
+import { globallyUnique } from "@xylabs/object";
+import { AddressSchema } from "@xyo-network/address-payload-plugin";
+import { asArchivistInstance } from "@xyo-network/archivist-model";
+import { QueryBoundWitnessWrapper } from "@xyo-network/boundwitness-wrapper";
+import { BridgeConfigSchema, BridgeConnectQuerySchema, BridgeDisconnectQuerySchema, BridgeExposeQuerySchema, BridgeUnexposeQuerySchema, ModuleFilterPayloadSchema } from "@xyo-network/bridge-model";
+import { AbstractModuleInstance } from "@xyo-network/module-abstract";
+import { isAddressModuleFilter, isNameModuleFilter, resolveAddressToInstance, resolvePathToAddress } from "@xyo-network/module-model";
+import { isPayloadOfSchemaType } from "@xyo-network/payload-model";
+var AbstractBridge = class _AbstractBridge extends AbstractModuleInstance {
+  static {
+    __name(this, "AbstractBridge");
+  }
+  static configSchemas = [
+    ...super.configSchemas,
+    BridgeConfigSchema
+  ];
+  static defaultConfigSchema = BridgeConfigSchema;
+  static uniqueName = globallyUnique("AbstractBridge", _AbstractBridge, "xyo");
+  _roots;
+  get allowNameResolution() {
+    return this.params.allowNameResolution ?? true;
+  }
+  get queries() {
+    return [
+      BridgeConnectQuerySchema,
+      BridgeDisconnectQuerySchema,
+      BridgeExposeQuerySchema,
+      BridgeUnexposeQuerySchema,
+      ...super.queries
+    ];
+  }
+  get resolver() {
+    return 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");
+    assertEx(id !== "*", () => "Exposing '*' not supported");
+    const addressToExpose = assertEx(await 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 (isNameModuleFilter(idOrFilter)) {
+          for (const mod of workingSet) {
+            if (mod.modName && idOrFilter.name.includes(mod.modName))
+              results.push(mod);
+          }
+        }
+        if (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") {
+      forget(this.getRoots());
+    } else {
+      await this.getRoots();
+    }
+    return true;
+  }
+  async unexpose(id, options) {
+    this._noOverride("unexpose");
+    const addressToUnexpose = assertEx(await 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 QueryBoundWitnessWrapper.parseQuery(query, payloads);
+    const queryPayload = await wrapper.getQuery();
+    const resultPayloads = [];
+    switch (queryPayload.schema) {
+      case BridgeExposeQuerySchema: {
+        const filterPayloads = (payloads ?? []).filter(isPayloadOfSchemaType(ModuleFilterPayloadSchema));
+        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((module) => {
+            const addressPayload = {
+              address: module.address,
+              schema: AddressSchema
+            };
+            resultPayloads.push(addressPayload);
+          });
+        }));
+        break;
+      }
+      case BridgeUnexposeQuerySchema: {
+        const filterPayloads = (payloads ?? []).filter(isPayloadOfSchemaType(ModuleFilterPayloadSchema));
+        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((module) => {
+            const addressPayload = {
+              address: module.address,
+              schema: 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) => resolvePathToAddress(parent, archivist)))).filter(exists)))).flat().filter(exists);
+    const resolved = (await Promise.all(resolvedAddresses.map((address) => resolveAddressToInstance(this, address)))).filter(exists);
+    return resolved.map((mod) => asArchivistInstance(mod)).filter(exists);
+  }
+};
+
+// src/AbstractBridgeModuleResolver.ts
+import { ObjectResolverPriority } from "@xyo-network/module-model";
+import { CompositeModuleResolver } from "@xyo-network/module-resolver";
+var AbstractBridgeModuleResolver = class extends CompositeModuleResolver {
+  static {
+    __name(this, "AbstractBridgeModuleResolver");
+  }
+  get priority() {
+    return ObjectResolverPriority.VeryLow;
+  }
+  async resolveHandler(id, options, _params) {
+    if (id === "*") {
+      return [];
+    }
+    return await super.resolveHandler(id, options);
+  }
+};
+
+// src/AbstractModuleProxy/AbstractModuleProxy.ts
+import { assertEx as assertEx3 } from "@xylabs/assert";
+import { forget as forget2 } from "@xylabs/forget";
+import { asAddress } from "@xylabs/hex";
+import { compact } from "@xylabs/lodash";
+import { toJsonString } from "@xylabs/object";
+import { BoundWitnessWrapper, QueryBoundWitnessWrapper as QueryBoundWitnessWrapper2 } from "@xyo-network/boundwitness-wrapper";
+import { ModuleManifestPayloadSchema, NodeManifestPayloadSchema } from "@xyo-network/manifest-model";
+import { AbstractModuleInstance as AbstractModuleInstance2 } from "@xyo-network/module-abstract";
+import { AddressPreviousHashSchema, DeadModuleError, ModuleAddressQuerySchema, ModuleManifestQuerySchema, ModuleStateQuerySchema } from "@xyo-network/module-model";
+import { ModuleWrapper } from "@xyo-network/module-wrapper";
+import { PayloadBuilder } from "@xyo-network/payload-builder";
+import { isPayloadOfSchemaType as isPayloadOfSchemaType2, ModuleErrorSchema } from "@xyo-network/payload-model";
+import { QuerySchema } from "@xyo-network/query-payload-plugin";
+import { LRUCache } from "lru-cache";
+
+// src/AbstractModuleProxy/ModuleProxyResolver.ts
+import { assertEx as assertEx2 } from "@xylabs/assert";
+import { exists as exists2 } from "@xylabs/exists";
+import { Account } from "@xyo-network/account";
+import { isAddressModuleFilter as isAddressModuleFilter2, isNameModuleFilter as isNameModuleFilter2, ObjectResolverPriority as ObjectResolverPriority2 } from "@xyo-network/module-model";
+import { CompositeModuleResolver as CompositeModuleResolver2 } from "@xyo-network/module-resolver";
+
+// src/wrapModuleWithType.ts
+import { isArchivistModule } from "@xyo-network/archivist-model";
+import { ArchivistWrapper } from "@xyo-network/archivist-wrapper";
+import { isDivinerModule } from "@xyo-network/diviner-model";
+import { DivinerWrapper } from "@xyo-network/diviner-wrapper";
+import { isNodeModule } from "@xyo-network/node-model";
+import { NodeWrapper } from "@xyo-network/node-wrapper";
+import { isSentinelModule } from "@xyo-network/sentinel-model";
+import { SentinelWrapper } from "@xyo-network/sentinel-wrapper";
+import { isWitnessModule } from "@xyo-network/witness-model";
+import { WitnessWrapper } from "@xyo-network/witness-wrapper";
+var wrapModuleWithType = /* @__PURE__ */ __name((module, account) => {
+  if (isArchivistModule(module)) {
+    return ArchivistWrapper.wrap(module, account);
+  }
+  if (isDivinerModule(module)) {
+    return DivinerWrapper.wrap(module, account);
+  }
+  if (isNodeModule(module)) {
+    return NodeWrapper.wrap(module, account);
+  }
+  if (isSentinelModule(module)) {
+    return SentinelWrapper.wrap(module, account);
+  }
+  if (isWitnessModule(module)) {
+    return WitnessWrapper.wrap(module, 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 CompositeModuleResolver2({
+      moduleIdentifierTransformers: options.moduleIdentifierTransformers,
+      root: this.root
+    });
+  }
+  get priority() {
+    return ObjectResolverPriority2.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(exists2);
+    } else if (typeof idOrFilter === "string") {
+      const idParts = idOrFilter.split(":");
+      const firstPart = assertEx2(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, Account.randomSync());
+              return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped;
+            }
+            return;
+          }
+        }
+      }
+      return;
+    } else {
+      const filter = idOrFilter;
+      if (isAddressModuleFilter2(filter)) {
+        const results = (await Promise.all(filter.address.map((item) => this.resolve(item, options)))).filter(exists2);
+        return results;
+      } else if (isNameModuleFilter2(filter)) {
+        return (await Promise.all(filter.name.map((item) => this.resolve(item, options)))).filter(exists2);
+      }
+    }
+  }
+  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 AbstractModuleInstance2 {
+  static {
+    __name(this, "AbstractModuleProxy");
+  }
+  static requiredQueries = [
+    ModuleStateQuerySchema
+  ];
+  _config;
+  _publicChildren;
+  _state = void 0;
+  _stateInProcess = false;
+  _spamTrap = new 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 assertEx3(this._config, () => "Config not set");
+  }
+  get queries() {
+    const queryPayloads = assertEx3(this._state, () => "Module state not found.  Make sure proxy has been started").filter((item) => isPayloadOfSchemaType2(QuerySchema)(item));
+    return queryPayloads.map((payload) => payload.query);
+  }
+  get _queryAccountPaths() {
+    return this._baseModuleQueryAccountPaths;
+  }
+  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
+    };
+    const result = assertEx3((await this.sendQuery(queryPayload, void 0, this.account)).find(isPayloadOfSchemaType2(AddressPreviousHashSchema)), () => "Result did not include correct payload");
+    return result;
+  }
+  childAddressByName(name) {
+    const nodeManifests = this._state?.filter(isPayloadOfSchemaType2(NodeManifestPayloadSchema));
+    const childPairs = nodeManifests?.flatMap((nodeManifest) => Object.entries(nodeManifest.status?.children ?? {}));
+    return asAddress(childPairs?.find(([_, childName]) => childName === name)?.[0]);
+  }
+  async childAddressMap() {
+    const state = await this.state();
+    const result = {};
+    const nodeManifests = state.filter(isPayloadOfSchemaType2(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: ModuleManifestQuerySchema,
+      ...maxDepth === void 0 ? {} : {
+        maxDepth
+      }
+    };
+    return (await this.sendQuery(queryPayload))[0];
+  }
+  async moduleAddress() {
+    const queryPayload = {
+      schema: ModuleAddressQuerySchema
+    };
+    return await this.sendQuery(queryPayload);
+  }
+  async previousHash() {
+    const queryPayload = {
+      schema: 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)) {
+          forget2(this.storeToArchivists(result.flat()));
+        }
+        forget2(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 DeadModuleError(this.address, error);
+        const errorPayload = {
+          message: deadError.message,
+          name: deadError.name,
+          schema: ModuleErrorSchema
+        };
+        const sourceQuery = await PayloadBuilder.build(assertEx3(QueryBoundWitnessWrapper2.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) => isPayloadOfSchemaType2(NodeManifestPayloadSchema)(payload) || isPayloadOfSchemaType2(ModuleManifestPayloadSchema)(payload));
+    const manifest = assertEx3(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: ModuleStateQuerySchema,
+        schema: QuerySchema
+      };
+      const manifestQueryPayload = {
+        query: ModuleManifestQuerySchema,
+        schema: QuerySchema
+      };
+      this._state = [
+        stateQueryPayload,
+        manifestQueryPayload
+      ];
+      const wrapper = ModuleWrapper.wrap(this, this.account);
+      this._state = await wrapper.state();
+    }
+    return this._state;
+  }
+  async filterErrors(result) {
+    const wrapper = await BoundWitnessWrapper.wrap(result[0], result[1]);
+    return wrapper.payloadsBySchema(ModuleErrorSchema);
+  }
+  //this checks and warns if we are getting spammed by the same query
+  async checkSpam(query) {
+    const hash = await PayloadBuilder.hash(query);
+    const previousCount = this._spamTrap.get(hash) ?? 0;
+    if (previousCount > 0) {
+      this.logger?.warn(`Spam trap triggered for query: ${hash} from ${toJsonString(query.addresses)}`);
+    }
+    this._spamTrap.set(hash, previousCount + 1);
+  }
+};
+export {
+  AbstractBridge,
+  AbstractBridgeModuleResolver,
+  AbstractModuleProxy,
+  ModuleProxyResolver,
+  wrapModuleWithType
+};
+//# sourceMappingURL=index.js.map