@xyo-network/node 2.51.8 → 2.52.0-rc.1

package/src/AbstractNode.ts

@@ -5,13 +5,9 @@ import {
   AbstractModule,
   CompositeModuleResolver,
   duplicateModules,
-  EventListener,
   Module,
   ModuleConfig,
   ModuleFilter,
-  ModuleParams,
-  ModuleQueriedEvent,
-  ModuleQueriedEventArgs,
   ModuleQueryResult,
   QueryBoundWitnessWrapper,
   XyoErrorBuilder,
@@ -21,27 +17,16 @@ import { XyoPayloadBuilder } from '@xyo-network/payload-builder'
 import { XyoPayload } from '@xyo-network/payload-model'
 import { Promisable } from '@xyo-network/promise'
 
-import { NodeConfig, NodeConfigSchema } from './Config'
-import {
-  ModuleAttachedEvent,
-  ModuleAttachedEventArgs,
-  ModuleDetachedEvent,
-  ModuleDetachedEventArgs,
-  ModuleRegisteredEvent,
-  ModuleRegisteredEventArgs,
-} from './Events'
-import { NodeModule } from './Node'
+import { NodeConfigSchema } from './Config'
+import { NodeModule, NodeModuleParams } from './Node'
 import { XyoNodeAttachedQuerySchema, XyoNodeAttachQuerySchema, XyoNodeDetachQuerySchema, XyoNodeQuery, XyoNodeRegisteredQuerySchema } from './Queries'
 
-export type AbstractNodeParams<TConfig extends NodeConfig = NodeConfig> = ModuleParams<TConfig>
-
-export abstract class AbstractNode<TParams extends AbstractNodeParams = AbstractNodeParams> extends AbstractModule<TParams> implements NodeModule {
+export abstract class AbstractNode<TParams extends NodeModuleParams = NodeModuleParams>
+  extends AbstractModule<TParams>
+  implements NodeModule<TParams>, Module<TParams>, NodeModule, Module
+{
   static override readonly configSchema = NodeConfigSchema
 
-  protected moduleAttachedEventListeners: EventListener<ModuleAttachedEventArgs>[] = []
-  protected moduleDetachedEventListeners: EventListener<ModuleDetachedEventArgs>[] = []
-  protected moduleRegisteredEventListeners: EventListener<ModuleRegisteredEventArgs>[] = []
-
   protected readonly privateResolver = new CompositeModuleResolver()
 
   private readonly isNode = true
@@ -58,8 +43,8 @@ export abstract class AbstractNode<TParams extends AbstractNodeParams = Abstract
     return [XyoNodeAttachQuerySchema, XyoNodeDetachQuerySchema, XyoNodeAttachedQuerySchema, XyoNodeRegisteredQuerySchema, ...super.queries]
   }
 
-  static override async create(params?: Partial<AbstractNodeParams>): Promise<AbstractNode> {
-    return (await super.create(params)) as AbstractNode
+  static override async create<TParams extends NodeModuleParams>(params?: TParams): Promise<NodeModule> {
+    return (await super.create(params)) as NodeModule
   }
 
   static isNode(module: unknown) {
@@ -83,48 +68,6 @@ export abstract class AbstractNode<TParams extends AbstractNodeParams = Abstract
     return [...(await super.discover()), ...childModAddresses]
   }
 
-  override on(event: ModuleQueriedEvent, listener: (args: ModuleQueriedEventArgs, remove?: boolean) => void): this
-  override on(event: ModuleAttachedEvent, listener: (args: ModuleAttachedEventArgs) => void, remove?: boolean): this
-  override on(event: ModuleDetachedEvent, listener: (args: ModuleDetachedEventArgs) => void, remove?: boolean): this
-  override on(event: ModuleRegisteredEvent, listener: (args: ModuleRegisteredEventArgs) => void, remove?: boolean): this
-  override on(
-    event: ModuleQueriedEvent | ModuleAttachedEvent | ModuleDetachedEvent | ModuleRegisteredEvent,
-    listener: (args: ModuleQueriedEventArgs) => void,
-    remove?: boolean,
-  ): this {
-    if (remove) {
-      switch (event) {
-        case ModuleAttachedEvent:
-          this.moduleAttachedEventListeners = this.moduleAttachedEventListeners?.filter((item) => item != listener)
-          break
-        case ModuleDetachedEvent:
-          this.moduleDetachedEventListeners = this.moduleDetachedEventListeners?.filter((item) => item != listener)
-          break
-        case ModuleRegisteredEvent:
-          this.moduleRegisteredEventListeners = this.moduleRegisteredEventListeners?.filter((item) => item != listener)
-          break
-        default:
-          return super.on(event, listener)
-      }
-    } else {
-      switch (event) {
-        case ModuleAttachedEvent:
-          this.moduleAttachedEventListeners?.push(listener as EventListener<ModuleAttachedEventArgs>)
-          break
-        case ModuleDetachedEvent:
-          this.moduleDetachedEventListeners?.push(listener as EventListener<ModuleDetachedEventArgs>)
-          break
-        case ModuleRegisteredEvent:
-          this.moduleRegisteredEventListeners?.push(listener as EventListener<ModuleRegisteredEventArgs>)
-          break
-        default:
-          return super.on(event, listener)
-      }
-    }
-
-    return this
-  }
-
   override async query<T extends XyoQueryBoundWitness = XyoQueryBoundWitness, TConfig extends ModuleConfig = ModuleConfig>(
     query: T,
     payloads?: XyoPayload[],
@@ -138,7 +81,7 @@ export abstract class AbstractNode<TParams extends AbstractNodeParams = Abstract
     try {
       switch (typedQuery.schema) {
         case XyoNodeAttachQuerySchema: {
-          await this.attach(typedQuery.address)
+          await this.attach(typedQuery.address, typedQuery.external)
           break
         }
         case XyoNodeDetachQuerySchema: {

package/src/Config.ts

@@ -4,4 +4,9 @@ import { XyoPayload } from '@xyo-network/payload-model'
 export type NodeConfigSchema = 'network.xyo.node.config'
 export const NodeConfigSchema: NodeConfigSchema = 'network.xyo.node.config'
 
-export type NodeConfig<TConfig extends XyoPayload = XyoPayload> = ModuleConfig<{ archivist?: string } & TConfig>
+export type NodeConfig<TConfig extends XyoPayload | undefined = undefined> = ModuleConfig<
+  {
+    archivist?: string
+    schema: TConfig extends XyoPayload ? TConfig['schema'] : NodeConfigSchema
+  } & Omit<TConfig, 'schema'>
+>

package/src/Events/ModuleAttached.ts

@@ -1,8 +1,7 @@
-import { ModuleEventArgs, ModuleEventEmitter } from '@xyo-network/module'
-
-export type ModuleAttachedEvent = 'moduleAttached'
-export const ModuleAttachedEvent: ModuleAttachedEvent = 'moduleAttached'
+import { EventData, ModuleEventArgs } from '@xyo-network/module'
 
 export type ModuleAttachedEventArgs = ModuleEventArgs
 
-export type ModuleAttachedEventEmitter = ModuleEventEmitter<ModuleAttachedEvent, ModuleAttachedEventArgs>
+export interface ModuleAttachedEventData extends EventData {
+  moduleAttached: ModuleAttachedEventArgs
+}

package/src/Events/ModuleDetached.ts

@@ -1,8 +1,7 @@
-import { ModuleEventArgs, ModuleEventEmitter } from '@xyo-network/module'
-
-export type ModuleDetachedEvent = 'moduleDetached'
-export const ModuleDetachedEvent: ModuleDetachedEvent = 'moduleDetached'
+import { EventData, ModuleEventArgs } from '@xyo-network/module'
 
 export type ModuleDetachedEventArgs = ModuleEventArgs
 
-export type ModuleDetachedEventEmitter = ModuleEventEmitter<ModuleDetachedEvent, ModuleDetachedEventArgs>
+export interface ModuleDetachedEventData extends EventData {
+  moduleDetached: ModuleDetachedEventArgs
+}

package/src/Events/ModuleRegistered.ts

@@ -1,8 +1,7 @@
-import { ModuleEventArgs, ModuleEventEmitter } from '@xyo-network/module'
-
-export type ModuleRegisteredEvent = 'moduleRegistered'
-export const ModuleRegisteredEvent: ModuleRegisteredEvent = 'moduleRegistered'
+import { EventData, ModuleEventArgs } from '@xyo-network/module'
 
 export type ModuleRegisteredEventArgs = ModuleEventArgs
 
-export type ModuleRegisteredEventEmitter = ModuleEventEmitter<ModuleRegisteredEvent, ModuleRegisteredEventArgs>
+export interface ModuleRegisteredEventData extends EventData {
+  moduleRegistered: ModuleRegisteredEventArgs
+}

package/src/MemoryNode.ts

@@ -1,23 +1,22 @@
 import { assertEx } from '@xylabs/assert'
 import { exists } from '@xylabs/exists'
 import { fulfilled, rejected } from '@xylabs/promise'
-import { duplicateModules, Module, ModuleFilter, ModuleWrapper } from '@xyo-network/module'
+import { AnyConfigSchema, duplicateModules, EventListener, Module, ModuleFilter, ModuleWrapper } from '@xyo-network/module'
 import compact from 'lodash/compact'
 
-import { AbstractNode, AbstractNodeParams } from './AbstractNode'
+import { AbstractNode } from './AbstractNode'
 import { NodeConfig, NodeConfigSchema } from './Config'
-import { ModuleAttachedEventArgs, ModuleAttachedEventEmitter, ModuleDetachedEventArgs, ModuleDetachedEventEmitter } from './Events'
-import { NodeModule } from './Node'
+import { NodeModule, NodeModuleParams } from './Node'
 import { NodeWrapper } from './NodeWrapper'
 
-export type MemoryNodeParams<TConfig extends NodeConfig = NodeConfig> = AbstractNodeParams<TConfig>
+export type MemoryNodeParams = NodeModuleParams<AnyConfigSchema<NodeConfig>>
 
-export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams> extends AbstractNode<TParams> {
+export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams> extends AbstractNode<TParams> implements NodeModule {
   static override configSchema = NodeConfigSchema
 
   private registeredModuleMap: Record<string, Module> = {}
 
-  static override async create(params?: Partial<MemoryNodeParams>): Promise<MemoryNode> {
+  static override async create<TParams extends MemoryNodeParams>(params?: TParams) {
     return (await super.create(params)) as MemoryNode
   }
 
@@ -67,27 +66,33 @@ export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams> ext
     }
 
     const args = { module, name: module.config.name }
-    this.moduleAttachedEventListeners?.map((listener) => listener(args))
+    await this.emit('moduleAttached', args)
 
     if (NodeWrapper.isNodeModule(module)) {
       if (external) {
         const wrappedAsNode = NodeWrapper.wrap(module as NodeModule)
-        const attachEmitter = wrappedAsNode.module as ModuleAttachedEventEmitter
-        const detachEmitter = wrappedAsNode.module as ModuleDetachedEventEmitter
 
-        attachEmitter.on('moduleAttached', (args: ModuleAttachedEventArgs) => this.moduleAttachedEventListeners?.map((listener) => listener(args)))
-        detachEmitter.on('moduleDetached', (args: ModuleDetachedEventArgs) => this.moduleDetachedEventListeners?.map((listener) => listener(args)))
+        const attachedListener: EventListener<TParams['eventData']> = async (args: TParams['eventData']['moduleAttached']) =>
+          await this.emit('moduleAttached', args)
+
+        const detachedListener: EventListener<TParams['eventData']> = async (args: TParams['eventData']['moduleDetached']) =>
+          await this.emit('moduleDetached', args)
+
+        wrappedAsNode.on('moduleAttached', attachedListener)
+        wrappedAsNode.on('moduleDetached', detachedListener)
       }
     }
 
-    const notifyOfExistingModules = (childModules: Module[]) => {
-      childModules.map((child) => {
-        const args = { module: child, name: child.config.name }
-        this.moduleAttachedEventListeners?.map((listener) => listener(args))
-      })
+    const notifyOfExistingModules = async (childModules: Module[]) => {
+      await Promise.all(
+        childModules.map(async (child) => {
+          const args = { module: child, name: child.config.name }
+          await this.emit('moduleAttached', args)
+        }),
+      )
     }
 
-    notifyOfExistingModules(notificationList)
+    await notifyOfExistingModules(notificationList)
   }
 
   override async detach(address: string) {
@@ -105,7 +110,7 @@ export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams> ext
     this.downResolver.removeResolver(module.downResolver)
 
     const args = { module, name: module.config.name }
-    this.moduleDetachedEventListeners?.map((listener) => listener(args))
+    await this.emit('moduleDetached', args)
 
     //notify of all sub node children detach
     const wrapper = ModuleWrapper.tryWrap(module as NodeModule)
@@ -114,19 +119,21 @@ export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams> ext
       const notifyOfExistingModules = async (node: ModuleWrapper) => {
         //send attach events for all existing attached modules
         const childModules = await node.resolve()
-        childModules.map((child) => {
-          //don't report self
-          if (node.address === child.address) {
-            return
-          }
-
-          //prevent loop
-          if (notifiedAddresses.includes(child.address)) {
-            return
-          }
-          notifiedAddresses.push(child.address)
-          this.moduleDetachedEventListeners?.map((listener) => listener({ module: child }))
-        })
+        await Promise.all(
+          childModules.map(async (child) => {
+            //don't report self
+            if (node.address === child.address) {
+              return
+            }
+
+            //prevent loop
+            if (notifiedAddresses.includes(child.address)) {
+              return
+            }
+            notifiedAddresses.push(child.address)
+            await this.emit('moduleDetached', { module: child })
+          }),
+        )
       }
       await notifyOfExistingModules(wrapper)
     }

package/src/Node.ts

@@ -1,8 +1,9 @@
-import { EventModule } from '@xyo-network/module-model'
+import { AnyObject } from '@xyo-network/core'
+import { AnyConfigSchema, EventData, Module, ModuleParams } from '@xyo-network/module-model'
 import { Promisable } from '@xyo-network/promise'
 
 import { NodeConfig } from './Config'
-import { ModuleAttachedEventEmitter, ModuleDetachedEventEmitter, ModuleRegisteredEventEmitter } from './Events'
+import { ModuleAttachedEventData, ModuleDetachedEventData, ModuleRegisteredEventData } from './Events'
 
 export interface Node {
   attach(address: string, external?: boolean): Promisable<void>
@@ -11,4 +12,12 @@ export interface Node {
   registered(): Promisable<string[]>
 }
 
-export type NodeModule = Node & EventModule<NodeConfig, ModuleAttachedEventEmitter | ModuleDetachedEventEmitter | ModuleRegisteredEventEmitter>
+export interface NodeModuleEventData extends ModuleAttachedEventData, ModuleDetachedEventData, ModuleRegisteredEventData {}
+
+export type NodeModuleParams<
+  TConfig extends AnyConfigSchema<NodeConfig> = AnyConfigSchema<NodeConfig>,
+  TEventData extends EventData | undefined = undefined,
+  TAdditionalParams extends AnyObject | undefined = undefined,
+> = ModuleParams<TConfig, TEventData extends EventData ? NodeModuleEventData & TEventData : NodeModuleEventData, TAdditionalParams>
+
+export type NodeModule<TParams extends NodeModuleParams = NodeModuleParams> = Node & Module<TParams>

package/src/NodeWrapper.ts

@@ -18,13 +18,13 @@ import {
   XyoNodeRegisteredQuerySchema,
 } from './Queries'
 
-export class NodeWrapper extends ModuleWrapper<NodeModule> implements NodeModule {
+export class NodeWrapper<TWrappedModule extends NodeModule = NodeModule> extends ModuleWrapper<TWrappedModule> {
   static override requiredQueries = [XyoNodeAttachQuerySchema, ...ModuleWrapper.requiredQueries]
 
   private _archivist?: ArchivistWrapper
 
   get archivist() {
-    this._archivist = this._archivist ?? new ArchivistWrapper(this.module)
+    this._archivist = this._archivist ?? new ArchivistWrapper({ account: this.account, module: this.module })
     return this._archivist
   }
 
@@ -33,18 +33,18 @@ export class NodeWrapper extends ModuleWrapper<NodeModule> implements NodeModule
     return missingRequiredQueries.length === 0
   }
 
-  static override tryWrap<TModule extends NodeModule = NodeModule>(module?: TModule, account?: AccountInstance): NodeWrapper | undefined {
+  static override tryWrap<TModule extends NodeModule = NodeModule>(module?: TModule, account?: AccountInstance): NodeWrapper<TModule> | undefined {
     if (module) {
       const missingRequiredQueries = this.missingRequiredQueries(module)
       if (missingRequiredQueries.length > 0) {
-        //console.warn(`Missing queries: ${JSON.stringify(missingRequiredQueries, null, 2)}`)
+        this.defaultLogger?.debug(`Missing queries: ${JSON.stringify(missingRequiredQueries, null, 2)}`)
       } else {
-        return new NodeWrapper(module as TModule, account)
+        return new NodeWrapper<TModule>({ account, module })
       }
     }
   }
 
-  static override wrap<TModule extends NodeModule = NodeModule>(module?: TModule, account?: AccountInstance): NodeWrapper {
+  static override wrap<TModule extends NodeModule = NodeModule>(module?: TModule, account?: AccountInstance): NodeWrapper<TModule> {
     return assertEx(this.tryWrap(module, account), 'Unable to wrap module as NodeWrapper')
   }
 

package/src/index.ts

@@ -4,5 +4,4 @@ export * from './Events'
 export * from './MemoryNode'
 export * from './Node'
 export * from './NodeWrapper'
-export * from './PartialConfig'
 export * from './Queries'

package/dist/cjs/PartialConfig.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=PartialConfig.js.map

package/dist/cjs/PartialConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PartialConfig.js","sourceRoot":"","sources":["../../src/PartialConfig.ts"],"names":[],"mappings":""}

package/dist/esm/PartialConfig.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=PartialConfig.js.map

package/dist/esm/PartialConfig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PartialConfig.js","sourceRoot":"","sources":["../../src/PartialConfig.ts"],"names":[],"mappings":""}

package/dist/types/PartialConfig.d.ts

@@ -1,4 +0,0 @@
-import { PartialModuleConfig } from '@xyo-network/module';
-import { NodeConfig } from './Config';
-export type PartialNodeConfig<T extends NodeConfig = NodeConfig> = PartialModuleConfig<T>;
-//# sourceMappingURL=PartialConfig.d.ts.map

package/dist/types/PartialConfig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"PartialConfig.d.ts","sourceRoot":"","sources":["../../src/PartialConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAEzD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAErC,MAAM,MAAM,iBAAiB,CAAC,CAAC,SAAS,UAAU,GAAG,UAAU,IAAI,mBAAmB,CAAC,CAAC,CAAC,CAAA"}

package/src/PartialConfig.ts

@@ -1,5 +0,0 @@
-import { PartialModuleConfig } from '@xyo-network/module'
-
-import { NodeConfig } from './Config'
-
-export type PartialNodeConfig<T extends NodeConfig = NodeConfig> = PartialModuleConfig<T>