@xyo-network/module-model 2.94.20 → 2.94.21

package/package.json

@@ -17,17 +17,17 @@
     "@xylabs/object": "^3.0.25",
     "@xylabs/promise": "^3.0.25",
     "@xylabs/retry": "^3.0.25",
-    "@xyo-network/account-model": "~2.94.20",
-    "@xyo-network/address-payload-plugin": "~2.94.20",
-    "@xyo-network/boundwitness-model": "~2.94.20",
-    "@xyo-network/manifest-model": "~2.94.20",
-    "@xyo-network/module-events": "~2.94.20",
-    "@xyo-network/payload-model": "~2.94.20"
+    "@xyo-network/account-model": "~2.94.21",
+    "@xyo-network/address-payload-plugin": "~2.94.21",
+    "@xyo-network/boundwitness-model": "~2.94.21",
+    "@xyo-network/manifest-model": "~2.94.21",
+    "@xyo-network/module-events": "~2.94.21",
+    "@xyo-network/payload-model": "~2.94.21"
   },
   "devDependencies": {
     "@xylabs/ts-scripts-yarn3": "^3.9.0",
     "@xylabs/tsconfig": "^3.9.0",
-    "typescript": "^5.4.3"
+    "typescript": "^5.4.4"
   },
   "description": "Primary SDK for using XYO Protocol 2.0",
   "types": "dist/node/index.d.ts",
@@ -68,6 +68,6 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
   },
   "sideEffects": false,
-  "version": "2.94.20",
+  "version": "2.94.21",
   "type": "module"
 }

package/src/ResolveHelper.ts

@@ -1,7 +1,8 @@
 /* eslint-disable max-statements */
 /* eslint-disable complexity */
 import { assertEx } from '@xylabs/assert'
-import { Address } from '@xylabs/hex'
+import { exists } from '@xylabs/exists'
+import { Address, isAddress } from '@xylabs/hex'
 import { IdLogger, Logger } from '@xylabs/logger'
 import { toJsonString } from '@xylabs/object'
 
@@ -15,7 +16,7 @@ Resolution rules
 
 1. Resolution is always done from the perspective of the module whose resolve function was called.
 
-2. Requesting '*' will return all the modules that the resolver can see.
+2. Requesting '*' will return all the modules that the resolver can see. [limited by maxDepth]
 
 3. Requesting a simple ModuleName (string w/o ':' separator) will return an immediate child that has that name.
 
@@ -40,11 +41,13 @@ Resolution rules
     a) Up Traversal
       i)    Every module's upResolver also can call it's parent's upResolver
       ii)   An upResolver also can see the parent's children's downResolvers
-      iii)  This means that when traversing upResolvers, you can traverse all the way up.
+      iii)  This means that when traversing upResolvers, you can traverse all the way up. [limited by maxDepth]
       iv)   At any point of the up traversal, it can start traversing down to any immediate child, public or private.
     b) Down Traversal
       i)    A down traversal is limited to the public children of the module. [The same as scope as calling the 'resolve' function]
 
+9. An up or a down traversal counts against the maxDepth
+
 */
 
 export interface ResolveHelperConfig {
@@ -53,6 +56,7 @@ export interface ResolveHelperConfig {
   downResolver?: ModuleResolver
   logger?: Logger
   module: ModuleInstance
+  privateResolver?: ModuleResolver
   upResolver?: ModuleResolver
 }
 
@@ -76,15 +80,15 @@ export class ResolveHelper {
   static async resolve<T extends ModuleInstance = ModuleInstance>(
     config: ResolveHelperConfig,
     idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
-    { visibility, maxDepth = 3, required = 'log', ...options }: ModuleFilterOptions<T> = {},
+    { maxDepth = 3, required = 'log', ...options }: ModuleFilterOptions<T> = {},
   ): Promise<T | T[] | undefined> {
-    const { module, logger = this.defaultLogger, dead = false, upResolver, downResolver } = config
-    const log = logger ? new IdLogger(logger, () => `ResolveHelper [${module.id}][${idOrFilter}][${visibility}]`) : undefined
+    const { module, logger = this.defaultLogger, dead = false, upResolver, downResolver, privateResolver } = config
+    const log = logger ? new IdLogger(logger, () => `ResolveHelper [${module.id}][${idOrFilter}]`) : undefined
 
-    const downLocalOptions: ModuleFilterOptions<T> = { ...options, direction: 'down', maxDepth, required: false, visibility }
+    const downLocalOptions: ModuleFilterOptions<T> = { ...options, direction: 'down', maxDepth, required: false }
     const upLocalOptions: ModuleFilterOptions<T> = { ...downLocalOptions, direction: 'up' }
 
-    const childOptions: ModuleFilterOptions<T> = { ...options, maxDepth: maxDepth - 1, required: false, visibility }
+    const childOptions: ModuleFilterOptions<T> = { ...options, maxDepth: maxDepth - 1, required: false }
 
     const direction = options?.direction ?? 'all'
     const up = direction === 'up' || direction === 'all'
@@ -121,9 +125,20 @@ export class ResolveHelper {
           if (dead) {
             return undefined
           }
-          result =
-            (down && downResolver ? await this.resolveModuleIdentifier<T>(downResolver, idOrFilter) : undefined) ??
-            (up && upResolver ? await this.resolveModuleIdentifier<T>(upResolver, idOrFilter) : undefined)
+
+          const resolvers = [
+            [downResolver, downLocalOptions],
+            [up ? upResolver : undefined, upLocalOptions],
+            [up ? privateResolver : undefined, upLocalOptions],
+          ].filter(([resolver]) => exists(resolver)) as [ModuleResolver, ModuleFilterOptions<T>][]
+
+          for (const resolver of resolvers) {
+            const [resolverInstance] = resolver
+            if (!result) {
+              result = await this.resolveModuleIdentifier<T>(resolverInstance, idOrFilter)
+            }
+          }
+
           break
         }
         default: {
@@ -147,13 +162,16 @@ export class ResolveHelper {
   static async resolveModuleIdentifier<T extends ModuleInstance = ModuleInstance>(
     resolver: ModuleResolver,
     path: ModuleIdentifier,
+    required?: boolean,
   ): Promise<T | undefined> {
     const parts = path.split(':')
     const first = parts.shift()
-    const firstModule = asModuleInstance(
-      assertEx(await resolver.resolve(first, { maxDepth: 1 }), () => `Failed to resolve [${first}]`),
-      () => `Resolved invalid module instance [${first}]`,
-    ) as T
+    const firstIsAddress = isAddress(first)
+    const resolvedModule =
+      (await resolver.resolve(first, { maxDepth: firstIsAddress ? 10 : 1 })) ??
+      (first ? await resolver.resolvePrivate(first, { maxDepth: firstIsAddress ? 10 : 1 }) : undefined)
+    const finalModule = required ? assertEx(resolvedModule, () => `Failed to resolve [${first}] [${firstIsAddress}]`) : resolvedModule
+    const firstModule = asModuleInstance(finalModule, () => `Resolved invalid module instance [${first}]`) as T
     if (firstModule) {
       return parts.length > 0 ? await this.resolveModuleIdentifier<T>(firstModule, parts.join(':')) : firstModule
     }

package/src/instance/ModuleResolver.ts

@@ -11,6 +11,7 @@ export const isModuleResolver = isObjectResolver<ModuleInstance>
 export interface ModuleResolver<TResult extends ModuleInstance = ModuleInstance> extends ObjectResolver<TResult> {}
 
 export interface ModuleNameResolver {
+  readonly root: ModuleInstance
   resolveIdentifier(id: ModuleIdentifier, options?: ObjectFilterOptions): Promisable<Address | undefined>
 }
 

package/src/instance/ObjectFilter.ts

@@ -16,7 +16,6 @@ export interface ResolveStrategy {
 export interface ObjectFilterOptions<T extends EmptyObject = AnyObject> extends ResolveStrategy {
   direction?: Direction
   identity?: TypeCheck<T>
-  visibility?: Visibility
 }
 
 export interface AddressObjectFilter<T extends EmptyObject = AnyObject> extends ObjectFilterOptions<T> {

package/src/instance/ObjectResolver.ts

@@ -30,6 +30,10 @@ export interface ObjectResolver<TResult extends EmptyObject> {
     idOrFilter?: ObjectFilter<T> | ModuleIdentifier,
     options?: ObjectFilterOptions<T>,
   ): Promisable<T | T[] | undefined>
+
+  resolvePrivate<T extends TResult = TResult>(all: '*', options?: ObjectFilterOptions<T>): Promise<T[]>
+  resolvePrivate<T extends TResult = TResult>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | undefined>
+  resolvePrivate<T extends TResult = TResult>(id: ModuleIdentifier, options?: ObjectFilterOptions<T>): Promise<T | T[] | undefined>
 }
 
 export interface ObjectResolverInstance<TResult extends EmptyObject> extends ObjectResolver<TResult> {

package/src/instance/attachable/AttachableInstance.ts

@@ -10,6 +10,9 @@ export interface AttachableModuleInstance<TParams extends ModuleParams = ModuleP
   /* The resolver is a 'down' resolver.  It can resolve the module or any children (if it is a node for example), that are in the module*/
   readonly downResolver: ModuleResolverInstance
 
+  // The resolver that gets called by children (usually only Nodes have this)
+  readonly privateResolver: ModuleResolverInstance
+
   /* The resolver is a 'up' resolver.  It can resolve the parent or any children of the parent*/
   /* This is set by a NodeModule when attaching to the module */
   readonly upResolver: ModuleResolverInstance