@xyo-network/module-model 3.18.10 → 4.0.1

package/src/CreatableModule/CreatableModuleRegistry.ts

@@ -1,15 +1,14 @@
 import type { Schema } from '@xyo-network/payload-model'
 
-import type { AttachableModuleInstance } from '../instance/index.ts'
 import type { Labels } from '../Labels/index.ts'
-import type { CreatableModuleFactory } from './CreatableModule.ts'
+import type { CreatableModuleFactory, CreatableModuleInstance } from './CreatableModule.ts'
 import type { LabeledCreatableModuleFactory } from './LabeledCreatableModuleFactory.ts'
 
 export interface CreatableModuleRegistry {
   [key: Schema]: (CreatableModuleFactory | LabeledCreatableModuleFactory)[] | undefined
 }
 
-const buildModuleFactory = <TModule extends AttachableModuleInstance>(
+const buildModuleFactory = <TModule extends CreatableModuleInstance>(
   mod: CreatableModuleFactory<TModule>,
   labels?: Labels,
 ): LabeledCreatableModuleFactory<TModule> => {
@@ -28,7 +27,7 @@ const buildModuleFactory = <TModule extends AttachableModuleInstance>(
   return factory
 }
 
-export const registerCreatableModuleFactory = <TModule extends AttachableModuleInstance>(
+export const registerCreatableModuleFactory = <TModule extends CreatableModuleInstance>(
   registry: CreatableModuleRegistry,
   factory: CreatableModuleFactory<TModule> | LabeledCreatableModuleFactory<TModule>,
   labels?: Labels,

package/src/CreatableModule/LabeledCreatableModuleFactory.ts

@@ -1,8 +1,7 @@
-import type { AttachableModuleInstance } from '../instance/index.ts'
 import type { WithOptionalLabels } from '../Labels/index.ts'
-import type { CreatableModuleFactory } from './CreatableModule.ts'
+import type { CreatableModuleFactory, CreatableModuleInstance } from './CreatableModule.ts'
 
-export type LabeledCreatableModuleFactory<T extends AttachableModuleInstance | void = void> = CreatableModuleFactory<T> & WithOptionalLabels
+export type LabeledCreatableModuleFactory<T extends CreatableModuleInstance = CreatableModuleInstance> = CreatableModuleFactory<T> & WithOptionalLabels
 
 export const hasLabels = (factory: CreatableModuleFactory | LabeledCreatableModuleFactory): factory is LabeledCreatableModuleFactory => {
   return (factory as LabeledCreatableModuleFactory).labels !== undefined
@@ -14,7 +13,7 @@ export const hasLabels = (factory: CreatableModuleFactory | LabeledCreatableModu
  * @returns The decorated Module requiring it implement the members
  * of the CreatableModule as statics properties/methods
  */
-export function labeledCreatableModuleFactory<TModule extends AttachableModuleInstance = AttachableModuleInstance>() {
+export function labeledCreatableModuleFactory<TModule extends CreatableModuleInstance = CreatableModuleInstance>() {
   return <U extends LabeledCreatableModuleFactory<TModule>>(constructor: U) => {
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions
     constructor

package/src/CreatableModule/ModuleFactory.ts

@@ -2,12 +2,13 @@ import { assertEx } from '@xylabs/assert'
 import type { Logger } from '@xylabs/logger'
 import type { Schema } from '@xyo-network/payload-model'
 
-import type { AttachableModuleInstance } from '../instance/index.ts'
 import type { Labels, WithOptionalLabels } from '../Labels/index.ts'
-import type { CreatableModule, CreatableModuleFactory } from './CreatableModule.ts'
+import type {
+  CreatableModule, CreatableModuleFactory, CreatableModuleInstance,
+} from './CreatableModule.ts'
 
-export class ModuleFactory<TModule extends AttachableModuleInstance> implements CreatableModuleFactory<TModule> {
-  configSchemas: CreatableModuleFactory<TModule>['configSchemas']
+export class ModuleFactory<TModule extends CreatableModuleInstance> implements CreatableModuleFactory<TModule> {
+  configSchemas: CreatableModule<TModule>['configSchemas']
 
   creatableModule: CreatableModule<TModule>
 
@@ -15,13 +16,13 @@ export class ModuleFactory<TModule extends AttachableModuleInstance> implements
 
   defaultLogger?: Logger
 
-  defaultParams?: Omit<TModule['params'], 'config'> & { config?: Partial<TModule['params']['config']> }
+  defaultParams?: Partial<TModule['params']>
 
   labels?: Labels
 
   constructor(
     creatableModule: CreatableModule<TModule>,
-    params?: Omit<TModule['params'], 'config'> & { config?: Partial<TModule['params']['config']> },
+    params?: Partial<TModule['params']>,
     labels: Labels = {},
   ) {
     this.creatableModule = creatableModule
@@ -32,45 +33,28 @@ export class ModuleFactory<TModule extends AttachableModuleInstance> implements
     this.labels = Object.assign({}, (creatableModule as WithOptionalLabels).labels ?? {}, labels ?? {})
   }
 
-  static withParams<T extends AttachableModuleInstance>(
+  static withParams<T extends CreatableModuleInstance>(
     creatableModule: CreatableModule<T>,
-    params?: Omit<T['params'], 'config'> & { config?: T['params']['config'] },
+    params?: Partial<T['params']>,
     labels: Labels = {},
   ) {
-    return new ModuleFactory(creatableModule, params, labels)
+    return new ModuleFactory<T>(creatableModule, params, labels)
   }
 
-  _getRootFunction(funcName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let anyThis = this as any
-    while (anyThis.__proto__[funcName]) {
-      anyThis = anyThis.__proto__
-    }
-    return anyThis[funcName]
-  }
-
-  _noOverride(functionName: string) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const thisFunc = (this as any)[functionName]
-
-    const rootFunc = this._getRootFunction(functionName)
-    assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName}] - override ${functionName}Handler instead`)
-  }
-
-  create<T extends AttachableModuleInstance>(this: CreatableModuleFactory<T>, params: TModule['params']): Promise<T> {
-    const factory = this as ModuleFactory<T>
-    const schema = factory.creatableModule.defaultConfigSchema
+  create(this: CreatableModuleFactory<TModule>, params?: Partial<TModule['params']>): Promise<TModule> {
     const mergedParams: TModule['params'] = {
-      ...factory.defaultParams,
+      ...this.defaultParams,
       ...params,
       config: {
-        ...factory.defaultParams?.config, ...params.config, schema,
+        schema: this.creatableModule.defaultConfigSchema,
+        ...this.defaultParams?.config,
+        ...params?.config,
       },
     } as TModule['params']
-    return factory.creatableModule.create<T>(mergedParams)
+    return this.creatableModule.create<TModule>(mergedParams)
   }
 
-  factory<T extends AttachableModuleInstance>(this: CreatableModule<T>, _params?: T['params'] | undefined): CreatableModuleFactory<T> {
-    throw new Error('Method not implemented.')
+  factory<T extends CreatableModuleInstance>(this: CreatableModuleFactory<T>, params?: Partial<T['params']>, labels: Labels = {}): CreatableModuleFactory<T> {
+    return new ModuleFactory<T>(this.creatableModule, params, labels)
   }
 }

package/src/EventsModels/ModuleEventArgs.ts

@@ -1,8 +1,7 @@
 import type { EventArgs } from '@xylabs/events'
 
-export type ModuleEventArgs<TModule extends object = object, TArgs extends EventArgs | undefined = undefined> =
-  TArgs extends EventArgs ?
-  {
+export type ModuleEventArgs<TModule extends object = object, TArgs extends EventArgs | undefined = undefined>
+  = TArgs extends EventArgs ? {
     mod: TModule
   } & TArgs
     : {

package/src/ModuleIdentifier.ts

@@ -42,14 +42,14 @@ export const ReservedModuleIdentifierCharacters = new Set<ReservedModuleIdentifi
 // using Exclude to make this type not allowed to take a naked string
 export type ModuleName = Exclude<string, 'reserved-module-name-56487634'>
 
-export type ModuleIdentifier =
-  | ColonPair<ModuleIdentifierPart>
-  | ColonPair<ColonPair<ModuleIdentifierPart>>
-  | ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>
-  | ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>
-  | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>
-  | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>>
-  | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>>>
+export type ModuleIdentifier
+  = | ColonPair<ModuleIdentifierPart>
+    | ColonPair<ColonPair<ModuleIdentifierPart>>
+    | ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>
+    | ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>
+    | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>
+    | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>>
+    | ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ColonPair<ModuleIdentifierPart>>>>>>>
 
 export type ColonPair<T extends string> = `${T}:${T}` | T
 

package/src/ModuleParams.ts

@@ -1,5 +1,4 @@
-import type { BaseParams } from '@xylabs/base'
-import type { EmptyObject, WithAdditional } from '@xylabs/object'
+import type { CreatableParams } from '@xylabs/creatable'
 import type { AccountInstance } from '@xyo-network/account-model'
 
 import type { AnyConfigSchema, ModuleConfig } from './Config/index.ts'
@@ -12,19 +11,13 @@ export type ModuleChildrenParams = {
   publicChildren?: ModuleInstance[]
 }
 
-export type ModuleParams<
-  TConfig extends AnyConfigSchema<ModuleConfig> | void = void,
-  TAdditionalParams extends EmptyObject | void = void,
-> = WithAdditional<
-  BaseParams<{
-    account?: AccountInstance | 'random'
-    addToResolvers?: boolean
-    additionalSigners?: AccountInstance[]
-    allowNameResolution?: boolean
-    config: TConfig extends AnyConfigSchema<ModuleConfig> ? TConfig : AnyConfigSchema<ModuleConfig>
-    ephemeralQueryAccountEnabled?: boolean
-    moduleIdentifierTransformers?: ModuleIdentifierTransformer[]
-    statusReporter?: ModuleStatusReporter
-  } & ModuleChildrenParams>,
-  TAdditionalParams
->
+export interface ModuleParams<TConfig extends AnyConfigSchema<ModuleConfig> = AnyConfigSchema<ModuleConfig>> extends CreatableParams, ModuleChildrenParams {
+  account?: AccountInstance | 'random'
+  addToResolvers?: boolean
+  additionalSigners?: AccountInstance[]
+  allowNameResolution?: boolean
+  config: Partial<TConfig>
+  ephemeralQueryAccountEnabled?: boolean
+  moduleIdentifierTransformers?: ModuleIdentifierTransformer[]
+  statusReporter?: ModuleStatusReporter
+}

package/src/ModuleStatusReporter.ts

@@ -1,5 +1,5 @@
+import type { CreatableStatusReporter } from '@xylabs/creatable'
+
 import type { ModuleStatus } from './instance/index.ts'
 
-export interface ModuleStatusReporter {
-  reportStatus: (name: string, status: ModuleStatus, progress?: number) => void
-}
+export interface ModuleStatusReporter extends CreatableStatusReporter {}

package/src/instance/Instance.ts

@@ -1,3 +1,4 @@
+import type { CreatableStatus } from '@xylabs/creatable'
 import type { Address } from '@xylabs/hex'
 import type { TypeCheck } from '@xylabs/object'
 import { IsObjectFactory, toJsonString } from '@xylabs/object'
@@ -13,7 +14,7 @@ import type { ObjectResolver } from './ObjectResolver.ts'
 
 export type ModulePipeLine = Lowercase<'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many'>
 
-export type ModuleStatus = 'started' | 'starting' | 'stopped' | 'stopping' | 'dead' | 'wrapped' | 'proxy'
+export type ModuleStatus = CreatableStatus | 'wrapped' | 'proxy'
 
 export class DeadModuleError extends Error {
   constructor(

package/src/instance/ObjectFilter.ts

@@ -41,8 +41,8 @@ export interface QueryObjectFilter<T extends EmptyObject = AnyObject> extends Ob
 export const isQueryObjectFilter = <T extends EmptyObject = AnyObject>(value: unknown): value is QueryObjectFilter<T> =>
   (value as QueryObjectFilter<T>).query !== undefined
 
-export type AnyObjectFilter<T extends EmptyObject = AnyObject> = Partial<AddressObjectFilter<T>> &
-  Partial<NameObjectFilter<T>> &
-  Partial<QueryObjectFilter<T>>
+export type AnyObjectFilter<T extends EmptyObject = AnyObject> = Partial<AddressObjectFilter<T>>
+  & Partial<NameObjectFilter<T>>
+  & Partial<QueryObjectFilter<T>>
 
 export type ObjectFilter<T extends EmptyObject> = ObjectFilterOptions<T> | AddressObjectFilter<T> | NameObjectFilter<T> | QueryObjectFilter<T>

package/src/instance/attachable/AttachableInstance.ts

@@ -1,3 +1,4 @@
+import type { CreatableInstance } from '@xylabs/creatable'
 import type { TypeCheck } from '@xylabs/object'
 import { IsObjectFactory } from '@xylabs/object'
 
@@ -7,7 +8,8 @@ import type { ModuleInstance } from '../Instance.ts'
 import type { ModuleResolverInstance } from '../ModuleResolver.ts'
 
 export interface AttachableModuleInstance<TParams extends ModuleParams = ModuleParams, TEventData extends ModuleEventData = ModuleEventData>
-  extends ModuleInstance<TParams, TEventData> {
+  extends ModuleInstance<TParams, TEventData>, CreatableInstance<TParams, TEventData> {
+  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: ModuleResolverInstance