@xyo-network/module-abstract 2.93.0-rc.1 → 2.93.0

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

@@ -1,13 +1,20 @@
-import { Logger } from '@xylabs/logger'
+/* 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: '*',
@@ -26,22 +33,40 @@ export class ResolveHelper {
   static async resolve<T extends ModuleInstance = ModuleInstance>(
     config: ResolveHelperConfig,
     idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
-    { required = 'log', ...options }: ModuleFilterOptions<T> = {},
+    { visibility, maxDepth = 5, required = 'log', ...options }: ModuleFilterOptions<T> = {},
   ): Promise<T | T[] | undefined> {
-    const { dead = false, upResolver, downResolver } = config
-    const childOptions = { ...options, required: false }
+    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 []
       }
-      return [
+      const modules = [
         ...(down ? await (downResolver as ModuleResolver).resolve<T>('*', childOptions) : []),
         ...(up ? await (upResolver as ModuleResolver).resolve<T>('*', childOptions) : []),
-      ].filter(duplicateModules)
+      ]
+        .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': {
@@ -66,7 +91,7 @@ export class ResolveHelper {
         }
       }
     }
-    this.validateRequiredResolve(required, result, idOrFilter)
+    this.validateRequiredResolve(required, result, idOrFilter, logger)
     return result
   }
 
@@ -74,21 +99,21 @@ export class ResolveHelper {
     required: boolean | 'warn' | 'log',
     result: ModuleInstance[] | ModuleInstance | undefined,
     idOrFilter: ModuleIdentifier | ModuleFilter,
-    logger?: Logger,
+    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': {
-          logger?.warn('resolve failed', idOrFilter)
+          log?.warn('resolve failed', idOrFilter)
           break
         }
         case 'log': {
-          logger?.log('resolve failed', idOrFilter)
+          log?.log('resolve failed', idOrFilter)
           break
         }
         default: {
-          logger?.error('resolve failed', idOrFilter)
-          break
+          throw new Error(`resolve failed [${idOrFilter}]`)
         }
       }
     }