@xyo-network/node-memory 5.3.22 → 5.3.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xyo-network/node-memory",
-  "version": "5.3.22",
+  "version": "5.3.24",
   "description": "Primary SDK for using XYO Protocol 2.0",
   "homepage": "https://xyo.network",
   "bugs": {
@@ -30,40 +30,36 @@
   "types": "dist/neutral/index.d.ts",
   "files": [
     "dist",
-    "src",
     "!**/*.bench.*",
     "!**/*.spec.*",
     "!**/*.test.*",
     "README.md"
   ],
   "dependencies": {
-    "@xyo-network/module-model": "~5.3.22",
-    "@xyo-network/node-abstract": "~5.3.22",
-    "@xyo-network/node-model": "~5.3.22",
-    "async-mutex": "~0.5.0"
+    "async-mutex": "~0.5.0",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/node-abstract": "~5.3.24",
+    "@xyo-network/node-model": "~5.3.24"
   },
   "devDependencies": {
     "@opentelemetry/api": "^1.9.1",
     "@types/node": "^25.5.0",
-    "@xylabs/sdk-js": "^5.0.91",
-    "@xylabs/ts-scripts-common": "~7.6.8",
-    "@xylabs/ts-scripts-yarn3": "~7.6.8",
-    "@xylabs/tsconfig": "~7.6.8",
-    "@xyo-network/module-model": "~5.3.22",
-    "@xyo-network/module-resolver": "~5.3.22",
-    "@xyo-network/node-abstract": "~5.3.22",
-    "@xyo-network/node-model": "~5.3.22",
+    "@xylabs/sdk-js": "^5.0.93",
+    "@xylabs/ts-scripts-common": "~7.6.16",
+    "@xylabs/ts-scripts-pnpm": "~7.6.16",
+    "@xylabs/tsconfig": "~7.6.16",
     "acorn": "^8.16.0",
     "async-mutex": "~0.5.0",
     "axios": "^1.14.0",
-    "cosmiconfig": "^9.0.1",
-    "esbuild": "^0.27.4",
-    "eslint": "^10.1.0",
+    "esbuild": "^0.28.0",
     "ethers": "^6.16.0",
-    "rollup": "^4.60.1",
     "tslib": "^2.8.1",
     "typescript": "~5.9.3",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@xyo-network/module-model": "~5.3.24",
+    "@xyo-network/module-resolver": "~5.3.24",
+    "@xyo-network/node-abstract": "~5.3.24",
+    "@xyo-network/node-model": "~5.3.24"
   },
   "peerDependencies": {
     "@xylabs/sdk-js": "^5",
@@ -74,4 +70,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/MemoryNode.ts

@@ -1,265 +0,0 @@
-import type {
-  Address, EventListener, Promisable,
-} from '@xylabs/sdk-js'
-import {
-  assertEx,
-  exists, isAddress, isDefined,
-} from '@xylabs/sdk-js'
-import {
-  type AnyConfigSchema,
-  type AttachableModuleInstance,
-  creatableModule,
-  type ModuleIdentifier,
-  type ModuleInstance,
-  type ModuleResolverInstance,
-  type QueryableModule,
-} from '@xyo-network/module-model'
-import type { CompositeModuleResolver } from '@xyo-network/module-resolver'
-import { AbstractNode } from '@xyo-network/node-abstract'
-import type {
-  ChildCertificationFields,
-  NodeConfig, NodeInstanceParams,
-  NodeModuleEventData,
-} from '@xyo-network/node-model'
-import { isNodeModule } from '@xyo-network/node-model'
-import { Mutex } from 'async-mutex'
-
-export type MemoryNodeParams = NodeInstanceParams<AnyConfigSchema<NodeConfig>>
-
-@creatableModule()
-export class MemoryNode<TParams extends MemoryNodeParams = MemoryNodeParams, TEventData extends NodeModuleEventData = NodeModuleEventData>
-  extends AbstractNode<TParams, TEventData> {
-  protected registeredModuleMap: Partial<Record<Address, AttachableModuleInstance>> = {}
-
-  private _attachMutex = new Mutex()
-
-  private _attachedPrivateModules = new Set<Address>()
-  private _attachedPublicModules = new Set<Address>()
-
-  async attachHandler(id: ModuleIdentifier, external?: boolean) {
-    await this.startedAsync('warn', true)
-    return assertEx(
-      isAddress(id) ? await this.attachUsingAddress(id as Address, external) : await this.attachUsingName(id, external),
-      () => `Unable to locate module [${id}]`,
-    )
-  }
-
-  async certifyHandler(id: ModuleIdentifier): Promise<ChildCertificationFields> {
-    const child = (await this.publicChildren()).find(child => child.modName === id || child.address === id)
-    if (child) {
-      return { address: child.address, expiration: Date.now() + 1000 * 60 * 10 /* 10 minutes */ }
-    }
-    throw new Error(`Unable to certify child module [${id}]`)
-  }
-
-  async detachHandler(id: ModuleIdentifier) {
-    return isAddress(id) ? await this.detachUsingAddress(id as Address) : await this.detachUsingName(id)
-  }
-
-  override async privateChildren(): Promise<ModuleInstance[]> {
-    return [...(await this.attachedPrivateModules()), ...this.params.privateChildren ?? []]
-  }
-
-  override async publicChildren(): Promise<ModuleInstance[]> {
-    return [...(await this.attachedPublicModules()), ...this.params.publicChildren ?? []]
-  }
-
-  async register(mod: AttachableModuleInstance) {
-    this.started('warn')
-    if (this.registeredModuleMap[mod.address]) {
-      if (this.registeredModuleMap[mod.address] === mod) {
-        this.logger?.warn(`Module already registered at that address[${mod.address}]|${mod.id}|[${mod.config.schema}]`)
-      } else {
-        throw new Error(`Other module already registered at that address[${mod.address}]|${mod.id}|[${mod.config.schema}]`)
-      }
-    }
-    this.registeredModuleMap[mod.address] = mod
-    const args = { mod, name: mod.modName }
-    await this.emit('moduleRegistered', args)
-  }
-
-  registeredHandler(): Promisable<Address[]> {
-    return Promise.resolve(
-      (Object.keys(this.registeredModuleMap) as Address[]).map((key) => {
-        return key
-      }),
-    )
-  }
-
-  registeredModules(): AttachableModuleInstance[] {
-    return Object.values(this.registeredModuleMap).map((value) => {
-      return value
-    }).filter(exists)
-  }
-
-  async unregister(mod: ModuleInstance): Promise<ModuleInstance> {
-    // try to detach if it is attached
-    try {
-      await this.detach(mod.address)
-    } catch {}
-    delete this.registeredModuleMap[mod.address]
-    const args = { mod, name: mod.modName }
-    await this.emit('moduleUnregistered', args)
-    return this
-  }
-
-  protected async attachUsingAddress(address: Address, external?: boolean) {
-    return await this._attachMutex.runExclusive(async () => {
-      const existingModule = await this.resolve(address)
-      if (existingModule) {
-        this.logger?.warn(`MemoryNode: Module [${existingModule?.modName ?? existingModule?.address}] already attached at address [${address}]`)
-      }
-      const mod = assertEx(this.registeredModuleMap[address], () => `No Module Registered at address [${address}]`)
-
-      if (this._attachedPublicModules.has(mod.address)) {
-        this.logger?.warn(`Module [${mod.modName}] already attached at [${address}] (public)`)
-      }
-      if (this._attachedPrivateModules.has(mod.address)) {
-        this.logger?.warn(`Module [${mod.modName}] already attached at [${address}] (private)`)
-      }
-
-      const notificationList = await this.getModulesToNotifyAbout(mod)
-
-      // give it private access
-      mod.upResolver.addResolver?.(this.privateResolver)
-
-      // give it public access
-      mod.upResolver.addResolver?.(this.downResolver as CompositeModuleResolver)
-
-      // give it outside access
-      mod.upResolver.addResolver?.(this.upResolver)
-
-      if (external) {
-        // expose it externally
-        this._attachedPublicModules.add(mod.address)
-        this.downResolver.addResolver(mod.downResolver as ModuleResolverInstance)
-      } else {
-        this._attachedPrivateModules.add(mod.address)
-        this.privateResolver.addResolver(mod.downResolver as ModuleResolverInstance)
-      }
-
-      mod.addParent(this)
-
-      const args = { mod, name: mod.modName }
-      await this.emit('moduleAttached', args)
-
-      if (isNodeModule(mod) && external) {
-        const attachedListener: EventListener<TEventData['moduleAttached']> = async (args: TEventData['moduleAttached']) =>
-          await this.emit('moduleAttached', args)
-
-        const detachedListener: EventListener<TEventData['moduleDetached']> = async (args: TEventData['moduleDetached']) =>
-          await this.emit('moduleDetached', args)
-
-        mod.on('moduleAttached', attachedListener as EventListener)
-        mod.on('moduleDetached', detachedListener as EventListener)
-      }
-
-      await this.notifyOfExistingModulesAttached(notificationList)
-
-      return address
-    })
-  }
-
-  protected async detachUsingAddress(address: Address) {
-    const mod = assertEx(this.registeredModuleMap[address], () => `No Module Registered at address [${address}]`)
-
-    const isAttachedPublic = this._attachedPublicModules.has(mod.address)
-    const isAttachedPrivate = this._attachedPrivateModules.has(mod.address)
-
-    assertEx(isAttachedPublic || isAttachedPrivate, () => `Module [${mod.modName}] not attached at [${address}]`)
-
-    // remove inside access
-    mod.upResolver?.removeResolver?.(this.privateResolver)
-
-    // remove outside access
-    mod.upResolver?.removeResolver?.(this.upResolver)
-
-    // remove external exposure
-    this.downResolver.removeResolver(mod.downResolver as ModuleResolverInstance)
-
-    mod.removeParent(this.address)
-
-    if (isAttachedPublic) {
-      this._attachedPublicModules.delete(mod.address)
-    }
-
-    if (isAttachedPrivate) {
-      this._attachedPrivateModules.delete(mod.address)
-    }
-
-    const args = { mod, name: mod.modName }
-    await this.emit('moduleDetached', args)
-
-    // notify of all sub node children detach
-    if (isNodeModule(mod)) {
-      const notificationList = await this.getModulesToNotifyAbout(mod)
-      await this.notifyOfExistingModulesDetached(notificationList)
-    }
-    return address
-  }
-
-  protected override startHandler() {
-    return super.startHandler()
-  }
-
-  private async attachUsingName(name: string, external?: boolean) {
-    const address = this.registeredModuleAddressFromName(name)
-    if (isDefined(address)) {
-      return await this.attachUsingAddress(address, external)
-    }
-  }
-
-  private async detachUsingName(name: string) {
-    const address = this.registeredModuleAddressFromName(name)
-    if (isDefined(address)) {
-      return await this.detachUsingAddress(address)
-    }
-  }
-
-  private async getModulesToNotifyAbout(node: ModuleInstance) {
-    const notifiedAddresses: string[] = []
-    // send attach events for all existing attached modules
-    const childModules = await node.resolve('*', { direction: 'down' })
-    return (
-      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)
-
-        return child
-      })
-    ).filter(exists)
-  }
-
-  private async notifyOfExistingModulesAttached(childModules: QueryableModule[]) {
-    await Promise.all(
-      childModules.map(async (child) => {
-        const args = { mod: child, name: child.modName }
-        await this.emit('moduleAttached', args)
-      }),
-    )
-  }
-
-  private async notifyOfExistingModulesDetached(childModules: QueryableModule[]) {
-    await Promise.all(
-      childModules.map(async (child) => {
-        const args = { mod: child, name: child.modName }
-        await this.emit('moduleDetached', args)
-      }),
-    )
-  }
-
-  private registeredModuleAddressFromName(name: string) {
-    return Object.values(this.registeredModuleMap).find((value) => {
-      return value?.modName === name
-    })?.address
-  }
-}

package/src/NodeHelper/attachToExistingNode.ts

@@ -1,25 +0,0 @@
-import { assertEx } from '@xylabs/sdk-js'
-import type { ModuleIdentifier } from '@xyo-network/module-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-import { asNodeInstance } from '@xyo-network/node-model'
-
-import { MemoryNode } from '../MemoryNode.ts'
-import { flatAttachToExistingNode } from './flatAttachToExistingNode.ts'
-
-export const attachToExistingNode = async (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance): Promise<NodeInstance> => {
-  const parts = id.split(':')
-  const first = assertEx(parts.shift(), () => 'missing first part')
-  if (parts.length === 0) {
-    // this is an immediate child/children
-    return await flatAttachToExistingNode(source, first, destination)
-  } else {
-    // all parts that are not the last should be nodes, build them and nest
-    const firstModule = await source.resolve(first)
-    const firstNode = asNodeInstance(firstModule, () => 'first part is not a node', { required: true })
-    const newNode = await MemoryNode.create({ config: firstNode.config })
-    await destination.register?.(newNode)
-    await destination.attach(newNode.address, true)
-    await attachToExistingNode(firstNode, parts.join(':'), newNode)
-    return destination
-  }
-}

package/src/NodeHelper/attachToNewNode.ts

@@ -1,19 +0,0 @@
-import type { CreatableName } from '@xylabs/sdk-js'
-import type { ModuleIdentifier } from '@xyo-network/module-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-import { NodeConfigSchema } from '@xyo-network/node-model'
-
-import type { MemoryNodeParams } from '../MemoryNode.ts'
-import { MemoryNode } from '../MemoryNode.ts'
-import { attachToExistingNode } from './attachToExistingNode.ts'
-
-const DEFAULT_NODE_PARAMS = { config: { schema: NodeConfigSchema }, name: 'MemoryNode' as CreatableName }
-
-export const attachToNewNode = async (
-  source: NodeInstance,
-  id: ModuleIdentifier,
-  destinationParams: MemoryNodeParams = DEFAULT_NODE_PARAMS,
-): Promise<NodeInstance> => {
-  const destination = await MemoryNode.create(destinationParams)
-  return await attachToExistingNode(source, id, destination)
-}

package/src/NodeHelper/flatAttachToExistingNode.ts

@@ -1,28 +0,0 @@
-import { assertEx, exists } from '@xylabs/sdk-js'
-import type { ModuleIdentifier } from '@xyo-network/module-model'
-import { asAttachableModuleInstance } from '@xyo-network/module-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-
-export const flatAttachAllToExistingNode = async (source: NodeInstance, destination: NodeInstance): Promise<NodeInstance> => {
-  const children = (await source.publicChildren()).map(child => asAttachableModuleInstance(child)).filter(exists)
-  await Promise.all(
-    children.map(async (child) => {
-      await destination.register?.(child)
-      await destination.attach(child.address, true)
-    }),
-  )
-  return destination
-}
-
-export const flatAttachChildToExistingNode = async (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance): Promise<NodeInstance> => {
-  assertEx(id !== '*', () => '* is not a single child')
-  const child = assertEx(await source.resolve(id), () => `Module ${id} not found`)
-  const attachableChild = asAttachableModuleInstance(child, () => `Module ${id} is not attachable`, { required: true })
-  await destination.register?.(attachableChild)
-  await destination.attach(child.address, true)
-  return destination
-}
-
-export const flatAttachToExistingNode = async (source: NodeInstance, id: ModuleIdentifier, destination: NodeInstance): Promise<NodeInstance> => {
-  return id === '*' ? await flatAttachAllToExistingNode(source, destination) : flatAttachChildToExistingNode(source, id, destination)
-}

package/src/NodeHelper/flatAttachToNewNode.ts

@@ -1,15 +0,0 @@
-import type { ModuleIdentifier } from '@xyo-network/module-model'
-import type { NodeInstance } from '@xyo-network/node-model'
-
-import type { MemoryNodeParams } from '../MemoryNode.ts'
-import { MemoryNode } from '../MemoryNode.ts'
-import { flatAttachToExistingNode } from './flatAttachToExistingNode.ts'
-
-export const flatAttachToNewNode = async (
-  source: NodeInstance,
-  id: ModuleIdentifier,
-  destinationParams: MemoryNodeParams,
-): Promise<NodeInstance> => {
-  const destination = await MemoryNode.create(destinationParams)
-  return await flatAttachToExistingNode(source, id, destination)
-}

package/src/NodeHelper/index.ts

@@ -1,18 +0,0 @@
-import { NodeHelper } from '@xyo-network/node-abstract'
-
-import { attachToExistingNode } from './attachToExistingNode.ts'
-import { attachToNewNode } from './attachToNewNode.ts'
-import {
-  flatAttachAllToExistingNode, flatAttachChildToExistingNode, flatAttachToExistingNode,
-} from './flatAttachToExistingNode.ts'
-import { flatAttachToNewNode } from './flatAttachToNewNode.ts'
-
-export const MemoryNodeHelper = {
-  ...NodeHelper,
-  attachToExistingNode,
-  attachToNewNode,
-  flatAttachAllToExistingNode,
-  flatAttachChildToExistingNode,
-  flatAttachToExistingNode,
-  flatAttachToNewNode,
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './MemoryNode.ts'
-export * from './NodeHelper/index.ts'