@xyo-network/module-resolver 2.92.6 → 2.92.8

package/src/CompositeModuleResolver.ts

@@ -4,6 +4,7 @@ import { Address } from '@xylabs/hex'
 import { Base, BaseParams } from '@xylabs/object'
 import { Promisable } from '@xylabs/promise'
 import {
+  CacheConfig,
   duplicateModules,
   ModuleFilter,
   ModuleFilterOptions,
@@ -13,6 +14,7 @@ import {
   ModuleRepository,
   ModuleResolverInstance,
 } from '@xyo-network/module-model'
+import { LRUCache } from 'lru-cache'
 
 import { SimpleModuleResolver } from './SimpleModuleResolver'
 import { ModuleIdentifierTransformer } from './transformers'
@@ -20,6 +22,7 @@ import { ModuleIdentifierTransformer } from './transformers'
 export type ModuleIdentifierTransformerFunc = (id: ModuleIdentifier) => Promisable<ModuleIdentifier>
 
 export interface ModuleResolverParams extends BaseParams {
+  cache?: CacheConfig
   moduleIdentifierTransformers?: ModuleIdentifierTransformer[]
 }
 
@@ -30,13 +33,16 @@ const moduleIdentifierParts = (moduleIdentifier: ModuleIdentifier): ModuleIdenti
 export class CompositeModuleResolver extends Base<ModuleResolverParams> implements ModuleRepository, ModuleResolverInstance {
   static defaultMaxDepth = 5
   protected resolvers: ModuleResolverInstance[] = []
-  private localResolver: SimpleModuleResolver
+  private _cache: LRUCache<ModuleIdentifier, ModuleInstance>
+  private _localResolver: SimpleModuleResolver
 
-  constructor(params: ModuleResolverParams = {}) {
+  constructor({ cache, ...params }: ModuleResolverParams = {}) {
     super(params)
     const localResolver = new SimpleModuleResolver()
     this.addResolver(localResolver)
-    this.localResolver = localResolver
+    const { max = 100, ttl = 1000 * 5 /* five seconds */ } = cache ?? {}
+    this._cache = new LRUCache<ModuleIdentifier, ModuleInstance>({ max, ttl, ...cache })
+    this._localResolver = localResolver
   }
 
   private get moduleIdentifierTransformers() {
@@ -72,15 +78,37 @@ export class CompositeModuleResolver extends Base<ModuleResolverParams> implemen
     this.resolvers = this.resolvers.filter((item) => item !== resolver)
     return this
   }
-
-  async resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promise<T[]>
+  /** @deprecated do not pass undefined.  If trying to get all, pass '*' */
+  async resolve(): Promise<ModuleInstance[]>
+  async resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promise<T[]>
+  async resolve<T extends ModuleInstance = ModuleInstance>(filter: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promise<T[]>
   async resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promise<T | undefined>
+  /** @deprecated use '*' if trying to resolve all */
+  async resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promise<T[]>
   async resolve<T extends ModuleInstance = ModuleInstance>(
-    idOrFilter?: ModuleFilter<T> | ModuleIdentifier,
+    idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
     options?: ModuleFilterOptions<T>,
   ): Promise<T | T[] | undefined> {
     const mutatedOptions = { ...options, maxDepth: (options?.maxDepth ?? CompositeModuleResolver.defaultMaxDepth) - 1 }
+
+    //resolve all
+    if (idOrFilter === '*') {
+      const all = idOrFilter
+      if (mutatedOptions.maxDepth < 0) {
+        return []
+      }
+      const result = await Promise.all(
+        this.resolvers.map(async (resolver) => {
+          const result: T[] = await resolver.resolve<T>(all, mutatedOptions)
+          return result
+        }),
+      )
+      const flatResult: T[] = result.flat().filter(exists)
+      return flatResult.filter(duplicateModules)
+    }
+
     if (typeof idOrFilter === 'string') {
+      //resolve ModuleIdentifier
       const idParts = moduleIdentifierParts(idOrFilter)
       if (idParts.length > 1) {
         return await this.resolveMultipartIdentifier<T>(idOrFilter)
@@ -89,6 +117,14 @@ export class CompositeModuleResolver extends Base<ModuleResolverParams> implemen
       if (mutatedOptions.maxDepth < 0) {
         return undefined
       }
+      const cachedResult = this._cache.get(id)
+      if (cachedResult) {
+        if (cachedResult.status === 'dead') {
+          this._cache.delete(id)
+        } else {
+          return cachedResult as T
+        }
+      }
       const results = await Promise.all(
         this.resolvers.map(async (resolver) => {
           const result: T | undefined = await resolver.resolve<T>(id, mutatedOptions)
@@ -96,8 +132,12 @@ export class CompositeModuleResolver extends Base<ModuleResolverParams> implemen
         }),
       )
       const result: T | undefined = results.filter(exists).filter(duplicateModules).pop()
+      if (result) {
+        this._cache.set(id, result)
+      }
       return result
     } else {
+      //resolve filter
       const filter = idOrFilter
       if (mutatedOptions.maxDepth < 0) {
         return []
@@ -115,16 +155,16 @@ export class CompositeModuleResolver extends Base<ModuleResolverParams> implemen
 
   private addSingleModule(module?: ModuleInstance) {
     if (module) {
-      this.localResolver.add(module)
+      this._localResolver.add(module)
     }
   }
   private removeSingleModule(address: Address) {
-    this.localResolver.remove(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')
+    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(':'))

package/src/ResolverEventEmitter.ts

@@ -22,6 +22,7 @@ const getMixin = <T extends ModuleResolver = ModuleResolver>(resolver: T) => {
     const args = { filter, module }
     emit('moduleResolved', args)
   }
+  // eslint-disable-next-line deprecation/deprecation
   const { resolve } = resolver
   function originalResolve(filter?: ModuleFilter) {
     return resolve.bind(resolver)(filter)

package/src/SimpleModuleResolver.ts

@@ -1,22 +1,26 @@
-import { Address } from '@xylabs/hex'
-import { compact, flatten } from '@xylabs/lodash'
+import { assertEx } from '@xylabs/assert'
+import { Address, isAddress } from '@xylabs/hex'
+import { compact } from '@xylabs/lodash'
 import { Promisable } from '@xylabs/promise'
 import {
   isAddressModuleFilter,
+  isModuleName,
   isNameModuleFilter,
   isQueryModuleFilter,
   ModuleFilter,
   ModuleFilterOptions,
   ModuleIdentifier,
   ModuleInstance,
+  ModuleName,
   ModuleRepository,
+  ModuleResolver,
   ModuleResolverInstance,
 } from '@xyo-network/module-model'
 
 //This class is now package private (not exported from index.ts)
-export class SimpleModuleResolver implements ModuleRepository {
-  private addressToName: Record<string, string> = {}
-  private modules: Record<string, ModuleInstance> = {}
+export class SimpleModuleResolver implements ModuleRepository, ModuleResolver {
+  private addressToName: Record<Address, ModuleName> = {}
+  private modules: Record<Address, ModuleInstance> = {}
 
   add(module: ModuleInstance): this
   add(module: ModuleInstance[]): this
@@ -46,21 +50,33 @@ export class SimpleModuleResolver implements ModuleRepository {
     throw 'Removing resolvers not supported'
   }
 
-  resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promisable<T[]>
+  resolve<T extends ModuleInstance = ModuleInstance>(all: '*', options?: ModuleFilterOptions<T>): Promisable<T[]>
+  resolve<T extends ModuleInstance = ModuleInstance>(filter: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promisable<T[]>
   resolve<T extends ModuleInstance = ModuleInstance>(id: ModuleIdentifier, options?: ModuleFilterOptions<T>): Promisable<T | undefined>
+  /** @deprecated use '*' if trying to resolve all */
+  resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promisable<T[]>
   resolve<T extends ModuleInstance = ModuleInstance>(
-    idOrFilter?: ModuleFilter<T> | string,
+    idOrFilter: ModuleFilter<T> | string = '*',
     options?: ModuleFilterOptions<T>,
   ): Promisable<T[] | T | undefined> {
     const unfiltered = (() => {
       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()
+          if (idOrFilter === '*') {
+            return Object.values(this.modules) as T[]
+          }
+          const id = idOrFilter as ModuleIdentifier
+          const name = isModuleName(id) ? id : undefined
+          const address = isAddress(id) ? id : undefined
+          assertEx(name || address, () => 'module identifier must be a ModuleName or Address')
+          return (
+            (name ? this.resolveByName<T>(Object.values(this.modules), [name]).pop() : undefined) ??
+            (address ? this.resolveByAddress<T>(this.modules, [address]).pop() : undefined)
+          )
         } else {
           const filter = idOrFilter
           if (isAddressModuleFilter(filter)) {
-            return this.resolveByAddress<T>(Object.values(this.modules), filter.address)
+            return this.resolveByAddress<T>(this.modules, filter.address)
           } else if (isNameModuleFilter(filter)) {
             return this.resolveByName<T>(Object.values(this.modules), filter.name)
           } else if (isQueryModuleFilter(filter)) {
@@ -90,6 +106,7 @@ export class SimpleModuleResolver implements ModuleRepository {
   }
 
   private removeSingleModule(address: Address) {
+    assertEx(isAddress(address), () => 'Invalid address')
     if (address && this.modules[address]) {
       delete this.modules[address]
       const name = this.addressToName[address]
@@ -99,42 +116,35 @@ 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[]
+  private resolveByAddress<T extends ModuleInstance = ModuleInstance>(modules: Record<Address, ModuleInstance>, address: Address[]): T[] {
+    return compact(
+      address.map((address) => {
+        return modules[address]
+      }),
+    ) as T[]
   }
 
-  private resolveByName<T extends ModuleInstance = ModuleInstance>(modules: ModuleInstance[], name?: string[]): T[] {
-    if (name) {
-      return compact(name.flatMap((name) => modules.filter((module) => module.config?.name === name))) as T[]
-    }
-    return modules as T[]
+  private resolveByName<T extends ModuleInstance = ModuleInstance>(modules: ModuleInstance[], name: ModuleName[]): T[] {
+    return compact(
+      name.map((name) => {
+        return modules.find((module) => module.config.name === name)
+      }),
+    ) as T[]
   }
 
-  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[]
+  private resolveByQuery<T extends ModuleInstance = ModuleInstance>(modules: ModuleInstance[], query: string[][]): T[] {
+    return 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),
+      ),
+    ) as T[]
   }
 }