@xyo-network/module-model 2.66.2 → 2.66.4

package/src/Module.ts

@@ -6,7 +6,7 @@ import { Payload } from '@xyo-network/payload-model'
 import { Promisable } from '@xyo-network/promise'
 
 import { AnyConfigSchema, ModuleConfig } from './Config'
-import { ModuleBusyEventData, ModuleQueriedEventData } from './Events'
+import { ModuleBusyEventData, ModuleErrorEventData, ModuleQueriedEventData } from './Events'
 import { ModuleDescription } from './ModuleDescription'
 import { ModuleFilter, ModuleFilterOptions } from './ModuleFilter'
 import { ModuleParams } from './ModuleParams'
@@ -14,12 +14,18 @@ import { ModuleQueryResult } from './ModuleQueryResult'
 import { AddressPreviousHashPayload } from './Queries'
 
 export interface ResolveFunctions {
-  resolve<TModule extends Module = Module>(filter?: ModuleFilter, options?: ModuleFilterOptions): Promisable<TModule[]>
-  resolve<TModule extends Module = Module>(nameOrAddress: string, options?: ModuleFilterOptions): Promisable<TModule | undefined>
-  resolve<TModule extends Module = Module>(
+  resolve<TModuleInstance extends ModuleInstance>(
+    filter?: ModuleFilter,
+    options?: ModuleFilterOptions<TModuleInstance>,
+  ): Promisable<TModuleInstance[]>
+  resolve<TModuleInstance extends ModuleInstance>(
+    nameOrAddress: string,
+    options?: ModuleFilterOptions<TModuleInstance>,
+  ): Promisable<TModuleInstance | undefined>
+  resolve<TModuleInstance extends ModuleInstance>(
     nameOrAddressOrFilter?: ModuleFilter | string,
-    options?: ModuleFilterOptions,
-  ): Promisable<TModule | TModule[] | undefined>
+    options?: ModuleFilterOptions<TModuleInstance>,
+  ): Promisable<TModuleInstance | TModuleInstance[] | undefined>
 }
 
 export interface ModuleResolver extends ResolveFunctions {
@@ -28,10 +34,7 @@ export interface ModuleResolver extends ResolveFunctions {
   removeResolver: (resolver: ModuleResolver) => this
 }
 
-export type ModuleEventArgs<
-  TModule extends IndirectModule = IndirectModule,
-  TArgs extends EventArgs | undefined = undefined,
-> = TArgs extends EventArgs
+export type ModuleEventArgs<TModule extends Module = Module, TArgs extends EventArgs | undefined = undefined> = TArgs extends EventArgs
   ? {
       module: TModule
     } & TArgs
@@ -39,7 +42,7 @@ export type ModuleEventArgs<
       module: TModule
     }
 
-export interface ModuleEventData extends ModuleQueriedEventData, ModuleBusyEventData {}
+export interface ModuleEventData extends ModuleQueriedEventData, ModuleBusyEventData, ModuleErrorEventData {}
 
 export type ModuleQueryFunctions = {
   describe: () => Promise<ModuleDescription>
@@ -53,7 +56,7 @@ export type ModuleFields<TParams extends ModuleParams<AnyConfigSchema<ModuleConf
   config: TParams['config']
 
   /* The resolver is a 'down' resolver.  It can resolve the module or any children (if it is a node for example), that are in the module*/
-  readonly downResolver: ModuleResolver
+  readonly downResolver: Omit<ModuleResolver, 'resolve'>
 
   loadAccount?: () => Promisable<AccountInstance>
 
@@ -78,25 +81,15 @@ export type ModuleFields<TParams extends ModuleParams<AnyConfigSchema<ModuleConf
 
   /* The resolver is a 'up' resolver.  It can resolve the parent or any children of the parent*/
   /* This is set by a NodeModule when attaching to the module */
-  readonly upResolver: ModuleResolver
+  readonly upResolver: Omit<ModuleResolver, 'resolve'>
 }
 
-export type IndirectModule<
+export type Module<
   TParams extends ModuleParams<AnyConfigSchema<ModuleConfig>> = ModuleParams<AnyConfigSchema<ModuleConfig>>,
   TEventData extends ModuleEventData = ModuleEventData,
 > = ModuleFields<TParams> & EventFunctions<TEventData> & ResolveFunctions
 
-export type DirectModule<
-  TParams extends ModuleParams<AnyConfigSchema<ModuleConfig>> = ModuleParams<AnyConfigSchema<ModuleConfig>>,
-  TEventData extends ModuleEventData = ModuleEventData,
-> = IndirectModule<TParams, TEventData> & ModuleQueryFunctions
-
 export type ModuleInstance<
   TParams extends ModuleParams<AnyConfigSchema<ModuleConfig>> = ModuleParams<AnyConfigSchema<ModuleConfig>>,
   TEventData extends ModuleEventData = ModuleEventData,
-> = DirectModule<TParams, TEventData>
-
-export type Module<
-  TParams extends ModuleParams<AnyConfigSchema<ModuleConfig>> = ModuleParams<AnyConfigSchema<ModuleConfig>>,
-  TEventData extends ModuleEventData = ModuleEventData,
-> = IndirectModule<TParams, TEventData>
+> = Module<TParams, TEventData> & ModuleQueryFunctions

package/src/ModuleFactory.ts

@@ -2,9 +2,9 @@ import { Logger } from '@xyo-network/core'
 import merge from 'lodash/merge'
 
 import { CreatableModule, CreatableModuleFactory } from './CreatableModule'
-import { IndirectModule } from './Module'
+import { Module } from './Module'
 
-export class ModuleFactory<TModule extends IndirectModule> implements CreatableModuleFactory<TModule> {
+export class ModuleFactory<TModule extends Module> implements CreatableModuleFactory<TModule> {
   configSchemas: CreatableModuleFactory<TModule>['configSchemas']
 
   creatableModule: CreatableModule<TModule>
@@ -23,18 +23,18 @@ export class ModuleFactory<TModule extends IndirectModule> implements CreatableM
     return this.configSchemas[0]
   }
 
-  static withParams<T extends IndirectModule>(creatableModule: CreatableModule<T>, params?: T['params']) {
+  static withParams<T extends Module>(creatableModule: CreatableModule<T>, params?: T['params']) {
     return new ModuleFactory(creatableModule, params)
   }
 
-  create<T extends IndirectModule>(this: CreatableModuleFactory<T>, params?: TModule['params'] | undefined): Promise<T> {
+  create<T extends Module>(this: CreatableModuleFactory<T>, params?: TModule['params'] | undefined): Promise<T> {
     const factory = this as ModuleFactory<T>
     const schema = factory.creatableModule.configSchema
     const mergedParams: TModule['params'] = merge(factory.defaultParams ?? {}, params, { config: { schema } })
     return factory.creatableModule.create<T>(mergedParams)
   }
 
-  factory<T extends IndirectModule>(this: CreatableModule<T>, _params?: T['params'] | undefined): CreatableModuleFactory<T> {
+  factory<T extends Module>(this: CreatableModule<T>, _params?: T['params'] | undefined): CreatableModuleFactory<T> {
     throw new Error('Method not implemented.')
   }
 }

package/src/ModuleFilter.ts

@@ -1,19 +1,29 @@
-export interface ModuleFilterOptions {
+import { InstanceTypeCheck } from './isModule'
+import { ModuleInstance } from './Module'
+
+export interface ModuleFilterOptions<TInstance extends ModuleInstance = ModuleInstance> {
   direction?: 'up' | 'down' | 'all'
+  identity?: InstanceTypeCheck<TInstance>
   visibility?: 'public' | 'private' | 'all'
 }
 
-export interface AddressModuleFilter extends ModuleFilterOptions {
+export interface AddressModuleFilter<TInstance extends ModuleInstance = ModuleInstance> extends ModuleFilterOptions<TInstance> {
   address: string[]
 }
 
-export interface NameModuleFilter extends ModuleFilterOptions {
+export interface NameModuleFilter<TInstance extends ModuleInstance = ModuleInstance> extends ModuleFilterOptions<TInstance> {
   name: string[]
 }
 
-export interface QueryModuleFilter extends ModuleFilterOptions {
+export interface QueryModuleFilter<TInstance extends ModuleInstance = ModuleInstance> extends ModuleFilterOptions<TInstance> {
   query: string[][]
 }
 
-export type AnyModuleFilter = Partial<AddressModuleFilter> & Partial<NameModuleFilter> & Partial<QueryModuleFilter>
-export type ModuleFilter = ModuleFilterOptions | AddressModuleFilter | NameModuleFilter | QueryModuleFilter
+export type AnyModuleFilter = Partial<AddressModuleFilter<ModuleInstance>> &
+  Partial<NameModuleFilter<ModuleInstance>> &
+  Partial<QueryModuleFilter<ModuleInstance>>
+export type ModuleFilter<TInstance extends ModuleInstance = ModuleInstance> =
+  | ModuleFilterOptions<TInstance>
+  | AddressModuleFilter<TInstance>
+  | NameModuleFilter<TInstance>
+  | QueryModuleFilter<TInstance>

package/src/ModuleRepository.ts

@@ -1,9 +1,9 @@
-import { IndirectModule, ModuleResolver } from './Module'
+import { Module, ModuleResolver } from './Module'
 
 export interface ModuleRepository extends ModuleResolver {
-  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
 
   remove(address: string | string[]): this
 }

package/src/isModule.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { DirectModule, IndirectModule, Module, ModuleInstance } from './Module'
+import { Module, ModuleInstance } from './Module'
 
 export type InstanceTypeCheck<T extends object = object> = (module: object) => module is T
 
@@ -24,24 +24,23 @@ export const IsInstanceFactory = {
     return (module: any = {}, log = false): module is T => {
       return (
         (additionalCheck?.(module) ?? true) &&
-        (Object.entries(shape ?? {}).reduce((prev, [key, type]) => {
+        Object.entries(shape ?? {}).reduce((prev, [key, type]) => {
           const result = isType(module[key], type)
           if (!result && log) {
             console.warn(`isType Failed: ${key}: ${type}`)
           }
-          return result
-        }, true) ??
-          true)
+          return prev && result
+        }, true)
       )
     }
   },
 }
 
-export const IsIndirectModuleFactory = {
-  create: <T extends IndirectModule = IndirectModule>(expectedQueries?: string[], additionalCheck?: (module: any) => boolean): ModuleTypeCheck<T> => {
+export const IsModuleFactory = {
+  create: <T extends Module = Module>(expectedQueries?: string[], additionalCheck?: (module: any) => boolean): ModuleTypeCheck<T> => {
     return (module: any = {}): module is T => {
       return (
-        isIndirectModuleInstance(module) &&
+        isModule(module) &&
         (additionalCheck?.(module) ?? true) &&
         (expectedQueries?.reduce((prev, query) => prev && module.queries.includes(query), true) ?? true)
       )
@@ -49,9 +48,7 @@ export const IsIndirectModuleFactory = {
   },
 }
 
-export const IsModuleFactory = IsIndirectModuleFactory
-
-export const isIndirectModuleInstance: InstanceTypeCheck<ModuleInstance> = IsInstanceFactory.create<ModuleInstance>({
+export const isModule: InstanceTypeCheck<ModuleInstance> = IsInstanceFactory.create<ModuleInstance>({
   address: 'string',
   config: 'object',
   downResolver: 'object',
@@ -61,39 +58,11 @@ export const isIndirectModuleInstance: InstanceTypeCheck<ModuleInstance> = IsIns
   queryable: 'function',
 })
 
-export const isDirectModuleInstance: InstanceTypeCheck<ModuleInstance> = IsInstanceFactory.create<ModuleInstance>(
+export const isModuleInstance: InstanceTypeCheck<ModuleInstance> = IsInstanceFactory.create<ModuleInstance>(
   {
     describe: 'function',
     discover: 'function',
     manifest: 'function',
   },
-  isIndirectModuleInstance,
+  isModule,
 )
-
-export const isModuleInstance = isDirectModuleInstance
-
-export const isDirectModule = <T extends DirectModule = DirectModule>(
-  module: any = {},
-  expectedQueries?: string[],
-  additionalCheck?: (module: any) => boolean,
-): module is T => {
-  return (
-    isDirectModuleInstance(module) &&
-    (additionalCheck?.(module) ?? true) &&
-    (expectedQueries?.reduce((prev, query) => prev && module.queries.includes(query), true) ?? true)
-  )
-}
-
-export const isIndirectModule = <T extends IndirectModule = IndirectModule>(
-  module: any = {},
-  expectedQueries?: string[],
-  additionalCheck?: (module: any) => boolean,
-): module is T => {
-  return (
-    isIndirectModuleInstance(module) &&
-    (additionalCheck?.(module) ?? true) &&
-    (expectedQueries?.reduce((prev, query) => prev && module.queries.includes(query), true) ?? true)
-  )
-}
-
-export const isModule = isIndirectModule

package/src/lib/duplicateModules.ts

@@ -1,4 +1,4 @@
-import { IndirectModule } from '../Module'
+import { Module } from '../Module'
 
 /**
  * Used to filter duplicates from an array of modules
@@ -9,6 +9,6 @@ import { IndirectModule } from '../Module'
  * @returns True if the Module's address is the first occurrence of
  * that address in the array, false otherwise
  */
-export const duplicateModules = (value: IndirectModule, index: number, array: IndirectModule[]): value is IndirectModule => {
+export const duplicateModules = (value: Module, index: number, array: Module[]): value is Module => {
   return array.findIndex((v) => v.address === value.address) === index
 }