@xyo-network/node 2.65.5 → 2.66.0

package/package.json

@@ -11,26 +11,26 @@
   },
   "dependencies": {
     "@xylabs/assert": "^2.9.3",
-    "@xyo-network/account": "^2.65.5",
-    "@xyo-network/account-model": "^2.65.5",
-    "@xyo-network/address-payload-plugin": "^2.65.5",
-    "@xyo-network/boundwitness-builder": "^2.65.5",
-    "@xyo-network/error": "^2.65.5",
-    "@xyo-network/manifest-model": "^2.65.5",
-    "@xyo-network/module": "^2.65.5",
-    "@xyo-network/module-abstract": "^2.65.5",
-    "@xyo-network/module-model": "^2.65.5",
-    "@xyo-network/node-model": "^2.65.5",
-    "@xyo-network/node-wrapper": "^2.65.5",
-    "@xyo-network/payload-builder": "^2.65.5",
-    "@xyo-network/payload-model": "^2.65.5",
-    "@xyo-network/promise": "^2.65.5",
+    "@xyo-network/account": "^2.66.0",
+    "@xyo-network/account-model": "^2.66.0",
+    "@xyo-network/address-payload-plugin": "^2.66.0",
+    "@xyo-network/boundwitness-builder": "^2.66.0",
+    "@xyo-network/error": "^2.66.0",
+    "@xyo-network/manifest-model": "^2.66.0",
+    "@xyo-network/module": "^2.66.0",
+    "@xyo-network/module-abstract": "^2.66.0",
+    "@xyo-network/module-model": "^2.66.0",
+    "@xyo-network/node-model": "^2.66.0",
+    "@xyo-network/node-wrapper": "^2.66.0",
+    "@xyo-network/payload-builder": "^2.66.0",
+    "@xyo-network/payload-model": "^2.66.0",
+    "@xyo-network/promise": "^2.66.0",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.195",
-    "@xylabs/ts-scripts-yarn3": "^2.18.10",
-    "@xylabs/tsconfig": "^2.18.10",
+    "@xylabs/ts-scripts-yarn3": "^2.18.11",
+    "@xylabs/tsconfig": "^2.18.11",
     "typescript": "^5.1.6"
   },
   "description": "Primary SDK for using XYO Protocol 2.0",
@@ -66,5 +66,5 @@
   },
   "sideEffects": false,
   "types": "dist/types/index.d.ts",
-  "version": "2.65.5"
+  "version": "2.66.0"
 }

package/src/AbstractNode.ts

@@ -6,7 +6,15 @@ import { handleErrorAsync } from '@xyo-network/error'
 import { NodeManifestPayload, NodeManifestPayloadSchema } from '@xyo-network/manifest-model'
 import { ModuleWrapper } from '@xyo-network/module'
 import { AbstractIndirectModule, CompositeModuleResolver, ModuleErrorBuilder } from '@xyo-network/module-abstract'
-import { duplicateModules, isDirectModule, Module, ModuleConfig, ModuleFilter, ModuleQueryResult } from '@xyo-network/module-model'
+import {
+  duplicateModules,
+  isDirectModule,
+  Module,
+  ModuleConfig,
+  ModuleFilter,
+  ModuleFilterOptions,
+  ModuleQueryResult,
+} from '@xyo-network/module-model'
 import {
   IndirectNodeModule,
   NodeAttachedQuerySchema,
@@ -59,7 +67,7 @@ export abstract class AbstractNode<TParams extends NodeModuleParams = NodeModule
   }
 
   async attachedModules(): Promise<Module[]> {
-    return await (this.privateResolver.resolve() ?? [])
+    return (await (this.downResolver.resolve() ?? [])).filter((module) => module.address !== this.address)
   }
 
   register(_module: Module): Promisable<void> {
@@ -74,24 +82,37 @@ export abstract class AbstractNode<TParams extends NodeModuleParams = NodeModule
     throw new Error('Method not implemented.')
   }
 
-  async resolvePrivate<TModule extends Module = Module>(filter?: ModuleFilter): Promise<TModule[]>
-  async resolvePrivate<TModule extends Module = Module>(nameOrAddress: string): Promise<TModule | undefined>
-  async resolvePrivate<TModule extends Module = Module>(nameOrAddressOrFilter?: ModuleFilter | string): Promise<TModule | TModule[] | undefined> {
-    switch (typeof nameOrAddressOrFilter) {
-      case 'string': {
-        const byAddress = Account.isAddress(nameOrAddressOrFilter)
-          ? (await this.privateResolver.resolve<TModule>({ address: [nameOrAddressOrFilter] })).pop() ??
-            (await this.resolve<TModule>({ address: [nameOrAddressOrFilter] })).pop()
-          : undefined
-        return (
-          byAddress ??
-          (await this.privateResolver.resolve<TModule>({ name: [nameOrAddressOrFilter] })).pop() ??
-          (await this.resolve<TModule>({ name: [nameOrAddressOrFilter] })).pop()
-        )
+  override async resolve<TModule extends Module = Module>(filter?: ModuleFilter, options?: ModuleFilterOptions): Promise<TModule[]>
+  override async resolve<TModule extends Module = Module>(nameOrAddress: string, options?: ModuleFilterOptions): Promise<TModule | undefined>
+  override async resolve<TModule extends Module = Module>(
+    nameOrAddressOrFilter?: ModuleFilter | string,
+    options?: ModuleFilterOptions,
+  ): Promise<TModule | TModule[] | undefined> {
+    //checking type of nameOrAddressOrFilter before calling other functions since TS seems
+    //to need help here narrowing before the call
+    if (typeof nameOrAddressOrFilter === 'string') {
+      switch (options?.visibility) {
+        case 'private': {
+          return await this.resolvePrivate<TModule>(nameOrAddressOrFilter)
+        }
+        case 'all': {
+          return await this.resolveAll<TModule>(nameOrAddressOrFilter)
+        }
+        default: {
+          return await super.resolve<TModule>(nameOrAddressOrFilter, options)
+        }
       }
-      default: {
-        const filter: ModuleFilter | undefined = nameOrAddressOrFilter
-        return [...(await this.privateResolver.resolve<TModule>(filter)), ...(await this.resolve<TModule>(filter))].filter(duplicateModules)
+    } else {
+      switch (options?.visibility) {
+        case 'all': {
+          return await this.resolveAll<TModule>(nameOrAddressOrFilter)
+        }
+        case 'private': {
+          return await this.resolvePrivate<TModule>(nameOrAddressOrFilter)
+        }
+        default: {
+          return await super.resolve<TModule>(nameOrAddressOrFilter, options)
+        }
       }
     }
   }
@@ -115,13 +136,17 @@ export abstract class AbstractNode<TParams extends NodeModuleParams = NodeModule
     const notThisModule = (module: Module) => module.address !== this.address
     const toManifest = (module: Module) => (isDirectModule(module) ? module.manifest() : ModuleWrapper.wrap(module, this.account).manifest())
 
+    const privateModulesList = await this.privateResolver.resolve()
     const privateModules = await Promise.all((await this.privateResolver.resolve()).filter(notThisModule).map(toManifest))
+    console.log(`manifestHandler:privateModules:${privateModulesList.length}`)
     if (privateModules.length > 0) {
       manifest.modules = manifest.modules ?? {}
       manifest.modules.private = privateModules
     }
 
+    const publicModulesList = await this.downResolver.resolve()
     const publicModules = await Promise.all((await this.downResolver.resolve()).filter(notThisModule).map(toManifest))
+    console.log(`manifestHandler:publicModules:${publicModulesList.length}`)
     if (publicModules.length > 0) {
       manifest.modules = manifest.modules ?? {}
       manifest.modules.public = publicModules
@@ -193,6 +218,43 @@ export abstract class AbstractNode<TParams extends NodeModuleParams = NodeModule
     return (await this.bindQueryResult(queryPayload, resultPayloads, [queryAccount], errorPayloads))[0]
   }
 
+  private async resolveAll<TModule extends Module = Module>(filter?: ModuleFilter, options?: ModuleFilterOptions): Promise<TModule[]>
+  private async resolveAll<TModule extends Module = Module>(nameOrAddress: string, options?: ModuleFilterOptions): Promise<TModule | undefined>
+  private async resolveAll<TModule extends Module = Module>(
+    nameOrAddressOrFilter?: ModuleFilter | string,
+    options?: ModuleFilterOptions,
+  ): Promise<TModule | TModule[] | undefined> {
+    switch (typeof nameOrAddressOrFilter) {
+      case 'string': {
+        return (await this.resolvePrivate<TModule>(nameOrAddressOrFilter, options)) ?? (await super.resolve<TModule>(nameOrAddressOrFilter, options))
+      }
+      default: {
+        return [
+          ...(await this.resolvePrivate<TModule>(nameOrAddressOrFilter, options)),
+          ...(await super.resolve<TModule>(nameOrAddressOrFilter, options)),
+        ].filter(duplicateModules)
+      }
+    }
+  }
+
+  private async resolvePrivate<TModule extends Module = Module>(filter?: ModuleFilter, options?: ModuleFilterOptions): Promise<TModule[]>
+  private async resolvePrivate<TModule extends Module = Module>(nameOrAddress: string, options?: ModuleFilterOptions): Promise<TModule | undefined>
+  private async resolvePrivate<TModule extends Module = Module>(
+    nameOrAddressOrFilter?: ModuleFilter | string,
+    options?: ModuleFilterOptions,
+  ): Promise<TModule | TModule[] | undefined> {
+    const direction = options?.direction ?? 'all'
+    const down = direction === 'down' || direction === 'all'
+    switch (typeof nameOrAddressOrFilter) {
+      case 'string': {
+        return down ? await this.privateResolver.resolve<TModule>(nameOrAddressOrFilter) : undefined
+      }
+      default: {
+        return down ? await this.privateResolver.resolve<TModule>(nameOrAddressOrFilter) : undefined
+      }
+    }
+  }
+
   abstract attach(nameOrAddress: string, external?: boolean): Promisable<string | undefined>
   abstract detach(nameOrAddress: string): Promisable<string | undefined>
 }

package/src/MemoryNode.ts

@@ -27,30 +27,37 @@ export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams, TEv
   private registeredModuleMap: Record<string, Module> = {}
 
   override async attach(nameOrAddress: string, external?: boolean) {
+    await this.started('throw')
     return (await this.attachUsingAddress(nameOrAddress, external)) ?? (await this.attachUsingName(nameOrAddress, external))
   }
 
   async describe(): Promise<ModuleDescriptionPayload> {
+    await this.started('throw')
     return await super.describeHandler()
   }
 
   override async detach(nameOrAddress: string) {
+    await this.started('throw')
     return (await this.detachUsingAddress(nameOrAddress)) ?? (await this.detachUsingName(nameOrAddress))
   }
 
   async discover(): Promise<Payload[]> {
+    await this.started('throw')
     return await super.discoverHandler()
   }
 
   async manifest(): Promise<NodeManifestPayload> {
+    await this.started('throw')
     return await super.manifestHandler()
   }
 
   async moduleAddress(): Promise<AddressPreviousHashPayload[]> {
+    await this.started('throw')
     return await super.moduleAddressHandler()
   }
 
   override async register(module: Module) {
+    await this.started('throw')
     assertEx(!this.registeredModuleMap[module.address], `Module already registered at that address[${module.address}]`)
     this.registeredModuleMap[module.address] = module
     const args = { module, name: module.config.name }
@@ -74,6 +81,7 @@ export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams, TEv
   }
 
   override async unregister(module: Module) {
+    await this.started('throw')
     await this.detach(module.address)
     delete this.registeredModuleMap[module.address]
     const args = { module, name: module.config.name }
@@ -81,6 +89,10 @@ export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams, TEv
     return this
   }
 
+  protected override startHandler() {
+    return super.startHandler()
+  }
+
   private async attachUsingAddress(address: string, external?: boolean) {
     const existingModule = (await this.resolve({ address: [address] })).pop()
     assertEx(!existingModule, `Module [${existingModule?.config.name ?? existingModule?.address}] already attached at address [${address}]`)
@@ -116,17 +128,20 @@ export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams, TEv
 
     const notificationList = await getModulesToNotifyAbout(module)
 
-    this.privateResolver.addResolver(module.downResolver)
-
-    //give it inside access
+    //give it private access
     module.upResolver.addResolver?.(this.privateResolver)
 
+    //give it public access
+    module.upResolver.addResolver?.(this.downResolver)
+
     //give it outside access
     module.upResolver.addResolver?.(this.upResolver)
 
     if (external) {
       //expose it externally
       this.downResolver.addResolver(module.downResolver)
+    } else {
+      this.privateResolver.addResolver(module.downResolver)
     }
 
     const args = { module, name: module.config.name }
@@ -173,8 +188,6 @@ export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams, TEv
       return
     }
 
-    this.privateResolver.removeResolver(module.downResolver)
-
     //remove inside access
     module.upResolver?.removeResolver?.(this.privateResolver)