@xyo-network/module-abstract 2.92.6 → 2.92.8

package/src/AbstractModule.ts

@@ -1,8 +1,9 @@
+/* eslint-disable complexity */
 /* eslint-disable max-lines */
 import { assertEx } from '@xylabs/assert'
 import { handleError, handleErrorAsync } from '@xylabs/error'
 import { exists } from '@xylabs/exists'
-import { Hash } from '@xylabs/hex'
+import { Address, Hash } from '@xylabs/hex'
 import { compact } from '@xylabs/lodash'
 import { ConsoleLogger, IdLogger, Logger, LogLevel } from '@xylabs/logger'
 import { Base } from '@xylabs/object'
@@ -21,6 +22,7 @@ import {
   AddressPreviousHashSchema,
   CreatableModule,
   CreatableModuleFactory,
+  DeadModuleError,
   duplicateModules,
   isModuleName,
   Module,
@@ -44,6 +46,7 @@ import {
   ModuleQueryHandlerResult,
   ModuleQueryResult,
   ModuleStateQuerySchema,
+  ModuleStatus,
   ModuleSubscribeQuerySchema,
   serializableField,
 } from '@xyo-network/module-model'
@@ -69,8 +72,8 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
 
   protected static privateConstructorKey = Date.now().toString()
 
-  readonly downResolver: Omit<CompositeModuleResolver, 'resolve'> = new CompositeModuleResolver()
-  readonly upResolver: Omit<CompositeModuleResolver, 'resolve>'> = new CompositeModuleResolver()
+  readonly downResolver = new CompositeModuleResolver()
+  readonly upResolver = new CompositeModuleResolver()
 
   protected _account: AccountInstance | undefined = undefined
   protected readonly _baseModuleQueryAccountPaths: Record<ModuleQueries['schema'], string> = {
@@ -81,6 +84,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     [ModuleStateQuerySchema]: '6',
     [ModuleSubscribeQuerySchema]: '3',
   }
+  protected _lastError?: Error
   protected readonly _queryAccounts: Record<ModuleQueries['schema'], AccountInstance | undefined> = {
     [ModuleAddressQuerySchema]: undefined,
     [ModuleDescribeQuerySchema]: undefined,
@@ -95,9 +99,10 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
   protected readonly supportedQueryValidator: Queryable
 
   private _busyCount = 0
+  private _status: ModuleStatus = 'stopped'
 
   constructor(privateConstructorKey: string, params: TParams, account: AccountInstance) {
-    assertEx(AbstractModule.privateConstructorKey === privateConstructorKey, 'Use create function instead of constructor')
+    assertEx(AbstractModule.privateConstructorKey === privateConstructorKey, () => 'Use create function instead of constructor')
     // Clone params to prevent mutation of the incoming object
     const mutatedParams = { ...params } as TParams
     super(mutatedParams)
@@ -113,7 +118,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
   }
 
   get account() {
-    return assertEx(this._account, 'Missing account')
+    return assertEx(this._account, () => 'Missing account')
   }
 
   get address() {
@@ -128,6 +133,10 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return this.params.config
   }
 
+  get dead() {
+    return this.status === 'dead'
+  }
+
   get ephemeralQueryAccountEnabled(): boolean {
     return !!this.params.ephemeralQueryAccountEnabled
   }
@@ -155,6 +164,10 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return this._queryAccounts
   }
 
+  get status() {
+    return this._status
+  }
+
   get timestamp() {
     return this.config.timestamp ?? false
   }
@@ -167,6 +180,12 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return this.params?.logger ?? AbstractModule.defaultLogger ?? Base.defaultLogger
   }
 
+  protected set status(value: ModuleStatus) {
+    if (this._status !== 'dead') {
+      this._status = value
+    }
+  }
+
   protected abstract get _queryAccountPaths(): Record<Query['schema'], string>
 
   static _getRootFunction(funcName: string) {
@@ -183,7 +202,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     const thisFunc = (this as any)[functionName]
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const rootFunc = this._getRootFunction(functionName)
-    assertEx(thisFunc === rootFunc, `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
+    assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
   }
 
   static async create<TModule extends ModuleInstance>(
@@ -195,7 +214,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
       throw new Error(`Missing configSchema [${params?.config?.schema}][${this.name}]`)
     }
 
-    assertEx(params?.config?.name === undefined || isModuleName(params.config.name), `Invalid module name: ${params?.config?.name}`)
+    assertEx(params?.config?.name === undefined || isModuleName(params.config.name), () => `Invalid module name: ${params?.config?.name}`)
 
     const { account } = params ?? {}
 
@@ -244,14 +263,6 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return anyThis[funcName]
   }
 
-  _noOverride(functionName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const thisFunc = (this as any)[functionName]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const rootFunc = this._getRootFunction(functionName)
-    assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
-  }
-
   async busy<R>(closure: () => Promise<R>) {
     if (this._busyCount <= 0) {
       this._busyCount = 0
@@ -279,6 +290,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
   }
 
   previousHash(): Promisable<string | undefined> {
+    this._checkDead()
     return this.account.previousHash
   }
 
@@ -287,8 +299,9 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     payloads?: Payload[],
     queryConfig?: TConfig,
   ): Promise<ModuleQueryResult> {
+    this._checkDead()
     this._noOverride('query')
-    const sourceQuery = await PayloadBuilder.build(assertEx(QueryBoundWitnessWrapper.unwrap(query), 'Invalid query'))
+    const sourceQuery = await PayloadBuilder.build(assertEx(QueryBoundWitnessWrapper.unwrap(query), () => 'Invalid query'))
     return await this.busy(async () => {
       const resultPayloads: Payload[] = []
       const errorPayloads: ModuleError[] = []
@@ -298,9 +311,14 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
         if (!this.allowAnonymous && query.addresses.length === 0) {
           throw new Error(`Anonymous Queries not allowed, but running anyway [${this.config.name}], [${this.address}]`)
         }
+        if (queryConfig?.allowedQueries) {
+          assertEx(queryConfig?.allowedQueries.includes(sourceQuery.schema), () => `Query not allowed [${sourceQuery.schema}]`)
+        }
         resultPayloads.push(...(await this.queryHandler(sourceQuery, payloads, queryConfig)))
       } catch (ex) {
         await handleErrorAsync(ex, async (error) => {
+          this._lastError = error
+          this.status = 'dead'
           errorPayloads.push(
             await new ModuleErrorBuilder()
               .sources([sourceQuery.$hash])
@@ -327,6 +345,9 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     payloads?: Payload[],
     queryConfig?: TConfig,
   ): Promise<boolean> {
+    if (this.dead) {
+      return false
+    }
     if (!(await this.started('warn'))) return false
     const configValidator =
       queryConfig ? new ModuleConfigQueryValidator(Object.assign({}, this.config, queryConfig)).queryable : this.moduleConfigQueryValidator
@@ -335,10 +356,15 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     return validators.every((validator) => validator(query, payloads))
   }
 
-  async resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter, 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, 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,
+    idOrFilter: ModuleFilter<T> | ModuleIdentifier = '*',
     { required = 'log', ...options }: ModuleFilterOptions<T> = {},
   ): Promise<T | T[] | undefined> {
     const childOptions = { ...options, required: false }
@@ -346,45 +372,48 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     const up = direction === 'up' || direction === 'all'
     const down = direction === 'down' || direction === 'all'
     let result: T | T[] | undefined
-    switch (typeof idOrFilter) {
-      case 'string': {
-        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: {
-        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
+    if (idOrFilter === '*') {
+      if (this.dead) {
+        return []
       }
-    }
-    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)
+      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: {
-          this.logger.error('resolve failed', idOrFilter)
+          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()
-    return this._startPromise
+    const result = this._startPromise
+    this.status = result ? 'started' : 'dead'
+    return result
   }
 
   async started(notStartedAction: 'error' | 'throw' | 'warn' | 'log' | 'none' = 'log', tryStart = true): Promise<boolean> {
@@ -440,10 +469,25 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
       const result = await this.stopHandler()
       this._started = undefined
       this._startPromise = undefined
+      this.status = result ? 'stopped' : 'dead'
       return result
     })
   }
 
+  protected _checkDead() {
+    if (this.dead) {
+      throw new DeadModuleError(this.id, this._lastError)
+    }
+  }
+
+  protected _noOverride(functionName: string) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const thisFunc = (this as any)[functionName]
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const rootFunc = this._getRootFunction(functionName)
+    assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
+  }
+
   protected bindHashes(hashes: Hash[], schema: Schema[], account?: AccountInstance) {
     // eslint-disable-next-line @typescript-eslint/no-misused-promises
     const promise = new PromiseEx((resolve) => {
@@ -571,7 +615,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     }
   }
 
-  protected manifestHandler(_depth?: number, _ignoreAddresses?: string[]): Promisable<ModuleManifestPayload> {
+  protected manifestHandler(_depth?: number, _ignoreAddresses?: Address[]): Promisable<ModuleManifestPayload> {
     const name = this.config.name ?? 'Anonymous'
     return { config: { name, ...this.config }, schema: ModuleManifestPayloadSchema, status: { address: this.address } }
   }
@@ -710,4 +754,27 @@ 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
+        }
+      }
+    }
+  }
 }

package/src/AbstractModuleInstance.ts

@@ -1,4 +1,5 @@
 import { assertEx } from '@xylabs/assert'
+import { Address } from '@xylabs/hex'
 import { AccountInstance } from '@xyo-network/account-model'
 import { ModuleManifestPayload } from '@xyo-network/manifest-model'
 import { AddressPreviousHashPayload, Module, ModuleDescriptionPayload, ModuleEventData, ModuleParams } from '@xyo-network/module-model'
@@ -11,7 +12,7 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
   implements Module<TParams, TEventData>
 {
   constructor(privateConstructorKey: string, params: TParams, account: AccountInstance) {
-    assertEx(AbstractModule.privateConstructorKey === privateConstructorKey, 'Use create function instead of constructor')
+    assertEx(AbstractModule.privateConstructorKey === privateConstructorKey, () => 'Use create function instead of constructor')
     // Clone params to prevent mutation of the incoming object
     const mutatedParams = { ...params } as TParams
     super(privateConstructorKey, mutatedParams, account)
@@ -20,36 +21,42 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
   }
 
   describe(): Promise<ModuleDescriptionPayload> {
+    this._checkDead()
     return this.busy(async () => {
       return await this.describeHandler()
     })
   }
 
   discover(): Promise<Payload[]> {
+    this._checkDead()
     return this.busy(async () => {
       return await this.discoverHandler()
     })
   }
 
-  manifest(maxDepth?: number, ignoreAddresses?: string[]): Promise<ModuleManifestPayload> {
+  manifest(maxDepth?: number, ignoreAddresses?: Address[]): Promise<ModuleManifestPayload> {
+    this._checkDead()
     return this.busy(async () => {
       return await this.manifestHandler(maxDepth, ignoreAddresses)
     })
   }
 
   moduleAddress(): Promise<AddressPreviousHashPayload[]> {
+    this._checkDead()
     return this.busy(async () => {
       return await this.moduleAddressHandler()
     })
   }
 
   state() {
+    this._checkDead()
     return this.busy(async () => {
       return await this.stateHandler()
     })
   }
 
   subscribe(_queryAccount?: AccountInstance) {
+    this._checkDead()
     return this.subscribeHandler()
   }
 }

package/src/determineAccount.ts

@@ -18,7 +18,7 @@ export interface DetermineRandomParams {}
 export type DetermineAccountParams = DetermineAccountFromAccountParams | DetermineAccountFromWalletParams | DetermineRandomParams
 
 const isDetermineAccountFromAccountParams = (params: DetermineAccountParams): params is DetermineAccountFromAccountParams => {
-  assertEx(!(params as DetermineAccountFromWalletParams).accountPath, 'accountPath may not be provided when account is provided')
+  assertEx(!(params as DetermineAccountFromWalletParams).accountPath, () => 'accountPath may not be provided when account is provided')
   return !!(params as DetermineAccountFromAccountParams).account
 }
 
@@ -29,14 +29,17 @@ const isDetermineAccountFromWalletParams = (params: DetermineAccountParams): par
 export async function determineAccount(params: DetermineAccountParams, allowRandomAccount = true): Promise<AccountInstance> {
   if (isDetermineAccountFromAccountParams(params)) {
     if (params.account === 'random') {
-      assertEx(allowRandomAccount, 'Random address not allowed')
+      assertEx(allowRandomAccount, () => 'Random address not allowed')
       return Account.randomSync()
     }
     return params.account
   }
 
   if (isDetermineAccountFromWalletParams(params)) {
-    return assertEx(params.accountPath ? await params.wallet.derivePath(params.accountPath) : params.wallet, 'Failed to derive account from path')
+    return assertEx(
+      params.accountPath ? await params.wallet.derivePath(params.accountPath) : params.wallet,
+      () => 'Failed to derive account from path',
+    )
   }
 
   //this should eventually be removed/thrown