@xyo-network/node 2.44.0 → 2.45.0-rc.1

package/src/AbstractNode.ts

@@ -1,20 +1,18 @@
 import { assertEx } from '@xylabs/assert'
-import { exists } from '@xylabs/exists'
 import { Account } from '@xyo-network/account'
 import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
 import {
   AbstractModule,
   AbstractModuleConfig,
+  CompositeModuleResolver,
   Module,
   ModuleConstructable,
   ModuleDescription,
   ModuleFilter,
   ModuleParams,
   ModuleQueryResult,
-  ModuleRepository,
   ModuleWrapper,
   QueryBoundWitnessWrapper,
-  SimpleModuleResolver,
   XyoErrorBuilder,
   XyoQueryBoundWitness,
 } from '@xyo-network/module'
@@ -28,21 +26,19 @@ import { XyoNodeAttachedQuerySchema, XyoNodeAttachQuerySchema, XyoNodeDetachQuer
 
 //const childModuleDiscoverQueryPayload = PayloadWrapper.parse<AbstractModuleDiscoverQuery>({ schema: AbstractModuleDiscoverQuerySchema })
 
-export interface AbstractNodeParams<TConfig extends NodeConfig = NodeConfig, TModule extends Module = Module> extends ModuleParams<TConfig> {
-  internalResolver?: ModuleRepository<TModule>
+export interface AbstractNodeParams<TConfig extends NodeConfig = NodeConfig> extends ModuleParams<TConfig> {
+  internalResolver?: CompositeModuleResolver
 }
 
-export abstract class AbstractNode<TConfig extends NodeConfig = NodeConfig, TModule extends Module = Module>
-  extends AbstractModule<TConfig>
-  implements NodeModule
-{
+export abstract class AbstractNode<TConfig extends NodeConfig = NodeConfig> extends AbstractModule<TConfig> implements NodeModule<AbstractModule> {
   static readonly configSchema = NodeConfigSchema
 
-  protected internalResolver: ModuleRepository<TModule>
+  protected internalResolver = new CompositeModuleResolver()
 
-  protected constructor(params: AbstractNodeParams<TConfig, TModule>) {
+  private readonly isNode = true
+
+  protected constructor(params: AbstractNodeParams<TConfig>) {
     super(params)
-    this.internalResolver = params.internalResolver ?? new SimpleModuleResolver<TModule>()
   }
 
   get isModuleResolver(): boolean {
@@ -53,11 +49,15 @@ export abstract class AbstractNode<TConfig extends NodeConfig = NodeConfig, TMod
     return (await super.create(params)) as AbstractNode
   }
 
+  static isNode(module: unknown) {
+    return (module as AbstractNode).isNode
+  }
+
   async attached(): Promise<string[]> {
     return (await this.attachedModules()).map((module) => module.address)
   }
 
-  async attachedModules(): Promise<TModule[]> {
+  async attachedModules(): Promise<Module[]> {
     return await (this.internalResolver.resolve() ?? [])
   }
 
@@ -126,7 +126,7 @@ export abstract class AbstractNode<TConfig extends NodeConfig = NodeConfig, TMod
     return this.bindResult(resultPayloads, queryAccount)
   }
 
-  register(_module: TModule): Promisable<void> {
+  register(_module: AbstractModule): Promisable<this> {
     throw new Error('Method not implemented.')
   }
 
@@ -134,10 +134,14 @@ export abstract class AbstractNode<TConfig extends NodeConfig = NodeConfig, TMod
     throw new Error('Method not implemented.')
   }
 
-  registeredModules(): Promisable<TModule[]> {
+  registeredModules(): Promisable<Module[]> {
     throw new Error('Method not implemented.')
   }
 
+  override async resolve(filter?: ModuleFilter): Promise<AbstractModule[]> {
+    return (await this.internalResolver.resolve(filter)) ?? super.resolve(filter) ?? []
+  }
+
   /**
    * Resolves the supplied filter into wrapped modules
    * @example <caption>Example using ArchivistWrapper</caption>
@@ -149,8 +153,8 @@ export abstract class AbstractNode<TConfig extends NodeConfig = NodeConfig, TMod
    * @returns An array of ModuleWrapper instances corresponding to
    * the underlying modules matching the supplied filter
    */
-  async resolveWrapped<T extends ModuleWrapper<TModule> = ModuleWrapper<TModule>>(
-    wrapper: ModuleConstructable<TModule, T>,
+  async resolveWrapped<T extends ModuleWrapper<Module> = ModuleWrapper<Module>>(
+    wrapper: ModuleConstructable<Module, T>,
     filter?: ModuleFilter,
   ): Promise<T[]> {
     return (await this.resolve(filter)).map((mod) => new wrapper(mod))
@@ -161,44 +165,13 @@ export abstract class AbstractNode<TConfig extends NodeConfig = NodeConfig, TMod
     return this
   }
 
-  /**
-   * Tries to resolve the supplied filter into wrapped modules
-   * @example <caption>Example using ArchivistWrapper</caption>
-   * const filter = { address: [address] }
-   * const mods: ArchivistWrapper[] = await node.tryResolveWrapped(ArchivistWrapper, filter)
-   * @param wrapper The ModuleWrapper class (ArchivistWrapper,
-   * DivinerWrapper, etc.)
-   * @param filter The ModuleFilter
-   * @returns An array of ModuleWrapper instances corresponding to
-   * the underlying modules matching the supplied filter
-   */
-  async tryResolveWrapped<T extends ModuleWrapper<TModule> = ModuleWrapper<TModule>>(
-    wrapper: ModuleConstructable<TModule, T>,
-    filter?: ModuleFilter,
-  ): Promise<T[]> {
-    return (await this.tryResolve(filter))
-      .map((mod) => {
-        try {
-          return new wrapper(mod)
-        } catch (_err) {
-          return undefined
-        }
-      })
-      .filter(exists)
-  }
-
-  unregister(_module: TModule): Promisable<void> {
+  unregister(_module: Module): Promisable<this> {
     throw new Error('Method not implemented.')
   }
 
-  abstract attach(address: string): Promisable<void>
+  abstract attach(address: string, external?: boolean): Promisable<void>
   abstract detach(address: string): Promisable<void>
-  abstract resolve(filter?: ModuleFilter): Promisable<TModule[]>
-  abstract tryResolve(filter?: ModuleFilter): Promisable<TModule[]>
 }
 
 /** @deprecated use AbstractNode instead */
-export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig, TModule extends AbstractModule = AbstractModule> extends AbstractNode<
-  TConfig,
-  TModule
-> {}
+export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig> extends AbstractNode<TConfig> {}

package/src/Events/ModuleAttached.ts

@@ -3,7 +3,11 @@ import { Module } from '@xyo-network/module-model'
 
 export interface ModuleAttachedEventArgs {
   module: Module
-  name?: string
+}
+
+export interface ModuleDetachedEventArgs {
+  address: string
 }
 
 export type ModuleAttachedEventEmitter = ModuleEventEmitter<'moduleAttached', ModuleAttachedEventArgs>
+export type ModuleDetachedEventEmitter = ModuleEventEmitter<'moduleDetached', ModuleDetachedEventArgs>

package/src/MemoryNode.ts

@@ -1,45 +1,42 @@
 import { assertEx } from '@xylabs/assert'
 import { exists } from '@xylabs/exists'
 import { fulfilled } from '@xylabs/promise'
-import { duplicateModules, EventListener, mixinResolverEventEmitter, Module, ModuleFilter, ModuleResolver } from '@xyo-network/module'
+import { AbstractModule, duplicateModules, EventListener, Module, ModuleFilter } from '@xyo-network/module'
 
 import { AbstractNode, AbstractNodeParams } from './AbstractNode'
 import { NodeConfig, NodeConfigSchema } from './Config'
-import { ModuleAttachedEventArgs, ModuleAttachedEventEmitter, ModuleResolverChangedEventArgs, ResolverChangedEventEmitter } from './Events'
+import {
+  ModuleAttachedEventArgs,
+  ModuleAttachedEventEmitter,
+  ModuleDetachedEventArgs,
+  ModuleResolverChangedEventArgs,
+  ResolverChangedEventEmitter,
+} from './Events'
 
 type SupportedEventTypes = 'moduleAttached' | 'moduleResolverChanged'
 type SupportedEventListeners<T extends SupportedEventTypes> = T extends 'moduleAttached'
   ? EventListener<ModuleAttachedEventArgs>
   : EventListener<ModuleResolverChangedEventArgs>
 
-export interface MemoryNodeParams<TConfig extends NodeConfig = NodeConfig, TModule extends Module = Module>
-  extends AbstractNodeParams<TConfig, TModule> {
-  autoAttachExternallyResolved?: boolean
-}
+export type MemoryNodeParams<TConfig extends NodeConfig = NodeConfig> = AbstractNodeParams<TConfig>
 
-export class MemoryNode<TConfig extends NodeConfig = NodeConfig, TModule extends Module = Module>
-  extends AbstractNode<TConfig, TModule>
+export class MemoryNode<TConfig extends NodeConfig = NodeConfig>
+  extends AbstractNode<TConfig>
   implements ModuleAttachedEventEmitter, ResolverChangedEventEmitter
 {
   static configSchema = NodeConfigSchema
   private readonly moduleAttachedEventListeners: EventListener<ModuleAttachedEventArgs>[] = []
-  private registeredModuleMap = new Map<string, TModule>()
+  private readonly moduleDetachedEventListeners: EventListener<ModuleDetachedEventArgs>[] = []
+  private registeredModuleMap = new Map<string, AbstractModule>()
   private readonly resolverChangedEventListeners: EventListener<ModuleResolverChangedEventArgs>[] = []
 
-  override get resolver() {
-    return this._resolver
-  }
-
-  override set resolver(resolver: ModuleResolver | undefined) {
-    this._resolver = resolver
-    const args = { resolver }
-    this.resolverChangedEventListeners?.map((listener) => listener(args))
-  }
-
   static override async create(params?: Partial<MemoryNodeParams>): Promise<MemoryNode> {
     const instance = (await super.create(params)) as MemoryNode
-    if (params?.resolver && params?.autoAttachExternallyResolved) {
-      const resolver = mixinResolverEventEmitter(params?.resolver)
+
+    //Arie: Why would we want to auto register modules?
+
+    /*if (params?.autoAttachExternallyResolved) {
+      const resolver = mixinResolverEventEmitter(instance.resolver)
       resolver.on('moduleResolved', (args) => {
         const { module, filter } = args
         try {
@@ -56,19 +53,48 @@ export class MemoryNode<TConfig extends NodeConfig = NodeConfig, TModule extends
         }
       })
       instance.resolver = resolver
-    }
+    }*/
     return instance
   }
 
-  override attach(address: string, name?: string) {
+  override attach(address: string, external?: boolean) {
     const module = assertEx(this.registeredModuleMap.get(address), 'No module found at that address')
-    this.internalResolver.add(module, name)
-    const args = { module, name }
+
+    this.internalResolver.addResolver(module.resolver)
+
+    //give it inside access
+    module.parentResolver.addResolver(this.internalResolver)
+
+    //give it outside access
+    if (this.parentResolver) {
+      module.parentResolver.addResolver(this.parentResolver)
+    }
+
+    if (external) {
+      //expose it externally
+      this.resolver.addResolver(module.resolver)
+    }
+
+    const args = { module }
     this.moduleAttachedEventListeners?.map((listener) => listener(args))
   }
 
   override detach(address: string) {
-    this.internalResolver.remove(address)
+    const module = assertEx(this.registeredModuleMap.get(address), 'No module found at that address')
+
+    this.internalResolver.removeResolver(module.resolver)
+
+    //remove outside access
+    module.parentResolver.removeResolver(this.parentResolver)
+
+    //remove inside access
+    module.parentResolver.removeResolver(this.internalResolver)
+
+    //remove external exposure
+    this.resolver.removeResolver(module.resolver)
+
+    const args = { address }
+    this.moduleDetachedEventListeners?.map((listener) => listener(args))
   }
 
   on(event: 'moduleAttached', listener: (args: ModuleAttachedEventArgs) => void): this
@@ -85,8 +111,9 @@ export class MemoryNode<TConfig extends NodeConfig = NodeConfig, TModule extends
     return this
   }
 
-  override register(module: TModule) {
+  override register(module: AbstractModule) {
     this.registeredModuleMap.set(module.address, module)
+    return this
   }
 
   override registered() {
@@ -101,17 +128,11 @@ export class MemoryNode<TConfig extends NodeConfig = NodeConfig, TModule extends
     })
   }
 
-  override async resolve(filter?: ModuleFilter): Promise<TModule[]> {
+  override async resolve(filter?: ModuleFilter): Promise<AbstractModule[]> {
     const internal = this.internalResolver.resolve(filter)
-    const external = (this.resolver as ModuleResolver<TModule> | undefined)?.resolve(filter) || []
-    const resolved = await Promise.all([internal, external])
-    return resolved.flat().filter(exists).filter(duplicateModules)
-  }
-
-  override async tryResolve(filter?: ModuleFilter): Promise<TModule[]> {
-    const internal = this.internalResolver.tryResolve(filter)
-    const external = (this.resolver as ModuleResolver<TModule> | undefined)?.tryResolve(filter) || []
-    const resolved = await Promise.allSettled([internal, external])
+    const external = this.parentResolver?.resolve(filter) || []
+    const local = this.resolver?.resolve(filter) || []
+    const resolved = await Promise.allSettled([internal, external, local])
     return resolved
       .filter(fulfilled)
       .map((r) => r.value)
@@ -120,7 +141,9 @@ export class MemoryNode<TConfig extends NodeConfig = NodeConfig, TModule extends
       .filter(duplicateModules)
   }
 
-  override unregister(module: TModule) {
+  override unregister(module: Module) {
+    this.detach(module.address)
     this.registeredModuleMap.delete(module.address)
+    return this
   }
 }

package/src/Node.ts

@@ -2,7 +2,7 @@ import { Module, ModuleResolver } from '@xyo-network/module-model'
 import { Promisable } from '@xyo-network/promise'
 
 export interface Node {
-  attach(address: string, name?: string): Promisable<void>
+  attach(address: string, external?: boolean): Promisable<void>
   attached(): Promisable<string[]>
   detach(address: string): Promisable<void>
   registered(): Promisable<string[]>

package/src/NodeWrapper.ts

@@ -1,8 +1,10 @@
+import { assertEx } from '@xylabs/assert'
 import { AddressPayload, AddressSchema } from '@xyo-network/address-payload-plugin'
 import { ArchivistWrapper } from '@xyo-network/archivist-wrapper'
-import { ModuleFilter, ModuleWrapper } from '@xyo-network/module'
+import { Module, ModuleFilter, ModuleWrapper } from '@xyo-network/module'
 import { isXyoPayloadOfSchemaType } from '@xyo-network/payload-model'
 import { PayloadWrapper } from '@xyo-network/payload-wrapper'
+import { Promisable } from '@xyo-network/promise'
 
 import { Node, NodeModule } from './Node'
 import {
@@ -17,6 +19,8 @@ import {
 } from './Queries'
 
 export class NodeWrapper<TModule extends NodeModule = NodeModule> extends ModuleWrapper<TModule> implements Node, NodeModule {
+  static requiredQueries = [XyoNodeAttachQuerySchema, ...ModuleWrapper.requiredQueries]
+
   public isModuleResolver = true
 
   private _archivist?: ArchivistWrapper
@@ -26,8 +30,16 @@ export class NodeWrapper<TModule extends NodeModule = NodeModule> extends Module
     return this._archivist
   }
 
-  async attach(address: string, name?: string): Promise<void> {
-    const queryPayload = PayloadWrapper.parse<XyoNodeAttachQuery>({ address, name, schema: XyoNodeAttachQuerySchema })
+  static tryWrap(module: Module): NodeWrapper | undefined {
+    return this.hasRequiredQueries(module) ? new NodeWrapper(module as NodeModule) : undefined
+  }
+
+  static wrap(module: Module): NodeWrapper {
+    return assertEx(this.tryWrap(module), 'Unable to wrap module as NodeWrapper')
+  }
+
+  async attach(address: string, external?: boolean): Promise<void> {
+    const queryPayload = PayloadWrapper.parse<XyoNodeAttachQuery>({ address, external, schema: XyoNodeAttachQuerySchema })
     await this.sendQuery(queryPayload)
   }
 
@@ -48,10 +60,7 @@ export class NodeWrapper<TModule extends NodeModule = NodeModule> extends Module
     return payloads.map((p) => p.address)
   }
 
-  resolve(filter?: ModuleFilter) {
+  resolve(filter?: ModuleFilter): Promisable<Module[]> {
     return this.module.resolve(filter)
   }
-  tryResolve(filter?: ModuleFilter) {
-    return this.module.tryResolve(filter)
-  }
 }

package/src/Queries/Attach.ts

@@ -5,6 +5,6 @@ export const XyoNodeAttachQuerySchema: XyoNodeAttachQuerySchema = 'network.xyo.q
 
 export type XyoNodeAttachQuery = XyoQuery<{
   address: string
-  name?: string
+  external?: boolean
   schema: XyoNodeAttachQuerySchema
 }>

package/src/spec/MemoryNode.spec.ts

@@ -10,11 +10,11 @@ import {
   XyoHuriPayload,
   XyoHuriSchema,
 } from '@xyo-network/diviner'
-import { AbstractModule, Module, ModuleDescription, SimpleModuleResolver } from '@xyo-network/module'
+import { AbstractModule, Module, ModuleDescription } from '@xyo-network/module'
 import { Account, PayloadWrapper, XyoPayload, XyoPayloadBuilder, XyoPayloadSchema } from '@xyo-network/protocol'
 
 import { NodeConfigSchema } from '../Config'
-import { MemoryNode, MemoryNodeParams } from '../MemoryNode'
+import { MemoryNode } from '../MemoryNode'
 
 describe('MemoryNode', () => {
   const testAccount1 = new Account({ phrase: 'testPhrase1' })
@@ -34,7 +34,6 @@ describe('MemoryNode', () => {
       const archivist = await XyoMemoryArchivist.create()
       const diviner: AbstractModule = await ArchivistPayloadDiviner.create({
         config: { archivist: archivist.address, schema: XyoArchivistPayloadDivinerConfigSchema },
-        resolver: new SimpleModuleResolver().add(archivist),
       })
       node.register(archivist)
       node.attach(archivist.address)
@@ -61,7 +60,7 @@ describe('MemoryNode', () => {
       if (payloads && payloads[0]) {
         const huri = new PayloadWrapper(payloads[0]).hash
         const huriPayload: XyoHuriPayload = { huri: [huri], schema: XyoHuriSchema }
-        const module = (await node.resolve({ address: [diviner.address] })).shift() as DivinerModule
+        const module = (await node.resolve({ address: [diviner.address] })).shift() as DivinerModule | undefined
         const foundDiviner = module ? new DivinerWrapper(module) : null
         expect(foundDiviner).toBeDefined()
         if (foundDiviner) {
@@ -76,15 +75,14 @@ describe('MemoryNode', () => {
         }
       }
     })
-    describe('with autoAttachExternallyResolved true', () => {
+    /*describe('with autoAttachExternallyResolved true', () => {
       it('attaches external modules to internal resolver', async () => {
         // Arrange
         // Create a MemoryNode with no modules in the internal
         // resolver and one module in the external resolver
-        const resolver = new SimpleModuleResolver()
-        const internalResolver = new SimpleModuleResolver()
+        const resolver = new CompositeModuleResolver()
+        const internalResolver = new CompositeModuleResolver()
         const params: MemoryNodeParams = {
-          autoAttachExternallyResolved: true,
           config: { schema: NodeConfigSchema },
           internalResolver,
           resolver,
@@ -93,9 +91,9 @@ describe('MemoryNode', () => {
         const filter = { address: [module.address] }
         resolver.add(module)
         // No modules exist in internal resolver
-        expect(await internalResolver.tryResolve(filter)).toBeArrayOfSize(0)
+        expect(await internalResolver.resolve(filter)).toBeArrayOfSize(0)
         // Module exists in external resolver
-        expect(await resolver.tryResolve(filter)).toBeArrayOfSize(1)
+        expect(await resolver.resolve(filter)).toBeArrayOfSize(1)
         const node = await MemoryNode.create(params)
         // No modules are attached
         expect(await node.attached()).toBeArrayOfSize(0)
@@ -103,17 +101,17 @@ describe('MemoryNode', () => {
         // Act
         // Query for unattached module (by address) that exists in
         // external resolver
-        expect(await node.tryResolve(filter)).toBeArrayOfSize(1)
+        expect(await node.resolve(filter)).toBeArrayOfSize(1)
 
         // Assert
         // Module is now attached
         expect(await node.attached()).toBeArrayOfSize(1)
         // Module exists in internal resolver
-        expect(await internalResolver.tryResolve(filter)).toBeArrayOfSize(1)
+        expect(await internalResolver.resolve(filter)).toBeArrayOfSize(1)
         // Module still exists in external resolver
-        expect(await resolver.tryResolve(filter)).toBeArrayOfSize(1)
+        expect(await resolver.resolve(filter)).toBeArrayOfSize(1)
       })
-    })
+    })*/
   })
   describe('register', () => {
     it('registers module', async () => {
@@ -151,16 +149,13 @@ describe('MemoryNode', () => {
       node.attach(module.address)
     })
     it('emits event on module attach', (done) => {
-      const name = 'foo'
       node.on('moduleAttached', (args) => {
         expect(args.module).toBeObject()
         expect(args.module.address).toBe(module.address)
-        expect(args.name).toBeDefined()
-        expect(args.name).toBe(name)
         expect(args.module).toBe(module)
         done()
       })
-      node.attach(module.address, name)
+      node.attach(module.address)
     })
   })
   describe('attached', () => {
@@ -197,9 +192,9 @@ describe('MemoryNode', () => {
     it('deregisters existing module', () => {
       node.detach(module.address)
     })
-    it('allows deregistering non-existent module', () => {
+    /*it('allows deregistering non-existent module', () => {
       node.detach('4a15a6c96665931b76c1d2a587ea1132dbfdc266')
-    })
+    })*/
   })
   describe('registeredModules', () => {
     let module: AbstractModule
@@ -360,7 +355,7 @@ describe('MemoryNode', () => {
       })
     })
   })
-  describe('tryResolveWrapped', () => {
+  describe('resolveWrapped', () => {
     beforeEach(async () => {
       const modules = await Promise.all([
         await MemoryArchivist.create({ account: testAccount2, config: archivistConfig }),
@@ -373,7 +368,7 @@ describe('MemoryNode', () => {
     })
     it('resolves modules wrapped as the specified type', async () => {
       const filter = { address: [testAccount2.addressValue.hex] }
-      const modules = await node.tryResolveWrapped(ArchivistWrapper, filter)
+      const modules = await node.resolveWrapped(ArchivistWrapper, filter)
       expect(modules.length).toBeGreaterThan(0)
       modules.map((mod) => {
         expect(mod.get).toBeFunction()
@@ -382,19 +377,6 @@ describe('MemoryNode', () => {
       })
     })
   })
-  describe('resolver', () => {
-    it('emits event when resolver changes', (done) => {
-      const resolver = new SimpleModuleResolver()
-      node.on('moduleResolverChanged', (args) => {
-        expect(args).toBeObject()
-        expect(args.resolver).toBe(resolver)
-        done()
-      })
-      expect(node.resolver).toBeUndefined()
-      node.resolver = resolver
-      expect(node.resolver).toBe(resolver)
-    })
-  })
 })
 
 const prettyPrintDescription = (description: ModuleDescription) => {