@xyo-network/node 2.41.2 → 2.41.4

package/src/MemoryNode.spec.ts

@@ -1,5 +1,5 @@
 /* eslint-disable max-statements */
-import { XyoArchivistWrapper } from '@xyo-network/archivist'
+import { XyoArchivistWrapper, XyoMemoryArchivist, XyoMemoryArchivistConfigSchema } from '@xyo-network/archivist'
 import {
   DivinerModule,
   XyoArchivistPayloadDiviner,
@@ -8,57 +8,248 @@ import {
   XyoHuriPayload,
   XyoHuriSchema,
 } from '@xyo-network/diviner'
-import { XyoModule, XyoModuleResolver } from '@xyo-network/module'
-import { PayloadWrapper, XyoPayload, XyoPayloadBuilder, XyoPayloadSchema } from '@xyo-network/sdk'
+import { ModuleDescription, XyoModule, XyoModuleResolver } from '@xyo-network/module'
+import { PayloadWrapper, XyoAccount, XyoPayload, XyoPayloadBuilder, XyoPayloadSchema } from '@xyo-network/protocol'
 
+import { NodeConfigSchema } from './Config'
 import { MemoryNode } from './MemoryNode'
 import { NodeModule } from './NodeModule'
 
-test('Create Node', async () => {
-  const XyoMemoryArchivist = (await import('@xyo-network/archivist')).XyoMemoryArchivist
-  const node: NodeModule = await MemoryNode.create()
-  const archivist = await XyoMemoryArchivist.create()
-  const diviner: XyoModule = await XyoArchivistPayloadDiviner.create({
-    config: { archivist: archivist.address, schema: XyoArchivistPayloadDivinerConfigSchema },
-    resolver: new XyoModuleResolver().add(archivist),
+describe('MemoryNode', () => {
+  const testAccount1 = new XyoAccount({ phrase: 'testPhrase1' })
+  const testAccount2 = new XyoAccount({ phrase: 'testPhrase2' })
+  const testAccount3 = new XyoAccount({ phrase: 'testPhrase3' })
+  const testAccount4 = new XyoAccount({ phrase: 'testPhrase4' })
+  const nodeConfig = { schema: NodeConfigSchema }
+  let node: MemoryNode
+  beforeEach(async () => {
+    node = await MemoryNode.create({ account: testAccount1, config: nodeConfig })
   })
-  await node.register(archivist)
-  node.attach(archivist.address)
-  await node.register(diviner)
-  node.attach(diviner.address)
-  expect((await node.registered()).length).toBe(2)
-  expect((await node.attached()).length).toBe(2)
-  const foundArchivist = (await node.resolve({ address: [archivist.address] })).shift()
-  expect(foundArchivist).toBeDefined()
-  expect(foundArchivist?.address).toBe(archivist.address)
-  const testPayload = new XyoPayloadBuilder<XyoPayload<{ schema: XyoPayloadSchema; test: boolean }>>({ schema: XyoPayloadSchema })
-    .fields({ test: true })
-    .build()
+  describe('create', () => {
+    it('Creates MemoryNode', async () => {
+      const XyoMemoryArchivist = (await import('@xyo-network/archivist')).XyoMemoryArchivist
+      const node: NodeModule = await MemoryNode.create()
+      const archivist = await XyoMemoryArchivist.create()
+      const diviner: XyoModule = await XyoArchivistPayloadDiviner.create({
+        config: { archivist: archivist.address, schema: XyoArchivistPayloadDivinerConfigSchema },
+        resolver: new XyoModuleResolver().add(archivist),
+      })
+      await node.register(archivist)
+      node.attach(archivist.address)
+      await node.register(diviner)
+      node.attach(diviner.address)
+      expect((await node.registered()).length).toBe(2)
+      expect((await node.attached()).length).toBe(2)
+      const foundArchivist = (await node.resolve({ address: [archivist.address] })).shift()
+      expect(foundArchivist).toBeDefined()
+      expect(foundArchivist?.address).toBe(archivist.address)
+      const testPayload = new XyoPayloadBuilder<XyoPayload<{ schema: XyoPayloadSchema; test: boolean }>>({ schema: XyoPayloadSchema })
+        .fields({ test: true })
+        .build()
 
-  const foundArchivistWrapper = foundArchivist ? new XyoArchivistWrapper(foundArchivist) : undefined
-  await foundArchivistWrapper?.insert([testPayload])
+      const foundArchivistWrapper = foundArchivist ? new XyoArchivistWrapper(foundArchivist) : undefined
+      await foundArchivistWrapper?.insert([testPayload])
 
-  /*const subscribeQuery: XyoModuleSubscribeQuery = { payloads: [testPayload], schema: XyoModuleSubscribeQuerySchema }
+      /*const subscribeQuery: XyoModuleSubscribeQuery = { payloads: [testPayload], schema: XyoModuleSubscribeQuerySchema }
   await foundArchivist?.query(subscribeQuery)*/
 
-  const payloads = await foundArchivistWrapper?.all()
-  expect(payloads?.length).toBe(1)
-
-  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 foundDiviner = module ? new XyoDivinerWrapper(module) : null
-    expect(foundDiviner).toBeDefined()
-    if (foundDiviner) {
-      const foundDivinerWrapper = new XyoDivinerWrapper(foundDiviner)
-      const payloads = await foundDivinerWrapper.divine([huriPayload])
-      console.log(`payloads: ${JSON.stringify(payloads, null, 2)}`)
+      const payloads = await foundArchivistWrapper?.all()
       expect(payloads?.length).toBe(1)
-      expect(payloads[0]).toBeDefined()
-      if (payloads?.length === 1 && payloads[0]) {
-        expect(new PayloadWrapper(payloads[0]).hash).toBe(huri)
+
+      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 foundDiviner = module ? new XyoDivinerWrapper(module) : null
+        expect(foundDiviner).toBeDefined()
+        if (foundDiviner) {
+          const foundDivinerWrapper = new XyoDivinerWrapper(foundDiviner)
+          const payloads = await foundDivinerWrapper.divine([huriPayload])
+          // console.log(`payloads: ${JSON.stringify(payloads, null, 2)}`)
+          expect(payloads?.length).toBe(1)
+          expect(payloads[0]).toBeDefined()
+          if (payloads?.length === 1 && payloads[0]) {
+            expect(new PayloadWrapper(payloads[0]).hash).toBe(huri)
+          }
+        }
       }
+    })
+  })
+  describe('register', () => {
+    it('registers module', async () => {
+      const module = await XyoMemoryArchivist.create()
+      node.register(module)
+    })
+  })
+  describe('registered', () => {
+    describe('with no modules registered', () => {
+      it('returns empty array', () => {
+        const result = node.registered()
+        expect(result).toBeArrayOfSize(0)
+      })
+    })
+    describe('with modules registered', () => {
+      let module: XyoModule
+      beforeEach(async () => {
+        module = await XyoMemoryArchivist.create()
+        node.register(module)
+      })
+      it('lists addresses of registered modules', () => {
+        const result = node.registered()
+        expect(result).toBeArrayOfSize(1)
+        expect(result).toEqual([module.address])
+      })
+    })
+  })
+  describe('attach', () => {
+    let module: XyoModule
+    beforeEach(async () => {
+      module = await XyoMemoryArchivist.create()
+      node.register(module)
+    })
+    it('attaches module', () => {
+      node.attach(module.address)
+    })
+  })
+  describe('attached', () => {
+    let module: XyoModule
+    beforeEach(async () => {
+      module = await XyoMemoryArchivist.create()
+      node.register(module)
+    })
+    describe('with no modules attached', () => {
+      it('returns empty array', async () => {
+        const result = await node.attached()
+        expect(result).toBeArrayOfSize(0)
+      })
+    })
+    describe('with modules attached', () => {
+      beforeEach(() => {
+        node.attach(module.address)
+      })
+      it('lists addresses of attached modules', async () => {
+        node.attach(module.address)
+        const result = await node.attached()
+        expect(result).toBeArrayOfSize(1)
+        expect(result).toEqual([module.address])
+      })
+    })
+  })
+  describe('detach', () => {
+    let module: XyoModule
+    beforeEach(async () => {
+      module = await XyoMemoryArchivist.create()
+      node.register(module)
+      node.attach(module.address)
+    })
+    it('deregisters existing module', () => {
+      node.detach(module.address)
+    })
+    it('allows deregistering non-existent module', () => {
+      node.detach('4a15a6c96665931b76c1d2a587ea1132dbfdc266')
+    })
+  })
+  describe('registeredModules', () => {
+    let module: XyoModule
+    beforeEach(async () => {
+      module = await XyoMemoryArchivist.create()
+    })
+    describe('with no modules registered', () => {
+      it('returns empty array', () => {
+        const modules = node.registeredModules()
+        expect(modules).toBeArrayOfSize(0)
+      })
+    })
+    describe('with modules registered', () => {
+      it('returns registered modules', () => {
+        node.register(module)
+        const modules = node.registeredModules()
+        expect(modules).toBeArrayOfSize(1)
+        expect(modules).toContain(module)
+      })
+    })
+  })
+  describe('unregister', () => {
+    it('un-registers module', async () => {
+      const module = await XyoMemoryArchivist.create()
+      node.register(module)
+      expect(node.registeredModules()).toContain(module)
+      node.unregister(module)
+      expect(node.registeredModules()).not.toContain(module)
+    })
+  })
+  describe('description', () => {
+    const archivistConfig = { schema: XyoMemoryArchivistConfigSchema }
+    const validateModuleDescription = (description: ModuleDescription) => {
+      expect(description).toBeObject()
+      expect(description.address).toBeString()
+      expect(description.queries).toBeArray()
+      description.queries.map((query) => {
+        expect(query).toBeString()
+      })
     }
-  }
+    describe('node without child modules', () => {
+      it('describes node alone', async () => {
+        const description = await node.description()
+        validateModuleDescription(description)
+        expect(description.children).toBeArrayOfSize(0)
+      })
+      it('serializes to JSON consistently', async () => {
+        const description = await node.description()
+        expect(prettyPrintDescription(description)).toMatchSnapshot()
+      })
+    })
+    describe('node with child modules', () => {
+      beforeEach(async () => {
+        const modules = await Promise.all([
+          await XyoMemoryArchivist.create({ account: testAccount2, config: archivistConfig }),
+          await XyoMemoryArchivist.create({ account: testAccount3, config: archivistConfig }),
+        ])
+        modules.map((mod) => {
+          node.register(mod)
+          node.attach(mod.address)
+        })
+      })
+      it('describes node and child modules', async () => {
+        const description = await node.description()
+        validateModuleDescription(description)
+        expect(description.children).toBeArrayOfSize(2)
+        description.children?.map(validateModuleDescription)
+      })
+      it('serializes to JSON consistently', async () => {
+        const description = await node.description()
+        expect(prettyPrintDescription(description)).toMatchSnapshot()
+      })
+    })
+    describe('node with nested nodes and modules', () => {
+      beforeEach(async () => {
+        const nestedNode = await MemoryNode.create({ account: testAccount2, config: nodeConfig })
+        const nestedModules = await Promise.all([await XyoMemoryArchivist.create({ account: testAccount3, config: archivistConfig })])
+        nestedModules.map((mod) => {
+          nestedNode.register(mod)
+          nestedNode.attach(mod.address)
+        })
+        const rootModules: XyoModule[] = await Promise.all([await XyoMemoryArchivist.create({ account: testAccount4, config: archivistConfig })])
+        rootModules.push(nestedNode)
+        rootModules.map((mod) => {
+          node.register(mod)
+          node.attach(mod.address)
+        })
+      })
+      it('describes node and all nested nodes and child modules', async () => {
+        const description = await node.description()
+        validateModuleDescription(description)
+        expect(description.children).toBeArrayOfSize(2)
+        description.children?.map(validateModuleDescription)
+      })
+      it('serializes to JSON consistently', async () => {
+        const description = await node.description()
+        expect(prettyPrintDescription(description)).toMatchSnapshot()
+      })
+    })
+  })
 })
+
+const prettyPrintDescription = (description: ModuleDescription) => {
+  return JSON.stringify(description, null, 2)
+}

package/src/MemoryNode.ts

@@ -12,9 +12,9 @@ export class MemoryNode<TConfig extends NodeConfig = NodeConfig, TModule extends
     return (await super.create(params)) as MemoryNode
   }
 
-  override attach(address: string) {
+  override attach(address: string, name?: string) {
     const module = assertEx(this.registeredModuleMap.get(address), 'No module found at that address')
-    this.internalResolver.add(module)
+    this.internalResolver.add(module, name)
   }
 
   override detach(address: string) {

package/src/Node.ts

@@ -1,12 +1,7 @@
 import { Promisable } from '@xyo-network/promise'
 
-export interface ModuleIdentifier {
-  address?: string
-  schema?: string
-}
-
 export interface Node {
-  attach(address: string): void
+  attach(address: string, name?: string): void
   attached(): Promisable<string[]>
   detach(address: string): void
   registered(): Promisable<string[]>

package/src/NodeModule.ts

@@ -1,12 +1,11 @@
-import { Module, ModuleFilter } from '@xyo-network/module'
+import { Module, ModuleResolver } from '@xyo-network/module'
 import { Promisable, PromisableArray } from '@xyo-network/promise'
 
 import { Node } from './Node'
 
-export interface NodeModule<TModule extends Module = Module> extends Node, Module {
+export interface NodeModule<TModule extends Module = Module> extends Node, Module, ModuleResolver {
   attachedModules(): PromisableArray<TModule>
   register(module: TModule): Promisable<void>
   registeredModules(): PromisableArray<TModule>
-  resolve(filter?: ModuleFilter): Promisable<TModule[]>
   unregister(module: TModule): Promisable<void>
 }

package/src/Queries/Attach.ts

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

package/src/XyoNode.ts

@@ -1,11 +1,10 @@
 import { assertEx } from '@xylabs/assert'
 import { XyoAccount } from '@xyo-network/account'
-import { XyoArchivistWrapper, XyoMemoryArchivist } from '@xyo-network/archivist'
 import {
   Module,
+  ModuleDescription,
   ModuleFilter,
   ModuleQueryResult,
-  ModuleResolver,
   QueryBoundWitnessWrapper,
   XyoErrorBuilder,
   XyoModule,
@@ -13,7 +12,6 @@ import {
   XyoModuleResolver,
   XyoQueryBoundWitness,
 } from '@xyo-network/module'
-import { XyoModuleInstanceSchema } from '@xyo-network/module-instance-payload-plugin'
 import { XyoPayload } from '@xyo-network/payload'
 import { Promisable } from '@xyo-network/promise'
 
@@ -23,7 +21,7 @@ import { XyoNodeAttachedQuerySchema, XyoNodeAttachQuerySchema, XyoNodeDetachQuer
 
 export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig, TModule extends XyoModule = XyoModule>
   extends XyoModule<TConfig>
-  implements NodeModule, ModuleResolver
+  implements NodeModule
 {
   public isModuleResolver = true
 
@@ -47,14 +45,10 @@ export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig, TModule e
     return await (this.internalResolver.resolve() ?? [])
   }
 
-  public async getArchivist(): Promise<Module> {
-    if (!this._archivist) {
-      this._archivist =
-        this._archivist ??
-        (this.config?.archivist ? ((await this.resolver?.resolve({ address: [this.config?.archivist] })) ?? []).shift() : undefined) ??
-        (await XyoMemoryArchivist.create())
-    }
-    return this._archivist
+  override async description(): Promise<ModuleDescription> {
+    const desc = await super.description()
+    const children = await Promise.all((await this.attachedModules()).map((mod) => mod.description()))
+    return { ...desc, children }
   }
 
   override async query<T extends XyoQueryBoundWitness = XyoQueryBoundWitness>(query: T, payloads?: XyoPayload[]): Promise<ModuleQueryResult> {
@@ -106,7 +100,6 @@ export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig, TModule e
 
   override async start() {
     await super.start()
-    await this.storeInstanceData()
     return this
   }
 
@@ -114,13 +107,7 @@ export abstract class XyoNode<TConfig extends NodeConfig = NodeConfig, TModule e
     throw new Error('Method not implemented.')
   }
 
-  private async storeInstanceData() {
-    const payload = { address: this.address, queries: this.queries, schema: XyoModuleInstanceSchema }
-    const [bw] = await this.bindResult([payload])
-    await new XyoArchivistWrapper(await this.getArchivist()).insert([bw, payload])
-  }
-
-  abstract attach(_address: string): void
-  abstract detach(_address: string): void
-  abstract resolve(_filter?: ModuleFilter): Promisable<TModule[]>
+  abstract attach(address: string): void
+  abstract detach(address: string): void
+  abstract resolve(filter?: ModuleFilter): Promisable<TModule[]>
 }

package/src/XyoNodeWrapper.ts

@@ -17,14 +17,17 @@ import {
 } from './Queries'
 
 export class XyoNodeWrapper extends XyoModuleWrapper implements NodeModule {
+  public isModuleResolver = true
+
   private _archivist?: XyoArchivistWrapper
+
   public get archivist() {
     this._archivist = this._archivist ?? new XyoArchivistWrapper(this.module)
     return this._archivist
   }
 
-  async attach(address: string): Promise<void> {
-    const queryPayload = PayloadWrapper.parse<XyoNodeAttachQuery>({ address, schema: XyoNodeAttachQuerySchema })
+  async attach(address: string, name?: string): Promise<void> {
+    const queryPayload = PayloadWrapper.parse<XyoNodeAttachQuery>({ address, name, schema: XyoNodeAttachQuerySchema })
     const query = await this.bindQuery(queryPayload)
     const result = await this.module.query(query[0], query[1])
     this.throwErrors(query, result)

package/src/__snapshots__/MemoryNode.spec.ts.snap

@@ -0,0 +1,109 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`MemoryNode description node with child modules serializes to JSON consistently 1`] = `
+"{
+  "address": "3a15a6c96665931b76c1d2a587ea1132dbfdc266",
+  "queries": [
+    "network.xyo.query.node.attach",
+    "network.xyo.query.node.detach",
+    "network.xyo.query.module.discover",
+    "network.xyo.query.module.subscribe"
+  ],
+  "children": [
+    {
+      "address": "b3bbeb946d88cd5fe70146a6bb276c7b384f6582",
+      "queries": [
+        "network.xyo.query.archivist.all",
+        "network.xyo.query.archivist.delete",
+        "network.xyo.query.archivist.clear",
+        "network.xyo.query.archivist.find",
+        "network.xyo.query.archivist.commit",
+        "network.xyo.query.archivist.get",
+        "network.xyo.query.archivist.insert",
+        "network.xyo.query.module.discover",
+        "network.xyo.query.module.subscribe"
+      ]
+    },
+    {
+      "address": "ca2e94ac3ae1084072b3a4407881bf940dc2019c",
+      "queries": [
+        "network.xyo.query.archivist.all",
+        "network.xyo.query.archivist.delete",
+        "network.xyo.query.archivist.clear",
+        "network.xyo.query.archivist.find",
+        "network.xyo.query.archivist.commit",
+        "network.xyo.query.archivist.get",
+        "network.xyo.query.archivist.insert",
+        "network.xyo.query.module.discover",
+        "network.xyo.query.module.subscribe"
+      ]
+    }
+  ]
+}"
+`;
+
+exports[`MemoryNode description node with nested nodes and modules serializes to JSON consistently 1`] = `
+"{
+  "address": "3a15a6c96665931b76c1d2a587ea1132dbfdc266",
+  "queries": [
+    "network.xyo.query.node.attach",
+    "network.xyo.query.node.detach",
+    "network.xyo.query.module.discover",
+    "network.xyo.query.module.subscribe"
+  ],
+  "children": [
+    {
+      "address": "f59810a9da8a99e464355a411afe06f8c2d1c4b8",
+      "queries": [
+        "network.xyo.query.archivist.all",
+        "network.xyo.query.archivist.delete",
+        "network.xyo.query.archivist.clear",
+        "network.xyo.query.archivist.find",
+        "network.xyo.query.archivist.commit",
+        "network.xyo.query.archivist.get",
+        "network.xyo.query.archivist.insert",
+        "network.xyo.query.module.discover",
+        "network.xyo.query.module.subscribe"
+      ]
+    },
+    {
+      "address": "b3bbeb946d88cd5fe70146a6bb276c7b384f6582",
+      "queries": [
+        "network.xyo.query.node.attach",
+        "network.xyo.query.node.detach",
+        "network.xyo.query.module.discover",
+        "network.xyo.query.module.subscribe"
+      ],
+      "children": [
+        {
+          "address": "ca2e94ac3ae1084072b3a4407881bf940dc2019c",
+          "queries": [
+            "network.xyo.query.archivist.all",
+            "network.xyo.query.archivist.delete",
+            "network.xyo.query.archivist.clear",
+            "network.xyo.query.archivist.find",
+            "network.xyo.query.archivist.commit",
+            "network.xyo.query.archivist.get",
+            "network.xyo.query.archivist.insert",
+            "network.xyo.query.module.discover",
+            "network.xyo.query.module.subscribe"
+          ]
+        }
+      ]
+    }
+  ]
+}"
+`;
+
+exports[`MemoryNode description node without child modules serializes to JSON consistently 1`] = `
+"{
+  "address": "3a15a6c96665931b76c1d2a587ea1132dbfdc266",
+  "queries": [
+    "network.xyo.query.node.attach",
+    "network.xyo.query.node.detach",
+    "network.xyo.query.module.discover",
+    "network.xyo.query.module.subscribe"
+  ],
+  "children": []
+}"
+`;