@xyo-network/module-resolver 5.3.30 → 5.4.0

package/dist/neutral/index.mjs

@@ -49,23 +49,345 @@ var AbstractModuleResolver = class extends Base {
 
 // src/CompositeModuleResolver.ts
 import {
-  assertEx as assertEx3,
-  exists as exists2,
-  isDefined,
-  isString
+  assertEx as assertEx6,
+  exists as exists3,
+  isDefined as isDefined2,
+  isString as isString2
 } from "@xylabs/sdk-js";
 import {
-  duplicateModules,
-  ObjectResolverPriority as ObjectResolverPriority2,
-  ResolveHelper
+  duplicateModules as duplicateModules3,
+  ObjectResolverPriority as ObjectResolverPriority2
 } from "@xyo-network/module-model";
 import { LRUCache } from "lru-cache";
 
-// src/SimpleModuleResolver.ts
+// src/ResolveHelper/resolveAddressToInstance.ts
+var resolveAddressToInstanceDown = async (root, address, includePrivate = void 0, ignore = []) => {
+  if (root.address === address) {
+    return root;
+  }
+  const cache = root.addressCache?.("up", !!includePrivate);
+  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
+  const publicChildren = await root.publicChildren?.() ?? [];
+  const children = [...privateChildren, ...publicChildren];
+  for (const child of children) {
+    const found = await resolveAddressToInstanceDown(child, address, includePrivate, ignore);
+    if (found) {
+      cache?.set(address, new WeakRef(found));
+      return found;
+    }
+  }
+  cache?.set(address, null);
+};
+var resolveAddressToInstanceSiblings = async (root, address, includePrivate = void 0, ignore = []) => {
+  const siblings = await root.siblings?.() ?? [];
+  for (const sibling of siblings) {
+    const found = await resolveAddressToInstanceDown(sibling, address, includePrivate, ignore);
+    if (found) {
+      return found;
+    }
+  }
+};
+var resolveAddressToInstanceUp = async (root, address, includePrivate = void 0, ignore = []) => {
+  const cache = root.addressCache?.("up", includePrivate ?? true);
+  const parents = await root.parents?.() ?? [];
+  for (const parent of parents) {
+    const found = await resolveAddressToInstance(parent, address, includePrivate, ignore);
+    if (found) {
+      cache?.set(address, new WeakRef(found));
+      return found;
+    }
+  }
+  cache?.set(address, null);
+};
+var resolveAddressToInstanceAll = async (root, address, includePrivate = void 0, ignore = []) => {
+  const cache = root.addressCache?.("all", !!includePrivate);
+  const result = await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore) ?? await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore);
+  cache?.set(address, result ? new WeakRef(result) : null);
+  return result;
+};
+var resolveAddressToInstance = async (root, address, includePrivate = void 0, ignore = [], direction = "all") => {
+  switch (direction) {
+    case "all": {
+      return await resolveAddressToInstanceAll(root, address, includePrivate, ignore);
+    }
+    case "up": {
+      return await resolveAddressToInstanceUp(root, address, includePrivate ?? true, ignore);
+    }
+    case "down": {
+      return await resolveAddressToInstanceDown(root, address, includePrivate ?? false, ignore);
+    }
+  }
+};
+
+// src/ResolveHelper/resolveAll.ts
+import { duplicateModules } from "@xyo-network/module-model";
+var resolveAllUp = async (root, maxDepth = 10, exclude = []) => {
+  if (maxDepth === 0) {
+    return [root].filter((mod) => !exclude.includes(mod.address));
+  }
+  const parents = (await root.parents()).filter((mod) => !exclude.includes(mod.address));
+  return (maxDepth > 1 ? [
+    ...(await Promise.all(parents.map(async (mod) => await resolveAllUp(mod, maxDepth - 1, [...exclude, root.address])))).flat(),
+    ...(await Promise.all(parents.map(async (mod) => await resolveAllDown(mod, maxDepth - 1, [...exclude, root.address], true)))).flat(),
+    ...parents,
+    root
+  ] : [...parents, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
+};
+var resolveAllDown = async (root, maxDepth = 10, exclude = [], includePrivate = false) => {
+  if (maxDepth === 0) {
+    return [root];
+  }
+  const children = (await root.publicChildren()).filter((mod) => !exclude.includes(mod.address));
+  const privateChildren = includePrivate ? (await root.privateChildren()).filter((mod) => !exclude.includes(mod.address)) : [];
+  return (maxDepth > 1 ? [
+    ...children,
+    ...(await Promise.all(children.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
+    ...(await Promise.all(privateChildren.map((child) => resolveAllDown(child, maxDepth - 1, [...exclude, root.address])))).flat(),
+    root
+  ] : [...children, root]).filter((mod) => !exclude.includes(mod.address)).filter(duplicateModules);
+};
+var resolveAll = async (root, maxDepth = 10, exclude = []) => {
+  if (maxDepth === 0) {
+    return [root];
+  }
+  return [...await resolveAllUp(root, maxDepth, exclude), ...await resolveAllDown(root, maxDepth, exclude)].filter(duplicateModules);
+};
+
+// src/ResolveHelper/ResolveHelper.ts
 import {
-  assertEx as assertEx2,
+  assertEx as assertEx4,
   exists,
-  isAddress
+  IdLogger,
+  isAddress,
+  isDefined,
+  isString,
+  isTruthy
+} from "@xylabs/sdk-js";
+import { asModuleInstance as asModuleInstance3, duplicateModules as duplicateModules2 } from "@xyo-network/module-model";
+
+// src/ResolveHelper/ResolveHelperStatic.ts
+var ResolveHelperStatic = class {
+  static defaultLogger;
+  static transformers = [];
+};
+
+// src/ResolveHelper/resolvePathToInstance.ts
+import { asAddress, assertEx as assertEx2 } from "@xylabs/sdk-js";
+import { MODULE_PATH_SEPARATOR } from "@xyo-network/module-model";
+
+// src/ResolveHelper/resolveLocalNameToInstance.ts
+var resolveLocalNameToInstanceUp = async (root, modName) => {
+  const parents = await root.parents?.() ?? [];
+  return parents.find((parent) => parent.config.name === modName);
+};
+var resolveLocalNameToInstanceDown = async (root, modName, includePrivate = void 0) => {
+  const privateChildren = (includePrivate ? await root.privateChildren?.() : []) ?? [];
+  const publicChildren = await root.publicChildren?.() ?? [];
+  const children = [...privateChildren, ...publicChildren];
+  return children.find((child) => child.config.name === modName);
+};
+var resolveLocalNameToInstanceAll = async (root, modName, includePrivate = false) => {
+  return await resolveLocalNameToInstanceDown(root, modName, includePrivate) ?? await resolveLocalNameToInstanceUp(root, modName);
+};
+var resolveLocalNameToInstance = async (root, modName, includePrivate = false, direction = "all") => {
+  switch (direction) {
+    case "all": {
+      return await resolveLocalNameToInstanceAll(root, modName, includePrivate);
+    }
+    case "up": {
+      return await resolveLocalNameToInstanceUp(root, modName);
+    }
+    case "down": {
+      return await resolveLocalNameToInstanceDown(root, modName, includePrivate);
+    }
+  }
+};
+
+// src/ResolveHelper/resolveLocalNameToAddress.ts
+var resolveLocalNameToAddressUp = async (root, modName) => {
+  return (await resolveLocalNameToInstanceUp(root, modName))?.address;
+};
+var resolveLocalNameToAddressDown = async (root, modName, includePrivate = void 0) => {
+  return (await resolveLocalNameToInstanceDown(root, modName, includePrivate))?.address;
+};
+var resolveLocalNameToAddressAll = async (root, modName, includePrivate = void 0) => {
+  return (await resolveLocalNameToInstanceAll(root, modName, includePrivate))?.address;
+};
+var resolveLocalNameToAddress = async (root, modName, includePrivate = void 0, direction = "all") => {
+  return (await resolveLocalNameToInstance(root, modName, includePrivate, direction))?.address;
+};
+
+// src/ResolveHelper/transformModuleIdentifier.ts
+var transformModuleIdentifier = async (id, transformers) => {
+  let result = id;
+  for (const transformer of transformers) {
+    result = await transformer.transform(id);
+  }
+  return result;
+};
+
+// src/ResolveHelper/resolvePathToInstance.ts
+var resolvePathToInstance = async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
+  const parts = path.split(MODULE_PATH_SEPARATOR);
+  const first = await transformModuleIdentifier(
+    assertEx2(parts.shift(), () => `First part is invalid [${path}]`),
+    transformers
+  );
+  if (!first) {
+    return void 0;
+  }
+  const firstAddress = asAddress(first) ?? await resolveLocalNameToAddress(root, first, includePrivate);
+  if (firstAddress) {
+    const firstModule = await resolveAddressToInstance(root, firstAddress, includePrivate);
+    if (firstModule && parts.length > 0) {
+      return resolvePathToInstance(firstModule, parts.join(MODULE_PATH_SEPARATOR));
+    }
+    return firstModule;
+  }
+};
+
+// src/ResolveHelper/resolvePathToAddress.ts
+var resolvePathToAddress = async (root, path, includePrivate = void 0, transformers = ResolveHelperStatic.transformers) => {
+  return (await resolvePathToInstance(root, path, includePrivate, transformers))?.address;
+};
+
+// src/ResolveHelper/traceModuleIdentifier.ts
+import { assertEx as assertEx3 } from "@xylabs/sdk-js";
+import { asModuleInstance as asModuleInstance2 } from "@xyo-network/module-model";
+var traceModuleIdentifier = async (resolver, path) => {
+  const parts = path.split(":");
+  const first = parts.shift();
+  const firstModule = asModuleInstance2(
+    assertEx3(await resolver.resolve(first, { maxDepth: 1 }), () => `Failed to resolve [${first}]`),
+    () => `Resolved invalid module instance [${first}]`
+  );
+  if (firstModule) {
+    return parts.length > 0 ? [firstModule.address, ...await traceModuleIdentifier(firstModule, parts.join(":"))] : [firstModule.address];
+  }
+  return [];
+};
+
+// src/ResolveHelper/ResolveHelper.ts
+var ResolveHelper = class _ResolveHelper extends ResolveHelperStatic {
+  static async resolve(config, id = "*", {
+    maxDepth = 3,
+    required = "log",
+    ...options
+  } = {}) {
+    const {
+      transformers,
+      mod,
+      logger = this.defaultLogger,
+      dead = false,
+      upResolver,
+      downResolver,
+      privateResolver
+    } = config;
+    const log = logger ? new IdLogger(logger, () => `ResolveHelper [${mod.id}][${id}]`) : void 0;
+    const downLocalOptions = {
+      ...options,
+      direction: "down",
+      maxDepth,
+      required: false
+    };
+    const upLocalOptions = { ...downLocalOptions, direction: "up" };
+    const childOptions = {
+      ...options,
+      maxDepth: maxDepth - 1,
+      required: false
+    };
+    const direction = options?.direction ?? "all";
+    const up = direction === "up" || direction === "all";
+    const down = direction === "down" || direction === "all";
+    let result;
+    log?.debug("start", id, maxDepth);
+    if (id === "*") {
+      if (dead) {
+        log?.warn("failed [dead]", id);
+        return [];
+      }
+      const modules = [
+        ...down ? await downResolver.resolve("*", downLocalOptions) : [],
+        ...up ? await upResolver.resolve("*", upLocalOptions) : []
+      ].filter(duplicateModules2);
+      if (modules.length > 0) {
+        log?.debug("modules [count]", modules.length);
+      }
+      if (maxDepth === 0) {
+        return modules;
+      }
+      const childModules = (await Promise.all(modules.map(async (mod2) => await mod2.resolve("*", childOptions)))).flat().filter(duplicateModules2);
+      return [...modules, ...childModules, mod].filter(duplicateModules2);
+    } else {
+      switch (typeof id) {
+        case "string": {
+          if (dead) {
+            return void 0;
+          }
+          const resolvedId = assertEx4(await resolvePathToAddress(mod, id, false, transformers) ?? id, () => "Invalid resolvedId");
+          const resolvers = [
+            [downResolver, downLocalOptions],
+            [up ? upResolver : void 0, upLocalOptions],
+            [up ? privateResolver : void 0, upLocalOptions]
+          ].filter(([resolver]) => exists(resolver));
+          for (const resolver of resolvers) {
+            const [resolverInstance] = resolver;
+            if (!result) {
+              result = await this.resolveModuleIdentifier(resolverInstance, resolvedId);
+            }
+          }
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+    }
+    this.validateRequiredResolve(required, result, id, logger);
+    return result;
+  }
+  // resolves a complex module path to addresses
+  static async resolveModuleIdentifier(resolver, path, required) {
+    const parts = path.split(":");
+    const first = parts.shift();
+    const firstIsAddress = isAddress(first);
+    const resolvedModule = await resolver.resolve(first, { maxDepth: firstIsAddress ? 10 : 1 }) ?? (isString(first) ? await resolver.resolvePrivate(first, { maxDepth: firstIsAddress ? 10 : 1 }) : void 0);
+    const finalModule = required ? assertEx4(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule;
+    const firstModule = asModuleInstance3(finalModule, () => `Resolved invalid module instance [${first}]`);
+    return isDefined(firstModule) ? parts.length > 0 ? await this.resolveModuleIdentifier(firstModule, parts.join(":")) : firstModule : void 0;
+  }
+  // translates a complex module path to addresses
+  static traceModuleIdentifier(resolver, path) {
+    return traceModuleIdentifier(resolver, path);
+  }
+  static transformModuleIdentifier(identifier, transformers = _ResolveHelper.transformers) {
+    return transformModuleIdentifier(identifier, transformers);
+  }
+  static validateRequiredResolve(required, result, id, logger = this.defaultLogger) {
+    const log = logger ? new IdLogger(logger, () => `validateRequiredResolve [${id}][${result}]`) : void 0;
+    if (isTruthy(required) && (result === void 0 || Array.isArray(result) && result.length > 0)) {
+      switch (required) {
+        case "warn": {
+          log?.warn("resolve failed", id);
+          break;
+        }
+        case "log": {
+          log?.log("resolve failed", id);
+          break;
+        }
+        default: {
+          throw new Error(`resolve failed [${id}]`);
+        }
+      }
+    }
+  }
+};
+
+// src/SimpleModuleResolver.ts
+import {
+  assertEx as assertEx5,
+  exists as exists2,
+  isAddress as isAddress2
 } from "@xylabs/sdk-js";
 import { isModuleName } from "@xyo-network/module-model";
 var SimpleModuleResolver = class extends AbstractModuleResolver {
@@ -107,8 +429,8 @@ var SimpleModuleResolver = class extends AbstractModuleResolver {
             return Object.values(this.modules);
           }
           const name = isModuleName(id) ? id : void 0;
-          const address = isAddress(id) ? id : void 0;
-          assertEx2(name || address, () => "module identifier must be a ModuleName or Address");
+          const address = isAddress2(id) ? id : void 0;
+          assertEx5(name || address, () => "module identifier must be a ModuleName or Address");
           return (name ? this.resolveByName(Object.values(this.modules), [name]).pop() : void 0) ?? (address ? this.resolveByAddress(this.modules, [address]).pop() : void 0);
         }
       } else {
@@ -137,15 +459,15 @@ var SimpleModuleResolver = class extends AbstractModuleResolver {
     if (mod) {
       const modName = mod.modName;
       if (modName && this.allowNameResolution) {
-        assertEx2(this.nameToModule[modName] === void 0, () => `Module with name ${modName} already added`);
+        assertEx5(this.nameToModule[modName] === void 0, () => `Module with name ${modName} already added`);
         this.nameToModule[modName] = mod;
       }
       this.modules[mod.address] = mod;
     }
   }
   removeSingleModule(address) {
-    assertEx2(isAddress(address), () => "Invalid address");
-    const mod = assertEx2(this.modules[address], () => "Address not found in modules");
+    assertEx5(isAddress2(address), () => "Invalid address");
+    const mod = assertEx5(this.modules[address], () => "Address not found in modules");
     delete this.modules[address];
     const modName = mod.modName;
     if (modName) {
@@ -155,12 +477,12 @@ var SimpleModuleResolver = class extends AbstractModuleResolver {
   resolveByAddress(modules, address) {
     return address.map((address2) => {
       return modules[address2];
-    }).filter(exists);
+    }).filter(exists2);
   }
   resolveByName(modules, name) {
     return name.map((name2) => {
       return modules.find((mod) => mod.modName === name2);
-    }).filter(exists);
+    }).filter(exists2);
   }
   resolveByQuery(modules, query) {
     return modules.filter((mod) => (
@@ -174,7 +496,7 @@ var SimpleModuleResolver = class extends AbstractModuleResolver {
           }, true) || supported
         );
       }, false)
-    )).filter(exists);
+    )).filter(exists2);
   }
 };
 
@@ -260,8 +582,8 @@ var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractMod
           return result2;
         })
       );
-      const flatResult = result.flat().filter(exists2);
-      return flatResult.filter((v, i, a) => duplicateModules(v, i, a));
+      const flatResult = result.flat().filter(exists3);
+      return flatResult.filter((v, i, a) => duplicateModules3(v, i, a));
     }
     if (typeof id === "string") {
       if (mutatedOptions.maxDepth < 0) {
@@ -273,7 +595,7 @@ var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractMod
         return mod ? Array.isArray(mod) ? mod : [mod] : [];
       }
       const resolvedId = await ResolveHelper.transformModuleIdentifier(id, this.moduleIdentifierTransformers);
-      if (isString(resolvedId)) {
+      if (isString2(resolvedId)) {
         if (mutatedOptions.maxDepth < 0) {
           return [];
         }
@@ -287,7 +609,7 @@ var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractMod
         }
         if (mutatedOptions.maxDepth === 0) {
           const mod2 = await this._localResolver.resolve(resolvedId, mutatedOptions);
-          return isDefined(mod2) ? Array.isArray(mod2) ? mod2 : [mod2] : [];
+          return isDefined2(mod2) ? Array.isArray(mod2) ? mod2 : [mod2] : [];
         }
         const resolvePriority = async (priority) => {
           const resolvers = this.resolvers.filter((resolver) => resolver.priority === priority);
@@ -296,8 +618,8 @@ var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractMod
               const result2 = await resolver.resolve(resolvedId, mutatedOptions);
               return result2;
             })
-          )).filter(exists2);
-          const result = results.filter(exists2).findLast((v, i, a) => duplicateModules(v, i, a));
+          )).filter(exists3);
+          const result = results.filter(exists3).findLast((v, i, a) => duplicateModules3(v, i, a));
           if (result) {
             this._cache.set(resolvedId, result);
             return result;
@@ -319,11 +641,11 @@ var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractMod
       this.resolvers.map(async (resolver) => {
         return await resolver.resolveIdentifier(id);
       })
-    )).filter(exists2);
+    )).filter(exists3);
     const result = results.shift();
     if (results.length > 0) {
       for (const altResult of results) {
-        assertEx3(altResult === result, () => `Inconsistent results for ${id} [${result}][${altResult}]`);
+        assertEx6(altResult === result, () => `Inconsistent results for ${id} [${result}][${altResult}]`);
       }
     }
     return result;
@@ -341,15 +663,15 @@ var CompositeModuleResolver = class _CompositeModuleResolver extends AbstractMod
   }
   async resolveMultipartIdentifier(moduleIdentifier) {
     const idParts = moduleIdentifierParts(moduleIdentifier);
-    assertEx3(idParts.length >= 2, () => "Not a valid multipart identifier");
-    const id = assertEx3(idParts.shift());
+    assertEx6(idParts.length >= 2, () => "Not a valid multipart identifier");
+    const id = assertEx6(idParts.shift());
     const mod = await this.resolve(id) ?? await this.resolvePrivate(id);
     return await mod?.resolve(idParts.join(":")) ?? await mod?.resolvePrivate(idParts.join(":"));
   }
 };
 
 // src/NameRegistrarTransformer.ts
-import { isDefined as isDefined2, isUndefined } from "@xylabs/sdk-js";
+import { isDefined as isDefined3, isUndefined } from "@xylabs/sdk-js";
 import { PayloadDivinerQuerySchema } from "@xyo-network/diviner-payload-model";
 import { LRUCache as LRUCache2 } from "lru-cache";
 var NameRegistrarTransformer = class {
@@ -366,7 +688,7 @@ var NameRegistrarTransformer = class {
     const nameParts = first?.split(".");
     if (nameParts?.length === 2 && nameParts[1] === this.root) {
       const cachedResult = this._cache.get(identifier);
-      if (isDefined2(cachedResult)) return cachedResult;
+      if (isDefined3(cachedResult)) return cachedResult;
       const query = {
         domain: nameParts[0],
         order: "desc",
@@ -378,7 +700,7 @@ var NameRegistrarTransformer = class {
       if (isUndefined(resultPayload)) {
         throw new Error(`Unable to resolve registrar name (failed) [${first}]`);
       }
-      if (isDefined2(resultPayload)) {
+      if (isDefined3(resultPayload)) {
         const address = resultPayload.address?.shift();
         if (address) {
           this._cache.set(identifier, address);
@@ -427,7 +749,27 @@ export {
   AbstractModuleResolver,
   CompositeModuleResolver,
   NameRegistrarTransformer,
+  ResolveHelper,
   SimpleModuleResolver,
-  mixinResolverEventEmitter
+  mixinResolverEventEmitter,
+  resolveAddressToInstance,
+  resolveAddressToInstanceAll,
+  resolveAddressToInstanceDown,
+  resolveAddressToInstanceSiblings,
+  resolveAddressToInstanceUp,
+  resolveAll,
+  resolveAllDown,
+  resolveAllUp,
+  resolveLocalNameToAddress,
+  resolveLocalNameToAddressAll,
+  resolveLocalNameToAddressDown,
+  resolveLocalNameToAddressUp,
+  resolveLocalNameToInstance,
+  resolveLocalNameToInstanceAll,
+  resolveLocalNameToInstanceDown,
+  resolveLocalNameToInstanceUp,
+  resolvePathToAddress,
+  resolvePathToInstance,
+  transformModuleIdentifier
 };
 //# sourceMappingURL=index.mjs.map