@xyo-network/module-resolver 2.90.22 → 2.91.0

package/dist/node/transformers/model.d.ts

@@ -0,0 +1,7 @@
+import { Promisable } from '@xylabs/promise';
+import { ModuleIdentifier } from '@xyo-network/module-model';
+export type ModuleIdentifierTransformerFunc = (id: ModuleIdentifier) => Promisable<ModuleIdentifier>;
+export interface ModuleIdentifierTransformer {
+    transform: ModuleIdentifierTransformerFunc;
+}
+//# sourceMappingURL=model.d.ts.map

package/dist/node/transformers/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../src/transformers/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAE5D,MAAM,MAAM,+BAA+B,GAAG,CAAC,EAAE,EAAE,gBAAgB,KAAK,UAAU,CAAC,gBAAgB,CAAC,CAAA;AAEpG,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,+BAA+B,CAAA;CAC3C"}

package/package.json

@@ -10,15 +10,17 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js/issues"
   },
   "dependencies": {
-    "@xylabs/exists": "^2.14.2",
-    "@xylabs/lodash": "^2.14.2",
-    "@xylabs/object": "^2.89.2",
-    "@xylabs/promise": "^2.14.2",
-    "@xyo-network/module-model": "~2.90.22"
+    "@xylabs/assert": "^3.0.0",
+    "@xylabs/exists": "^3.0.0",
+    "@xylabs/hex": "^3.0.0",
+    "@xylabs/lodash": "^3.0.0",
+    "@xylabs/object": "^3.0.0",
+    "@xylabs/promise": "^3.0.0",
+    "@xyo-network/module-model": "~2.91.0"
   },
   "devDependencies": {
-    "@xylabs/ts-scripts-yarn3": "^3.2.42",
-    "@xylabs/tsconfig": "^3.2.42",
+    "@xylabs/ts-scripts-yarn3": "^3.4.1",
+    "@xylabs/tsconfig": "^3.4.1",
     "jest": "^29.7.0",
     "jest-mock-extended": "^3.0.5",
     "typescript": "^5.3.3"
@@ -62,6 +64,6 @@
     "url": "https://github.com/XYOracleNetwork/sdk-xyo-client-js.git"
   },
   "sideEffects": false,
-  "version": "2.90.22",
+  "version": "2.91.0",
   "type": "module"
 }

package/src/CompositeModuleResolver.ts

@@ -1,28 +1,48 @@
+import { assertEx } from '@xylabs/assert'
 import { exists } from '@xylabs/exists'
+import { Address } from '@xylabs/hex'
 import { Base, BaseParams } from '@xylabs/object'
+import { Promisable } from '@xylabs/promise'
 import {
   duplicateModules,
   ModuleFilter,
   ModuleFilterOptions,
+  ModuleIdentifier,
+  ModuleIdentifierPart,
   ModuleInstance,
   ModuleRepository,
   ModuleResolverInstance,
 } from '@xyo-network/module-model'
 
 import { SimpleModuleResolver } from './SimpleModuleResolver'
+import { ModuleIdentifierTransformer } from './transformers'
 
-export class CompositeModuleResolver extends Base implements ModuleRepository, ModuleResolverInstance {
+export type ModuleIdentifierTransformerFunc = (id: ModuleIdentifier) => Promisable<ModuleIdentifier>
+
+export interface ModuleResolverParams extends BaseParams {
+  moduleIdentifierTransformers?: ModuleIdentifierTransformer[]
+}
+
+const moduleIdentifierParts = (moduleIdentifier: ModuleIdentifier): ModuleIdentifierPart[] => {
+  return moduleIdentifier?.split(':') as ModuleIdentifierPart[]
+}
+
+export class CompositeModuleResolver extends Base<ModuleResolverParams> implements ModuleRepository, ModuleResolverInstance {
   static defaultMaxDepth = 5
   protected resolvers: ModuleResolverInstance[] = []
   private localResolver: SimpleModuleResolver
 
-  constructor(params: BaseParams = {}) {
+  constructor(params: ModuleResolverParams = {}) {
     super(params)
     const localResolver = new SimpleModuleResolver()
     this.addResolver(localResolver)
     this.localResolver = localResolver
   }
 
+  private get moduleIdentifierTransformers() {
+    return this.params.moduleIdentifierTransformers
+  }
+
   add(module: ModuleInstance): this
   add(module: ModuleInstance[]): this
   add(module: ModuleInstance | ModuleInstance[]): this {
@@ -39,11 +59,11 @@ export class CompositeModuleResolver extends Base implements ModuleRepository, M
     return this
   }
 
-  remove(addressOrName: string | string[]): this {
-    if (Array.isArray(addressOrName)) {
-      for (const address of addressOrName) this.removeSingleModule(address)
+  remove(addresses: Address[] | Address): this {
+    if (Array.isArray(addresses)) {
+      for (const address of addresses) this.removeSingleModule(address)
     } else {
-      this.removeSingleModule(addressOrName)
+      this.removeSingleModule(addresses)
     }
     return this
   }
@@ -54,31 +74,37 @@ export class CompositeModuleResolver extends Base implements ModuleRepository, M
   }
 
   async resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promise<T[]>
-  async resolve<T extends ModuleInstance = ModuleInstance>(nameOrAddress: string, options?: ModuleFilterOptions<T>): Promise<T | undefined>
+  async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
   async resolve<T extends ModuleInstance = ModuleInstance>(
-    nameOrAddressOrFilter?: ModuleFilter<T> | string,
+    idOrFilter?: ModuleFilter<T> | ModuleIdentifier,
     options?: ModuleFilterOptions<T>,
   ): Promise<T | T[] | undefined> {
     const mutatedOptions = { ...options, maxDepth: (options?.maxDepth ?? CompositeModuleResolver.defaultMaxDepth) - 1 }
-    if (typeof nameOrAddressOrFilter === 'string') {
+    if (typeof idOrFilter === 'string') {
+      const idParts = moduleIdentifierParts(idOrFilter)
+      if (idParts.length > 1) {
+        return await this.resolveMultipartIdentifier<T>(idOrFilter)
+      }
+      const id = await this.transformModuleIdentifier(idOrFilter)
       if (mutatedOptions.maxDepth < 0) {
         return undefined
       }
       const results = await Promise.all(
         this.resolvers.map(async (resolver) => {
-          const result: T | undefined = await resolver.resolve<T>(nameOrAddressOrFilter, mutatedOptions)
+          const result: T | undefined = await resolver.resolve<T>(id, mutatedOptions)
           return result
         }),
       )
       const result: T | undefined = results.filter(exists).filter(duplicateModules).pop()
       return result
     } else {
+      const filter = idOrFilter
       if (mutatedOptions.maxDepth < 0) {
         return []
       }
       const result = await Promise.all(
         this.resolvers.map(async (resolver) => {
-          const result: T[] = await resolver.resolve<T>(nameOrAddressOrFilter, mutatedOptions)
+          const result: T[] = await resolver.resolve<T>(filter, mutatedOptions)
           return result
         }),
       )
@@ -92,7 +118,23 @@ export class CompositeModuleResolver extends Base implements ModuleRepository, M
       this.localResolver.add(module)
     }
   }
-  private removeSingleModule(addressOrName: string) {
-    this.localResolver.remove(addressOrName)
+  private removeSingleModule(address: Address) {
+    this.localResolver.remove(address)
+  }
+
+  private async resolveMultipartIdentifier<T extends ModuleInstance = ModuleInstance>(moduleIdentifier: ModuleIdentifier): Promise<T | undefined> {
+    const idParts = moduleIdentifierParts(moduleIdentifier)
+    assertEx(idParts.length >= 2, 'Not a valid multipart identifier')
+    const id = assertEx(idParts.shift())
+    const module = await this.resolve(id)
+    return await module?.resolve<T>(idParts.join(':'))
+  }
+
+  private async transformModuleIdentifier(identifier: ModuleIdentifier) {
+    let id = identifier
+    for (const transformer of this.moduleIdentifierTransformers ?? []) {
+      id = await transformer.transform(id)
+    }
+    return id
   }
 }

package/src/SimpleModuleResolver.ts

@@ -1,14 +1,16 @@
+import { Address } from '@xylabs/hex'
 import { compact, flatten } from '@xylabs/lodash'
 import { Promisable } from '@xylabs/promise'
 import {
-  AddressModuleFilter,
+  isAddressModuleFilter,
+  isNameModuleFilter,
+  isQueryModuleFilter,
   ModuleFilter,
   ModuleFilterOptions,
+  ModuleIdentifier,
   ModuleInstance,
   ModuleRepository,
   ModuleResolverInstance,
-  NameModuleFilter,
-  QueryModuleFilter,
 } from '@xyo-network/module-model'
 
 //This class is now package private (not exported from index.ts)
@@ -31,7 +33,7 @@ export class SimpleModuleResolver implements ModuleRepository {
     throw 'Adding resolvers not supported'
   }
 
-  remove(address: string | string[]): this {
+  remove(address: Address | Address[]): this {
     if (Array.isArray(address)) {
       for (const addr of address) this.removeSingleModule(addr)
     } else {
@@ -45,24 +47,25 @@ export class SimpleModuleResolver implements ModuleRepository {
   }
 
   resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promisable<T[]>
-  resolve<T extends ModuleInstance = ModuleInstance>(nameOrAddress: string, options?: ModuleFilterOptions<T>): Promisable<T | undefined>
+  resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promisable<T | undefined>
   resolve<T extends ModuleInstance = ModuleInstance>(
-    nameOrAddressOrFilter?: ModuleFilter<T> | string,
+    idOrFilter?: ModuleFilter<T> | string,
     options?: ModuleFilterOptions<T>,
   ): Promisable<T[] | T | undefined> {
     const unfiltered = (() => {
-      if (nameOrAddressOrFilter) {
-        if (typeof nameOrAddressOrFilter === 'string') {
-          return (
-            this.resolveByName<T>(Object.values(this.modules), [nameOrAddressOrFilter]).pop() ??
-            this.resolveByAddress<T>(Object.values(this.modules), [nameOrAddressOrFilter]).pop()
-          )
-        } else if ((nameOrAddressOrFilter as AddressModuleFilter).address) {
-          return this.resolveByAddress<T>(Object.values(this.modules), (nameOrAddressOrFilter as AddressModuleFilter).address)
-        } else if ((nameOrAddressOrFilter as NameModuleFilter).name) {
-          return this.resolveByName<T>(Object.values(this.modules), (nameOrAddressOrFilter as NameModuleFilter).name)
-        } else if ((nameOrAddressOrFilter as QueryModuleFilter).query) {
-          return this.resolveByQuery<T>(Object.values(this.modules), (nameOrAddressOrFilter as QueryModuleFilter).query)
+      if (idOrFilter) {
+        if (typeof idOrFilter === 'string') {
+          const id = idOrFilter
+          return this.resolveByName<T>(Object.values(this.modules), [id]).pop() ?? this.resolveByAddress<T>(Object.values(this.modules), [id]).pop()
+        } else {
+          const filter = idOrFilter
+          if (isAddressModuleFilter(filter)) {
+            return this.resolveByAddress<T>(Object.values(this.modules), filter.address)
+          } else if (isNameModuleFilter(filter)) {
+            return this.resolveByName<T>(Object.values(this.modules), filter.name)
+          } else if (isQueryModuleFilter(filter)) {
+            return this.resolveByQuery<T>(Object.values(this.modules), filter.query)
+          }
         }
       } else {
         return Object.values(this.modules) as T[]
@@ -70,7 +73,11 @@ export class SimpleModuleResolver implements ModuleRepository {
     })()
     const identity = options?.identity
     if (identity) {
-      return Array.isArray(unfiltered) ? unfiltered?.filter((module) => identity(module)) : identity(unfiltered) ? unfiltered : undefined
+      return (
+        Array.isArray(unfiltered) ? unfiltered?.filter((module) => identity(module))
+        : identity(unfiltered) ? unfiltered
+        : undefined
+      )
     } else {
       return unfiltered
     }
@@ -82,7 +89,7 @@ export class SimpleModuleResolver implements ModuleRepository {
     }
   }
 
-  private removeSingleModule(address: string) {
+  private removeSingleModule(address: Address) {
     if (address && this.modules[address]) {
       delete this.modules[address]
       const name = this.addressToName[address]
@@ -94,16 +101,15 @@ export class SimpleModuleResolver implements ModuleRepository {
 
   private resolveByAddress<T extends ModuleInstance = ModuleInstance>(modules: ModuleInstance[], address?: string[]): T[] {
     return (
-      address
-        ? compact(
-            flatten(
-              address?.map((address) => {
-                return modules.filter((module) => module.address === address)
-              }),
-            ),
-          )
-        : modules
-    ) as T[]
+      address ?
+        compact(
+          flatten(
+            address?.map((address) => {
+              return modules.filter((module) => module.address === address)
+            }),
+          ),
+        )
+      : modules) as T[]
   }
 
   private resolveByName<T extends ModuleInstance = ModuleInstance>(modules: ModuleInstance[], name?: string[]): T[] {
@@ -115,21 +121,20 @@ export class SimpleModuleResolver implements ModuleRepository {
 
   private resolveByQuery<T extends ModuleInstance = ModuleInstance>(modules: ModuleInstance[], query?: string[][]): T[] {
     return (
-      query
-        ? compact(
-            modules.filter((module) =>
-              query?.reduce((supported, queryList) => {
-                return (
-                  // eslint-disable-next-line unicorn/no-array-reduce
-                  queryList.reduce((supported, query) => {
-                    const queryable = module.queries.includes(query)
-                    return supported && queryable
-                  }, true) || supported
-                )
-              }, false),
-            ),
-          )
-        : modules
-    ) as T[]
+      query ?
+        compact(
+          modules.filter((module) =>
+            query?.reduce((supported, queryList) => {
+              return (
+                // eslint-disable-next-line unicorn/no-array-reduce
+                queryList.reduce((supported, query) => {
+                  const queryable = module.queries.includes(query)
+                  return supported && queryable
+                }, true) || supported
+              )
+            }, false),
+          ),
+        )
+      : modules) as T[]
   }
 }

package/src/index.ts

@@ -1,3 +1,2 @@
 export * from './CompositeModuleResolver'
 export * from './ResolverEventEmitter'
-export * from './SimpleModuleResolver'

package/src/transformers/Xns.ts

@@ -0,0 +1,5 @@
+import { ModuleIdentifier } from '@xyo-network/module-model'
+
+export const XnsModuleIdentifierTransformer = (id: ModuleIdentifier) => {
+  return id
+}

package/src/transformers/index.ts

@@ -0,0 +1,2 @@
+export * from './model'
+export * from './Xns'

package/src/transformers/model.ts

@@ -0,0 +1,8 @@
+import { Promisable } from '@xylabs/promise'
+import { ModuleIdentifier } from '@xyo-network/module-model'
+
+export type ModuleIdentifierTransformerFunc = (id: ModuleIdentifier) => Promisable<ModuleIdentifier>
+
+export interface ModuleIdentifierTransformer {
+  transform: ModuleIdentifierTransformerFunc
+}