@xyo-network/bridge-abstract 2.111.3 → 3.0.1

package/dist/browser/index.mjs

@@ -1,585 +0,0 @@
-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 { 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 { AddressSchema, isAddressModuleFilter, isNameModuleFilter, resolveAddressToInstance, resolvePathToAddress, transformModuleIdentifier } 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 discoverRoots() {
-    return this.config.client?.discoverRoots ?? this.config.discoverRoots ?? (this.config.client === void 0 ? false : "start");
-  }
-  get queries() {
-    return [
-      BridgeConnectQuerySchema,
-      BridgeDisconnectQuerySchema,
-      BridgeExposeQuerySchema,
-      BridgeUnexposeQuerySchema,
-      ...super.queries
-    ];
-  }
-  get resolver() {
-    return assertEx(this.params.resolver, () => "No resolver provided");
-  }
-  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", {
-      mod: 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 = assertEx(parts.shift(), () => "Missing module identifier");
-        const firstId = await transformModuleIdentifier(first, this.moduleIdentifierTransformers);
-        const result = workingSet.find((mod) => {
-          return firstId === mod.address || firstId === 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() {
-    if (this.discoverRoots === "lazy") {
-      forget(this.getRoots());
-    } else if (this.discoverRoots === "start") {
-      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", {
-      mod: this,
-      modules
-    });
-    return modules.map((mod) => mod.address);
-  }
-  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);
-          for (const mod of modules) {
-            const addressPayload = {
-              address: mod.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 moduleAddresses = await this.unexpose(id, options);
-          for (const address of moduleAddresses) {
-            const addressPayload = {
-              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((mod, account) => {
-  if (isArchivistModule(mod)) {
-    return ArchivistWrapper.wrap(mod, account);
-  }
-  if (isDivinerModule(mod)) {
-    return DivinerWrapper.wrap(mod, account);
-  }
-  if (isNodeModule(mod)) {
-    return NodeWrapper.wrap(mod, account);
-  }
-  if (isSentinelModule(mod)) {
-    return SentinelWrapper.wrap(mod, account);
-  }
-  if (isWitnessModule(mod)) {
-    return WitnessWrapper.wrap(mod, 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.mod;
-  }
-  get childAddressMap() {
-    return this.options.childAddressMap;
-  }
-  get host() {
-    return this.options.host;
-  }
-  get mod() {
-    return this.options.mod;
-  }
-  addResolver(_resolver) {
-    throw new Error("Not supported");
-  }
-  childManifest(address) {
-    return this.options.childManifests?.[address];
-  }
-  childState(address) {
-    return this.options.childStates?.[address];
-  }
-  removeResolver(_resolver) {
-    throw new Error("Not supported");
-  }
-  // eslint-disable-next-line complexity
-  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;
-          }
-          console.log(`ModuleProxyResolver: ${firstPartAddress} | ${this.root.address}`);
-          if (firstPartAddress === this.root.address) {
-            const wrapped = wrapModuleWithType(this.root, await Account.random());
-            return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped;
-          }
-          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, await Account.random());
-              return remainingParts ? wrapped?.resolve(remainingParts, options) : wrapped;
-            }
-            return;
-          }
-        }
-      }
-      return;
-    } else {
-      const filter = idOrFilter;
-      if (isAddressModuleFilter2(filter)) {
-        return (await Promise.all(filter.address.map((item) => this.resolve(item, options)))).filter(exists2);
-      } 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;
-    }
-    if (this.root.address === id) {
-      return this.root.address;
-    }
-    if (this.root.modName === id) {
-      return this.root.address;
-    }
-    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);
-  }
-  static hasRequiredQueries(mod) {
-    return this.missingRequiredQueries(mod).length === 0;
-  }
-  static missingRequiredQueries(mod) {
-    const moduleQueries = mod.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() {
-    let nodeManifests = isPayloadOfSchemaType2(NodeManifestPayloadSchema)(this.params.manifest) ? [
-      this.params.manifest
-    ] : void 0;
-    const result = {};
-    if (nodeManifests === void 0) {
-      const state = await this.state();
-      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);
-        if (this.archiving && this.isAllowedArchivingQuery(query.schema)) {
-          forget2(this.storeToArchivists([
-            query,
-            ...payloads ?? []
-          ]));
-        }
-        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", {
-          mod: 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;
-  }
-  setState(state) {
-    this._state = state;
-  }
-  async startHandler() {
-    let manifest = this.params.manifest;
-    if (!manifest) {
-      const state = await this.state();
-      const manifestPayload = state.find((payload) => isPayloadOfSchemaType2(NodeManifestPayloadSchema)(payload) || isPayloadOfSchemaType2(ModuleManifestPayloadSchema)(payload));
-      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,
-      mod: 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.mjs.map