@xyo-network/module-abstract 2.66.2 → 2.66.4

package/src/AbstractIndirectModule.ts

@@ -4,8 +4,7 @@ import { exists } from '@xylabs/exists'
 import { HDWallet } from '@xyo-network/account'
 import { AccountInstance } from '@xyo-network/account-model'
 import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
-import { ArchivistInstance } from '@xyo-network/archivist-model'
-import { IndirectArchivistWrapper } from '@xyo-network/archivist-wrapper'
+import { ArchivistInstance, asArchivistInstance } from '@xyo-network/archivist-model'
 import { BoundWitnessBuilder, QueryBoundWitness, QueryBoundWitnessBuilder, QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-builder'
 import { BoundWitness } from '@xyo-network/boundwitness-model'
 import { ConfigPayload, ConfigSchema } from '@xyo-network/config-payload-plugin'
@@ -18,8 +17,8 @@ import {
   CreatableModule,
   CreatableModuleFactory,
   duplicateModules,
-  IndirectModule,
   IndividualArchivistConfig,
+  Module,
   ModuleAddressQuerySchema,
   ModuleBusyEventArgs,
   ModuleConfig,
@@ -58,11 +57,11 @@ import { CompositeModuleResolver } from './Resolver'
 /** @description Abstract class for modules that allow access only through querying and not through direct calls  */
 export abstract class AbstractIndirectModule<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData>
   extends BaseEmitter<TParams, TEventData>
-  implements IndirectModule<TParams, TEventData>, IndirectModule
+  implements Module<TParams, TEventData>, Module
 {
   static configSchemas: string[]
   static enableBusy = false
-  static enableLazyLoad = true
+  static enableLazyLoad = false
 
   protected static privateConstructorKey = Date.now().toString()
 
@@ -84,8 +83,8 @@ export abstract class AbstractIndirectModule<TParams extends ModuleParams = Modu
     [ModuleManifestQuerySchema]: undefined,
     [ModuleSubscribeQuerySchema]: undefined,
   }
-  protected _started: Promise<boolean> | true | undefined = undefined
-  protected _starting: Promise<boolean> | true | undefined = undefined
+  protected _startPromise: Promisable<boolean> | undefined = undefined
+  protected _started: Promisable<boolean> | undefined = undefined
   protected readonly moduleConfigQueryValidator: Queryable
   protected readonly supportedQueryValidator: Queryable
 
@@ -97,7 +96,7 @@ export abstract class AbstractIndirectModule<TParams extends ModuleParams = Modu
     const mutatedParams = { ...params } as TParams
     super(mutatedParams)
 
-    this.supportedQueryValidator = new SupportedQueryValidator(this as IndirectModule).queryable
+    this.supportedQueryValidator = new SupportedQueryValidator(this as Module).queryable
     this.moduleConfigQueryValidator = new ModuleConfigQueryValidator(mutatedParams?.config).queryable
   }
 
@@ -139,7 +138,7 @@ export abstract class AbstractIndirectModule<TParams extends ModuleParams = Modu
 
   protected abstract get _queryAccountPaths(): Record<Query['schema'], string>
 
-  static async create<TModule extends IndirectModule>(this: CreatableModule<TModule>, params?: TModule['params']) {
+  static async create<TModule extends Module>(this: CreatableModule<TModule>, params?: TModule['params']) {
     if (!this.configSchemas || this.configSchemas.length === 0) {
       throw Error(`Missing configSchema [${params?.config?.schema}][${this.name}]`)
     }
@@ -154,14 +153,14 @@ export abstract class AbstractIndirectModule<TParams extends ModuleParams = Modu
     params?.logger?.debug(`config: ${JSON.stringify(mutatedConfig, null, 2)}`)
     const mutatedParams = { ...params, config: mutatedConfig } as TModule['params']
     const newModule = new this(AbstractIndirectModule.privateConstructorKey, mutatedParams)
+    await newModule.loadAccount?.()
     if (!AbstractIndirectModule.enableLazyLoad) {
       await newModule.start?.()
     }
-    await newModule.loadAccount?.()
     return newModule
   }
 
-  static factory<TModule extends IndirectModule>(this: CreatableModule<TModule>, params?: TModule['params']): CreatableModuleFactory<TModule> {
+  static factory<TModule extends Module>(this: CreatableModule<TModule>, params?: TModule['params']): CreatableModuleFactory<TModule> {
     return ModuleFactory.withParams(this, params)
   }
 
@@ -200,7 +199,7 @@ export abstract class AbstractIndirectModule<TParams extends ModuleParams = Modu
       if (!account) console.warn(`AbstractModule.loadAccount: No account provided - Creating Random account [${this.config.schema}]`)
       this._account = account ?? (await HDWallet.random())
     }
-    this.downResolver.add(this as IndirectModule)
+    this.downResolver.add(this as Module)
     return this._account
   }
 
@@ -238,43 +237,40 @@ export abstract class AbstractIndirectModule<TParams extends ModuleParams = Modu
     return validators.every((validator) => validator(query, payloads))
   }
 
-  async resolve<TModule extends IndirectModule = IndirectModule>(filter?: ModuleFilter, options?: ModuleFilterOptions): Promise<TModule[]>
-  async resolve<TModule extends IndirectModule = IndirectModule>(nameOrAddress: string, options?: ModuleFilterOptions): Promise<TModule | undefined>
-  async resolve<TModule extends IndirectModule = IndirectModule>(
-    nameOrAddressOrFilter?: ModuleFilter | string,
-    options?: ModuleFilterOptions,
-  ): Promise<TModule | TModule[] | undefined> {
+  async resolve(filter?: ModuleFilter, options?: ModuleFilterOptions): Promise<Module[]>
+  async resolve(nameOrAddress: string, options?: ModuleFilterOptions): Promise<Module | undefined>
+  async resolve(nameOrAddressOrFilter?: ModuleFilter | string, options?: ModuleFilterOptions): Promise<Module | Module[] | undefined> {
     const direction = options?.direction ?? 'all'
     const up = direction === 'up' || direction === 'all'
     const down = direction === 'down' || direction === 'all'
     switch (typeof nameOrAddressOrFilter) {
       case 'string': {
         return (
-          (down ? await this.downResolver.resolve<TModule>(nameOrAddressOrFilter) : undefined) ??
-          (up ? await this.upResolver.resolve<TModule>(nameOrAddressOrFilter) : undefined)
+          (down ? await this.downResolver.resolve(nameOrAddressOrFilter) : undefined) ??
+          (up ? await this.upResolver.resolve(nameOrAddressOrFilter) : undefined)
         )
       }
       default: {
         const filter: ModuleFilter | undefined = nameOrAddressOrFilter
-        return [
-          ...(down ? await this.downResolver.resolve<TModule>(filter) : []),
-          ...(up ? await this.upResolver.resolve<TModule>(filter) : []),
-        ].filter(duplicateModules)
+        return [...(down ? await this.downResolver.resolve(filter) : []), ...(up ? await this.upResolver.resolve(filter) : [])].filter(
+          duplicateModules,
+        )
       }
     }
   }
 
-  start(_timeout?: number): Promise<boolean> | boolean {
+  start(_timeout?: number): Promisable<boolean> {
     //using promise as mutex
-    this._starting = this._starting ?? this.startHandler()
-    return this._starting
+    this._startPromise = this._startPromise ?? this.startHandler()
+    return this._startPromise
   }
 
   async started(notStartedAction: 'error' | 'throw' | 'warn' | 'log' | 'none' = 'log', tryStart = true): Promise<boolean> {
-    if (this._started === true) {
+    const started = await this._started
+    if (started === true) {
       return true
     }
-    if (!this._started) {
+    if (!started) {
       //using promise as mutex
       this._started = (async () => {
         if (tryStart) {
@@ -308,12 +304,18 @@ export abstract class AbstractIndirectModule<TParams extends ModuleParams = Modu
         return false
       })()
     }
+    if (!this._started) {
+      throw 'Failed to create start promise'
+    }
     return await this._started
   }
 
   async stop(_timeout?: number): Promise<boolean> {
     return await this.busy(async () => {
-      return await this.stopHandler()
+      const result = await this.stopHandler()
+      this._started = undefined
+      this._startPromise = undefined
+      return result
     })
   }
 
@@ -567,6 +569,6 @@ export abstract class AbstractIndirectModule<TParams extends ModuleParams = Modu
         ? (this.config.archivist as string)
         : (this.config?.archivist?.[kind] as string)
     const resolved = await this.upResolver.resolve(filter)
-    return resolved ? IndirectArchivistWrapper.wrap(resolved, this.account) : undefined
+    return asArchivistInstance(resolved)
   }
 }

package/src/QueryValidator/SupportedQueryValidator.ts

@@ -1,11 +1,11 @@
 import { QueryBoundWitness, QueryBoundWitnessWrapper } from '@xyo-network/boundwitness-builder'
-import { IndirectModule, ModuleQuery } from '@xyo-network/module-model'
+import { Module, ModuleQuery } from '@xyo-network/module-model'
 import { Payload } from '@xyo-network/payload-model'
 
 import { Queryable, QueryValidator } from './QueryValidator'
 
 export const isQuerySupportedByModule = async <T extends QueryBoundWitness = QueryBoundWitness>(
-  mod: IndirectModule,
+  mod: Module,
   query: T,
   payloads?: Payload[],
 ): Promise<boolean> => {
@@ -15,7 +15,7 @@ export const isQuerySupportedByModule = async <T extends QueryBoundWitness = Que
 }
 
 export class SupportedQueryValidator implements QueryValidator {
-  constructor(protected readonly mod: IndirectModule) {}
+  constructor(protected readonly mod: Module) {}
   queryable: Queryable = (query, payloads) => {
     return isQuerySupportedByModule(this.mod, query, payloads)
   }

package/src/Resolver/CompositeModuleResolver.ts

@@ -1,6 +1,6 @@
 import { exists } from '@xylabs/exists'
 import { Base, BaseParams } from '@xyo-network/core'
-import { duplicateModules, IndirectModule, ModuleFilter, ModuleRepository, ModuleResolver } from '@xyo-network/module-model'
+import { duplicateModules, Module, ModuleFilter, ModuleRepository, ModuleResolver } from '@xyo-network/module-model'
 
 import { SimpleModuleResolver } from './SimpleModuleResolver'
 
@@ -19,9 +19,9 @@ export class CompositeModuleResolver extends Base implements ModuleRepository, M
     return true
   }
 
-  add(module: IndirectModule): this
-  add(module: IndirectModule[]): this
-  add(module: IndirectModule | IndirectModule[]): this {
+  add(module: Module): this
+  add(module: Module[]): this
+  add(module: Module | Module[]): this {
     if (Array.isArray(module)) {
       module.forEach((module) => this.addSingleModule(module))
     } else {
@@ -49,22 +49,20 @@ export class CompositeModuleResolver extends Base implements ModuleRepository, M
     return this
   }
 
-  async resolve<TModule extends IndirectModule = IndirectModule>(filter?: ModuleFilter): Promise<TModule[]>
-  async resolve<TModule extends IndirectModule = IndirectModule>(nameOrAddress: string): Promise<TModule | undefined>
-  async resolve<TModule extends IndirectModule = IndirectModule>(
-    nameOrAddressOrFilter?: ModuleFilter | string,
-  ): Promise<TModule | TModule[] | undefined> {
+  async resolve(filter?: ModuleFilter): Promise<Module[]>
+  async resolve(nameOrAddress: string): Promise<Module | undefined>
+  async resolve(nameOrAddressOrFilter?: ModuleFilter | string): Promise<Module | Module[] | undefined> {
     if (typeof nameOrAddressOrFilter === 'string') {
       const result = await Promise.all(
         this.resolvers.map(async (resolver) => {
-          return await resolver.resolve<TModule>(nameOrAddressOrFilter)
+          return await resolver.resolve(nameOrAddressOrFilter)
         }),
       )
       return result.filter(exists).filter(duplicateModules).pop()
     } else {
       const result = await Promise.all(
         this.resolvers.map(async (resolver) => {
-          return await resolver.resolve<TModule>(nameOrAddressOrFilter)
+          return await resolver.resolve(nameOrAddressOrFilter)
         }),
       )
       const flatResult = result.flat()
@@ -72,7 +70,7 @@ export class CompositeModuleResolver extends Base implements ModuleRepository, M
     }
   }
 
-  private addSingleModule(module?: IndirectModule) {
+  private addSingleModule(module?: Module) {
     if (module) {
       this.localResolver.add(module)
     }

package/src/Resolver/ResolverEventEmitter.ts

@@ -1,8 +1,8 @@
-import { IndirectModule, ModuleFilter, ModuleResolver } from '@xyo-network/module-model'
+import { Module, ModuleFilter, ModuleResolver } from '@xyo-network/module-model'
 
 export interface ModuleResolvedEventArgs {
   filter?: ModuleFilter
-  module: IndirectModule
+  module: Module
 }
 
 export interface ResolverEventEmitter {
@@ -18,7 +18,7 @@ const getMixin = <T extends ModuleResolver = ModuleResolver>(resolver: T) => {
     listeners.map((listener) => listener(args))
     return true
   }
-  const onModuleResolved = (module: IndirectModule, filter?: ModuleFilter) => {
+  const onModuleResolved = (module: Module, filter?: ModuleFilter) => {
     const args = { filter, module }
     emit('moduleResolved', args)
   }
@@ -31,8 +31,8 @@ const getMixin = <T extends ModuleResolver = ModuleResolver>(resolver: T) => {
     on: (event: 'moduleResolved', listener: (args: ModuleResolvedEventArgs) => void) => {
       listeners.push(listener)
     },
-    resolve: async (filter?: ModuleFilter): Promise<IndirectModule[]> => {
-      const modules: IndirectModule[] = await originalResolve(filter)
+    resolve: async (filter?: ModuleFilter): Promise<Module[]> => {
+      const modules: Module[] = await originalResolve(filter)
       await Promise.allSettled(modules.map((mod) => onModuleResolved(mod, filter)))
       return modules
     },

package/src/Resolver/SimpleModuleResolver.ts

@@ -1,6 +1,6 @@
 import {
   AddressModuleFilter,
-  IndirectModule,
+  Module,
   ModuleFilter,
   ModuleRepository,
   ModuleResolver,
@@ -14,15 +14,15 @@ import flatten from 'lodash/flatten'
 //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, IndirectModule> = {}
+  private modules: Record<string, Module> = {}
 
   get isModuleResolver() {
     return true
   }
 
-  add(module: IndirectModule): this
-  add(module: IndirectModule[]): this
-  add(module: IndirectModule | IndirectModule[]): this {
+  add(module: Module): this
+  add(module: Module[]): this
+  add(module: Module | Module[]): this {
     if (Array.isArray(module)) {
       module.forEach((module) => this.addSingleModule(module))
     } else {
@@ -48,30 +48,28 @@ export class SimpleModuleResolver implements ModuleRepository {
     throw 'Removing resolvers not supported'
   }
 
-  resolve<TModule extends IndirectModule = IndirectModule>(filter?: ModuleFilter): Promisable<TModule[]>
-  resolve<TModule extends IndirectModule = IndirectModule>(nameOrAddress: string): Promisable<TModule | undefined>
-  resolve<TModule extends IndirectModule = IndirectModule>(
-    nameOrAddressOrFilter?: ModuleFilter | string,
-  ): Promisable<TModule | TModule[] | undefined> {
+  resolve(filter?: ModuleFilter): Promisable<Module[]>
+  resolve(nameOrAddress: string): Promisable<Module | undefined>
+  resolve(nameOrAddressOrFilter?: ModuleFilter | string): Promisable<Module | Module[] | undefined> {
     if (nameOrAddressOrFilter) {
       if (typeof nameOrAddressOrFilter === 'string') {
         return (
-          this.resolveByName(Object.values(this.modules) as TModule[], [nameOrAddressOrFilter]).pop() ??
-          this.resolveByAddress(Object.values(this.modules) as TModule[], [nameOrAddressOrFilter]).pop()
+          this.resolveByName(Object.values(this.modules), [nameOrAddressOrFilter]).pop() ??
+          this.resolveByAddress(Object.values(this.modules), [nameOrAddressOrFilter]).pop()
         )
       } else if ((nameOrAddressOrFilter as AddressModuleFilter).address) {
-        return this.resolveByAddress<TModule>(Object.values(this.modules) as TModule[], (nameOrAddressOrFilter as AddressModuleFilter).address)
+        return this.resolveByAddress(Object.values(this.modules), (nameOrAddressOrFilter as AddressModuleFilter).address)
       } else if ((nameOrAddressOrFilter as NameModuleFilter).name) {
-        return this.resolveByName<TModule>(Object.values(this.modules) as TModule[], (nameOrAddressOrFilter as NameModuleFilter).name)
+        return this.resolveByName(Object.values(this.modules), (nameOrAddressOrFilter as NameModuleFilter).name)
       } else if ((nameOrAddressOrFilter as QueryModuleFilter).query) {
-        return this.resolveByQuery<TModule>(Object.values(this.modules) as TModule[], (nameOrAddressOrFilter as QueryModuleFilter).query)
+        return this.resolveByQuery(Object.values(this.modules), (nameOrAddressOrFilter as QueryModuleFilter).query)
       }
     } else {
-      return Object.values(this.modules) as TModule[]
+      return Object.values(this.modules)
     }
   }
 
-  private addSingleModule(module?: IndirectModule) {
+  private addSingleModule(module?: Module) {
     if (module) {
       this.modules[module.address] = module
     }
@@ -89,7 +87,7 @@ export class SimpleModuleResolver implements ModuleRepository {
     }
   }
 
-  private resolveByAddress<T extends IndirectModule = IndirectModule>(modules: T[], address?: string[]): T[] {
+  private resolveByAddress<T extends Module = Module>(modules: T[], address?: string[]): T[] {
     return address
       ? compact(
           flatten(
@@ -101,14 +99,14 @@ export class SimpleModuleResolver implements ModuleRepository {
       : modules
   }
 
-  private resolveByName<T extends IndirectModule = IndirectModule>(modules: T[], name?: string[]): T[] {
+  private resolveByName<T extends Module = Module>(modules: T[], name?: string[]): T[] {
     if (name) {
       return compact(name.map((name) => modules.filter((module) => module.config.name === name)).flat())
     }
     return modules
   }
 
-  private resolveByQuery<T extends IndirectModule = IndirectModule>(modules: T[], query?: string[][]): T[] {
+  private resolveByQuery<T extends Module = Module>(modules: T[], query?: string[][]): T[] {
     return query
       ? compact(
           modules.filter((module) =>