@xyo-network/module-resolver 2.92.11 → 2.93.0-rc.1

package/src/AbstractModuleResolver.ts

@@ -0,0 +1,53 @@
+import { assertEx } from '@xylabs/assert'
+import { Base, BaseParams, toJsonString } from '@xylabs/object'
+import { Promisable } from '@xylabs/promise'
+import { asModuleInstance, ModuleFilter, ModuleFilterOptions, ModuleIdentifier, ModuleInstance, ModuleResolver } from '@xyo-network/module-model'
+
+export abstract class AbstractModuleResolver<T extends BaseParams = BaseParams> extends Base<T> implements ModuleResolver {
+  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> | string = '*',
+    options?: ModuleFilterOptions<T>,
+  ): Promise<T[] | T | undefined> {
+    if (idOrFilter === '*') {
+      const values = (await this.resolveHandler(idOrFilter, options)) as []
+      assertEx(Array.isArray(values), () => 'resolveHandler returned a non-array')
+      return values.map((value) =>
+        asModuleInstance<T>(value, () => {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          return `resolveHandler returned invalid result (*) [${(value as any)?.constructor?.name}][${toJsonString(value)}]`
+        }),
+      )
+    }
+    switch (typeof idOrFilter) {
+      case 'string': {
+        const value = await this.resolveHandler(idOrFilter, options)
+        return asModuleInstance<T>(
+          value,
+          () =>
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            `resolveHandler returned invalid result (string) [${(value as any)?.constructor?.name}][${toJsonString(value)}]`,
+        )
+      }
+      default: {
+        const values = (await this.resolveHandler(idOrFilter, options)) as []
+        assertEx(Array.isArray(values), () => 'resolveHandler returned a non-array')
+        return values.map((value) =>
+          asModuleInstance<T>(value, () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            return `resolveHandler returned invalid result (filter) [${(value as any)?.constructor?.name}][${toJsonString(value)}]`
+          }),
+        )
+      }
+    }
+  }
+
+  abstract resolveHandler<T extends ModuleInstance = ModuleInstance>(
+    idOrFilter: ModuleFilter<T> | ModuleIdentifier,
+    options?: ModuleFilterOptions<T>,
+  ): Promisable<T | T[] | undefined>
+}

package/src/CompositeModuleResolver.ts

@@ -1,7 +1,7 @@
 import { assertEx } from '@xylabs/assert'
 import { exists } from '@xylabs/exists'
 import { Address } from '@xylabs/hex'
-import { Base, BaseParams } from '@xylabs/object'
+import { BaseParams } from '@xylabs/object'
 import { Promisable } from '@xylabs/promise'
 import {
   CacheConfig,
@@ -16,6 +16,7 @@ import {
 } from '@xyo-network/module-model'
 import { LRUCache } from 'lru-cache'
 
+import { AbstractModuleResolver } from './AbstractModuleResolver'
 import { SimpleModuleResolver } from './SimpleModuleResolver'
 import { ModuleIdentifierTransformer } from './transformers'
 
@@ -30,7 +31,7 @@ const moduleIdentifierParts = (moduleIdentifier: ModuleIdentifier): ModuleIdenti
   return moduleIdentifier?.split(':') as ModuleIdentifierPart[]
 }
 
-export class CompositeModuleResolver extends Base<ModuleResolverParams> implements ModuleRepository, ModuleResolverInstance {
+export class CompositeModuleResolver extends AbstractModuleResolver<ModuleResolverParams> implements ModuleRepository, ModuleResolverInstance {
   static defaultMaxDepth = 5
   protected resolvers: ModuleResolverInstance[] = []
   private _cache: LRUCache<ModuleIdentifier, ModuleInstance>
@@ -78,14 +79,8 @@ export class CompositeModuleResolver extends Base<ModuleResolverParams> implemen
     this.resolvers = this.resolvers.filter((item) => item !== resolver)
     return this
   }
-  /** @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>(
+
+  async resolveHandler<T extends ModuleInstance = ModuleInstance>(
     idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
     options?: ModuleFilterOptions<T>,
   ): Promise<T | T[] | undefined> {
@@ -166,7 +161,7 @@ export class CompositeModuleResolver extends Base<ModuleResolverParams> implemen
     const idParts = moduleIdentifierParts(moduleIdentifier)
     assertEx(idParts.length >= 2, () => 'Not a valid multipart identifier')
     const id = assertEx(idParts.shift())
-    const module = await this.resolve(id)
+    const module = await this.resolve<T>(id)
     return await module?.resolve<T>(idParts.join(':'))
   }
 

package/src/SimpleModuleResolver.ts

@@ -13,15 +13,20 @@ import {
   ModuleInstance,
   ModuleName,
   ModuleRepository,
-  ModuleResolver,
   ModuleResolverInstance,
 } from '@xyo-network/module-model'
 
+import { AbstractModuleResolver } from './AbstractModuleResolver'
+
 //This class is now package private (not exported from index.ts)
-export class SimpleModuleResolver implements ModuleRepository, ModuleResolver {
+export class SimpleModuleResolver extends AbstractModuleResolver implements ModuleRepository {
   private addressToName: Record<Address, ModuleName> = {}
   private modules: Record<Address, ModuleInstance> = {}
 
+  constructor() {
+    super({})
+  }
+
   add(module: ModuleInstance): this
   add(module: ModuleInstance[]): this
   add(module: ModuleInstance | ModuleInstance[]): this {
@@ -50,12 +55,7 @@ export class SimpleModuleResolver implements ModuleRepository, ModuleResolver {
     throw 'Removing resolvers not supported'
   }
 
-  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>(
+  resolveHandler<T extends ModuleInstance = ModuleInstance>(
     idOrFilter: ModuleFilter<T> | string = '*',
     options?: ModuleFilterOptions<T>,
   ): Promisable<T[] | T | undefined> {

package/src/toJson.ts

@@ -0,0 +1,45 @@
+import { JsonArray, JsonObject, JsonValue } from '@xylabs/object'
+
+const toJsonArray = (value: unknown[], cycleList?: unknown[], maxDepth = 3): JsonArray => {
+  return value.map((item) => toJsonValue(item, cycleList, maxDepth))
+}
+
+const toJsonObject = (value: object, cycleList?: unknown[], maxDepth = 3): JsonObject => {
+  const result: JsonObject = {}
+  for (const [key, entry] of Object.entries(value)) {
+    result[key] = value === undefined ? '[Undefined]' : toJsonValue(entry, cycleList, maxDepth)
+  }
+  return result
+}
+
+const toJsonValue = (value: unknown, cycleList?: unknown[], maxDepth = 3): JsonValue => {
+  console.log(`toJsonValue: ${maxDepth}`)
+  if (maxDepth <= 0 && typeof value === 'object') {
+    return '[MaxDepth]'
+  }
+  if (cycleList?.includes(value)) {
+    return '[Circular]'
+  }
+  switch (typeof value) {
+    case 'string':
+    case 'boolean':
+    case 'number': {
+      return value
+    }
+    case 'object': {
+      if (value === null) {
+        return null
+      }
+      const newCycleList = cycleList ?? []
+      newCycleList.push(value)
+      return Array.isArray(value) ? toJsonArray(value, newCycleList, maxDepth - 1) : toJsonObject(value, newCycleList, maxDepth - 1)
+    }
+    default: {
+      return `[${typeof value}]`
+    }
+  }
+}
+
+export const toJson = (value: unknown, maxDepth = 3): JsonValue => {
+  return toJsonValue(value, undefined, maxDepth)
+}