@xyo-network/module-abstract 2.92.11 → 2.93.0-rc.2

package/src/AbstractModule.ts

@@ -20,10 +20,10 @@ import { ModuleManifestPayload, ModuleManifestPayloadSchema } from '@xyo-network
 import {
   AddressPreviousHashPayload,
   AddressPreviousHashSchema,
+  ArchivingModuleConfig,
   CreatableModule,
   CreatableModuleFactory,
   DeadModuleError,
-  duplicateModules,
   isModuleName,
   Module,
   ModuleAddressQuerySchema,
@@ -35,11 +35,9 @@ import {
   ModuleDiscoverQuerySchema,
   ModuleEventData,
   ModuleFactory,
-  ModuleFilter,
-  ModuleFilterOptions,
-  ModuleIdentifier,
   ModuleInstance,
   ModuleManifestQuerySchema,
+  ModuleName,
   ModuleParams,
   ModuleQueriedEventArgs,
   ModuleQueries,
@@ -67,7 +65,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
 {
   static readonly allowRandomAccount: boolean = true
   static configSchemas: string[]
-  static override defaultLogger: Logger = new ConsoleLogger(LogLevel.log)
+  static override defaultLogger: Logger = new ConsoleLogger(LogLevel.warn)
   static enableLazyLoad = false
 
   protected static privateConstructorKey = Date.now().toString()
@@ -129,6 +127,10 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return !!this.config.security?.allowAnonymous
   }
 
+  get archiving(): ArchivingModuleConfig['archiving'] | undefined {
+    return this.config.archiving
+  }
+
   get config(): TParams['config'] {
     return this.params.config
   }
@@ -356,58 +358,6 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return validators.every((validator) => validator(query, payloads))
   }
 
-  /** @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, 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, options?: ModuleFilterOptions<T>): Promise<T[]>
-  async resolve<T extends ModuleInstance = ModuleInstance>(
-    idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
-    { required = 'log', ...options }: ModuleFilterOptions<T> = {},
-  ): Promise<T | T[] | undefined> {
-    const childOptions = { ...options, required: false }
-    const direction = options?.direction ?? 'all'
-    const up = direction === 'up' || direction === 'all'
-    const down = direction === 'down' || direction === 'all'
-    let result: T | T[] | undefined
-    if (idOrFilter === '*') {
-      if (this.dead) {
-        return []
-      }
-      return [
-        ...(down ? await (this.downResolver as CompositeModuleResolver).resolve<T>('*', childOptions) : []),
-        ...(up ? await (this.upResolver as CompositeModuleResolver).resolve<T>('*', childOptions) : []),
-      ].filter(duplicateModules)
-    } else {
-      switch (typeof idOrFilter) {
-        case 'string': {
-          if (this.dead) {
-            return undefined
-          }
-          result =
-            (down ? await (this.downResolver as CompositeModuleResolver).resolve<T>(idOrFilter, childOptions) : undefined) ??
-            (up ? await (this.upResolver as CompositeModuleResolver).resolve<T>(idOrFilter, childOptions) : undefined)
-          break
-        }
-        default: {
-          if (this.dead) {
-            return []
-          }
-          const filter: ModuleFilter<T> | undefined = idOrFilter
-          result = [
-            ...(down ? await (this.downResolver as CompositeModuleResolver).resolve<T>(filter, childOptions) : []),
-            ...(up ? await (this.upResolver as CompositeModuleResolver).resolve<T>(filter, childOptions) : []),
-          ].filter(duplicateModules)
-          break
-        }
-      }
-    }
-    this.validateRequiredResolve(required, result, idOrFilter)
-    return result
-  }
-
   start(_timeout?: number): Promisable<boolean> {
     //using promise as mutex
     this._startPromise = this._startPromise ?? this.startHandler()
@@ -544,7 +494,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
       await Promise.all(payloads.map((payload) => PayloadBuilder.build(payload))),
       await Promise.all((errors ?? [])?.map((error) => PayloadBuilder.build(error))),
     ]
-    if (this.config.archiving) {
+    if (this.archiving) {
       await this.storeToArchivists(result.flat())
     }
     return result
@@ -573,7 +523,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
   }
 
   protected async discoverHandler(_maxDepth?: number): Promise<Payload[]> {
-    const config = this.config
+    const config = await PayloadBuilder.build(this.config)
     const address = await new PayloadBuilder<AddressPayload>({ schema: AddressSchema })
       .fields({ address: this.address, name: this.config?.name })
       .build()
@@ -582,10 +532,10 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
         return await new PayloadBuilder<QueryPayload>({ schema: QuerySchema }).fields({ query }).build()
       }),
     )
-    const configSchema: ConfigPayload = {
+    const configSchema = await PayloadBuilder.build<ConfigPayload>({
       config: config.schema,
       schema: ConfigSchema,
-    }
+    })
     return compact([config, configSchema, address, ...queries])
   }
 
@@ -615,9 +565,20 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     }
   }
 
-  protected manifestHandler(_depth?: number, _ignoreAddresses?: Address[]): Promisable<ModuleManifestPayload> {
+  protected async manifestHandler(maxDepth: number = 1, _ignoreAddresses: Address[] = []): Promise<ModuleManifestPayload> {
     const name = this.config.name ?? 'Anonymous'
-    return { config: { name, ...this.config }, schema: ModuleManifestPayloadSchema, status: { address: this.address } }
+    const children = await this.downResolver.resolve('*', { direction: 'down', maxDepth })
+    const childAddressToName: Record<Address, ModuleName | null> = {}
+    for (const child of children) {
+      if (child.address !== this.address) {
+        childAddressToName[child.address] = child.config.name ?? null
+      }
+    }
+    return {
+      config: { name, ...this.config },
+      schema: ModuleManifestPayloadSchema,
+      status: { address: this.address, children: childAddressToName },
+    }
   }
 
   protected moduleAddressHandler(): Promisable<AddressPreviousHashPayload[]> {
@@ -686,13 +647,6 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return resultPayloads
   }
 
-  protected async resolveArchivingArchivists(): Promise<ArchivistInstance[]> {
-    const archivists = this.config.archiving?.archivists
-    if (!archivists) return []
-    const resolved = await Promise.all(archivists.map((archivist) => this.resolve(archivist)))
-    return compact(resolved.map((mod) => asArchivistInstance(mod)))
-  }
-
   protected async startHandler(): Promise<boolean> {
     this.validateConfig()
     await this.initializeQueryAccounts()
@@ -709,17 +663,6 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return true
   }
 
-  protected async storeToArchivists(payloads: Payload[]): Promise<Payload[]> {
-    const archivists = await this.resolveArchivingArchivists()
-    return (
-      await Promise.all(
-        archivists.map((archivist) => {
-          return archivist.insert?.(payloads)
-        }),
-      )
-    ).map(([bw]) => bw)
-  }
-
   protected subscribeHandler() {
     return
   }
@@ -755,26 +698,5 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     }, true)
   }
 
-  private validateRequiredResolve(
-    required: boolean | 'warn' | 'log',
-    result: ModuleInstance[] | ModuleInstance | undefined,
-    idOrFilter: ModuleIdentifier | ModuleFilter,
-  ) {
-    if (required && (result === undefined || (Array.isArray(result) && result.length > 0))) {
-      switch (required) {
-        case 'warn': {
-          this.logger.warn('resolve failed', idOrFilter)
-          break
-        }
-        case 'log': {
-          this.logger.log('resolve failed', idOrFilter)
-          break
-        }
-        default: {
-          this.logger.error('resolve failed', idOrFilter)
-          break
-        }
-      }
-    }
-  }
+  protected abstract storeToArchivists(payloads: Payload[]): Promise<Payload[]>
 }

package/src/AbstractModuleInstance.ts

@@ -1,15 +1,27 @@
 import { assertEx } from '@xylabs/assert'
 import { Address } from '@xylabs/hex'
+import { compact } from '@xylabs/lodash'
 import { AccountInstance } from '@xyo-network/account-model'
+import { ArchivistInstance, asArchivistInstance } from '@xyo-network/archivist-model'
 import { ModuleManifestPayload } from '@xyo-network/manifest-model'
-import { AddressPreviousHashPayload, Module, ModuleDescriptionPayload, ModuleEventData, ModuleParams } from '@xyo-network/module-model'
+import {
+  AddressPreviousHashPayload,
+  ModuleDescriptionPayload,
+  ModuleEventData,
+  ModuleFilter,
+  ModuleFilterOptions,
+  ModuleIdentifier,
+  ModuleInstance,
+  ModuleParams,
+} from '@xyo-network/module-model'
 import { Payload } from '@xyo-network/payload-model'
 
 import { AbstractModule } from './AbstractModule'
+import { ResolveHelper, ResolveHelperConfig } from './ResolveHelper'
 
 export abstract class AbstractModuleInstance<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData>
   extends AbstractModule<TParams, TEventData>
-  implements Module<TParams, TEventData>
+  implements ModuleInstance<TParams, TEventData>
 {
   constructor(privateConstructorKey: string, params: TParams, account: AccountInstance) {
     assertEx(AbstractModule.privateConstructorKey === privateConstructorKey, () => 'Use create function instead of constructor')
@@ -27,10 +39,10 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     })
   }
 
-  discover(): Promise<Payload[]> {
+  discover(maxDepth = 5): Promise<Payload[]> {
     this._checkDead()
     return this.busy(async () => {
-      return await this.discoverHandler()
+      return await this.discoverHandler(maxDepth)
     })
   }
 
@@ -48,6 +60,41 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     })
   }
 
+  /** @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, 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, options?: ModuleFilterOptions<T>): Promise<T[]>
+  async resolve<T extends ModuleInstance = ModuleInstance>(
+    idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
+    options: ModuleFilterOptions<T> = {},
+  ): Promise<T | T[] | undefined> {
+    const config: ResolveHelperConfig = {
+      address: this.address,
+      dead: this.dead,
+      downResolver: this.downResolver,
+      logger: this.logger,
+      module: this,
+      upResolver: this.upResolver,
+    }
+    if (idOrFilter === '*') {
+      return await ResolveHelper.resolve(config, idOrFilter, options)
+    }
+    switch (typeof idOrFilter) {
+      case 'string': {
+        return await ResolveHelper.resolve(config, idOrFilter, options)
+      }
+      case 'object': {
+        return await ResolveHelper.resolve(config, idOrFilter, options)
+      }
+      default: {
+        return await ResolveHelper.resolve(config, idOrFilter, options)
+      }
+    }
+  }
+
   state() {
     this._checkDead()
     return this.busy(async () => {
@@ -59,4 +106,22 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     this._checkDead()
     return this.subscribeHandler()
   }
+
+  protected async resolveArchivingArchivists(): Promise<ArchivistInstance[]> {
+    const archivists = this.config.archiving?.archivists
+    if (!archivists) return []
+    const resolved = await Promise.all(archivists.map((archivist) => this.resolve(archivist)))
+    return compact(resolved.map((mod) => asArchivistInstance(mod)))
+  }
+
+  protected async storeToArchivists(payloads: Payload[]): Promise<Payload[]> {
+    const archivists = await this.resolveArchivingArchivists()
+    return (
+      await Promise.all(
+        archivists.map((archivist) => {
+          return archivist.insert?.(payloads)
+        }),
+      )
+    ).map(([bw]) => bw)
+  }
 }

package/src/ResolveHelper.ts

@@ -0,0 +1,121 @@
+/* eslint-disable complexity */
+import { Address } from '@xylabs/hex'
+import { IdLogger, Logger } from '@xylabs/logger'
+import { toJsonString } from '@xylabs/object'
+import { duplicateModules, ModuleFilter, ModuleFilterOptions, ModuleIdentifier, ModuleInstance, ModuleResolver } from '@xyo-network/module-model'
+
+export interface ResolveHelperConfig {
+  address: Address
+  dead?: boolean
+  downResolver?: ModuleResolver
+  logger?: Logger
+  module: ModuleInstance
+  upResolver?: ModuleResolver
+}
+
+export class ResolveHelper {
+  static defaultLogger?: Logger
+  static async resolve<T extends ModuleInstance = ModuleInstance>(
+    config: ResolveHelperConfig,
+    all: '*',
+    options?: ModuleFilterOptions<T>,
+  ): Promise<T[]>
+  static async resolve<T extends ModuleInstance = ModuleInstance>(
+    config: ResolveHelperConfig,
+    filter: ModuleFilter,
+    options?: ModuleFilterOptions<T>,
+  ): Promise<T[]>
+  static async resolve<T extends ModuleInstance = ModuleInstance>(
+    config: ResolveHelperConfig,
+    id: ModuleIdentifier,
+    options?: ModuleFilterOptions<T>,
+  ): Promise<T | undefined>
+  static async resolve<T extends ModuleInstance = ModuleInstance>(
+    config: ResolveHelperConfig,
+    idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
+    { visibility, maxDepth = 5, 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 childOptions: ModuleFilterOptions<T> = { ...options, direction: 'down', maxDepth: maxDepth - 1, required: false, visibility }
+    const direction = options?.direction ?? 'all'
+    const up = direction === 'up' || direction === 'all'
+    const down = direction === 'down' || direction === 'all'
+    let result: T | T[] | undefined
+    log?.debug('start', idOrFilter, maxDepth)
+    if (idOrFilter === '*') {
+      if (dead) {
+        log?.warn('failed [dead]', idOrFilter)
+        return []
+      }
+      const modules = [
+        ...(down ? await (downResolver as ModuleResolver).resolve<T>('*', childOptions) : []),
+        ...(up ? await (upResolver as ModuleResolver).resolve<T>('*', childOptions) : []),
+      ]
+        .filter(duplicateModules)
+        .filter((module) => module.address !== config.address)
+
+      if (modules.length > 0) {
+        log?.log('modules [count]', modules.length)
+        log?.debug('modules', toJsonString(modules, 4))
+      }
+
+      if (maxDepth === 0) {
+        return modules
+      }
+      const childModules = (await Promise.all(modules.map(async (module) => await module.resolve<T>('*', childOptions))))
+        .flat()
+        .filter(duplicateModules)
+      return [module as T, ...modules, ...childModules].filter(duplicateModules)
+    } else {
+      switch (typeof idOrFilter) {
+        case 'string': {
+          if (dead) {
+            return undefined
+          }
+          result =
+            (down ? await (downResolver as ModuleResolver).resolve<T>(idOrFilter, childOptions) : undefined) ??
+            (up ? await (upResolver as ModuleResolver).resolve<T>(idOrFilter, childOptions) : undefined)
+          break
+        }
+        default: {
+          if (dead) {
+            return []
+          }
+          const filter: ModuleFilter<T> | undefined = idOrFilter
+          result = [
+            ...(down ? await (downResolver as ModuleResolver).resolve<T>(filter, childOptions) : []),
+            ...(up ? await (upResolver as ModuleResolver).resolve<T>(filter, childOptions) : []),
+          ].filter(duplicateModules)
+          break
+        }
+      }
+    }
+    this.validateRequiredResolve(required, result, idOrFilter, logger)
+    return result
+  }
+
+  static validateRequiredResolve(
+    required: boolean | 'warn' | 'log',
+    result: ModuleInstance[] | ModuleInstance | undefined,
+    idOrFilter: ModuleIdentifier | ModuleFilter,
+    logger = this.defaultLogger,
+  ) {
+    const log = logger ? new IdLogger(logger, () => `validateRequiredResolve [${idOrFilter}][${result}]`) : undefined
+    if (required && (result === undefined || (Array.isArray(result) && result.length > 0))) {
+      switch (required) {
+        case 'warn': {
+          log?.warn('resolve failed', idOrFilter)
+          break
+        }
+        case 'log': {
+          log?.log('resolve failed', idOrFilter)
+          break
+        }
+        default: {
+          throw new Error(`resolve failed [${idOrFilter}]`)
+        }
+      }
+    }
+  }
+}

package/src/index.ts

@@ -3,3 +3,4 @@ export * from './AbstractModuleInstance'
 export * from './BaseEmitter'
 export * from './Error'
 export * from './QueryValidator'
+export * from './ResolveHelper'