resolve up/down precision improved

packages/manifest/src/spec/Manifest.spec.ts

@@ -16,11 +16,11 @@ describe('Manifest', () => {
  expect(node).toBeDefined()
  const discover = await node.discover()
  const discoveredAddresses = discover.filter((item) => item.schema === AddressSchema)
- expect(discoveredAddresses.length).toBeGreaterThan(4)
- expect(await node.resolve()).toBeArrayOfSize(15)
+ expect(discoveredAddresses.length).toBe(4)
+ expect((await node.resolve()).length).toBeGreaterThan(10)
  const roundTrip = await node.manifest()
  expect(roundTrip.modules?.private).toBeArrayOfSize(1)
- expect(roundTrip.modules?.public).toBeArrayOfSize(14)
+ expect(roundTrip.modules?.public?.length).toBeGreaterThan(10)
  })
  })
  describe('Create Node from Manifest [Lazy]', () => {
@@ -32,11 +32,11 @@ describe('Manifest', () => {
  expect(node).toBeDefined()
  const discover = await node.discover()
  const discoveredAddresses = discover.filter((item) => item.schema === AddressSchema)
- expect(discoveredAddresses.length).toBeGreaterThan(4)
- expect(await node.resolve()).toBeArrayOfSize(15)
+ expect(discoveredAddresses.length).toBe(4)
+ expect((await node.resolve()).length).toBeGreaterThan(10)
  const roundTrip = await node.manifest()
  expect(roundTrip.modules?.private).toBeArrayOfSize(1)
- expect(roundTrip.modules?.public).toBeArrayOfSize(14)
+ expect(roundTrip.modules?.public?.length).toBeGreaterThan(10)
  })
  })
 })

packages/modules/packages/bridge/packages/module-resolver/src/ModuleResolver.ts

@@ -11,6 +11,7 @@ import {
  AddressModuleFilter,
  Module,
  ModuleFilter,
+ ModuleFilterOptions,
  ModuleInstance,
  ModuleResolver,
  NameModuleFilter,
@@ -93,22 +94,37 @@ export class BridgeModuleResolver extends CompositeModuleResolver implements Mod
  throw new Error('Method not implemented.')
  }
 
- override async resolve(filter?: ModuleFilter): Promise<ModuleInstance[]>
- override async resolve(nameOrAddress: string): Promise<ModuleInstance | undefined>
- override async resolve(nameOrAddressOrFilter?: ModuleFilter | string): Promise<ModuleInstance | ModuleInstance[] | undefined> {
+ override async resolve<T extends ModuleInstance = ModuleInstance>(
+ filter?: ModuleFilter<T>,
+ options?: ModuleFilterOptions<T>,
+ ): Promise<ModuleInstance[]>
+ override async resolve<T extends ModuleInstance = ModuleInstance>(
+ nameOrAddress: string,
+ options?: ModuleFilterOptions<T>,
+ ): Promise<ModuleInstance | undefined>
+ override async resolve<T extends ModuleInstance = ModuleInstance>(
+ nameOrAddressOrFilter?: ModuleFilter<T> | string,
+ options?: ModuleFilterOptions<T>,
+ ): Promise<ModuleInstance | ModuleInstance[] | undefined> {
+ const mutatedOptions = { ...options, maxDepth: (options?.maxDepth ?? BridgeModuleResolver.defaultMaxDepth) - 1 }
  await this.prime()
  await this.resolveRemoteModules()
  if (typeof nameOrAddressOrFilter === 'string') {
- const result: ModuleInstance | undefined =
- (await this.resolveByAddress(nameOrAddressOrFilter)) ?? (await this.resolveByName(nameOrAddressOrFilter))
+ if (mutatedOptions.maxDepth < 0) {
+ return undefined
+ }
+ const result: T | undefined = (await this.resolveByAddress<T>(nameOrAddressOrFilter)) ?? (await this.resolveByName<T>(nameOrAddressOrFilter))
  return result
  } else {
- const result: ModuleInstance[] = await this.resolveRemoteModules(nameOrAddressOrFilter)
+ if (mutatedOptions.maxDepth < 0) {
+ return []
+ }
+ const result: T[] = await this.resolveRemoteModules<T>(nameOrAddressOrFilter)
  return result
  }
  }
 
- private async resolveByAddress(targetAddress: string): Promise<ModuleInstance | undefined> {
+ private async resolveByAddress<T extends ModuleInstance = ModuleInstance>(targetAddress: string): Promise<T | undefined> {
  const remoteAddresses = await this.getRemoteAddresses()
 
  //check if it is even there
@@ -118,7 +134,7 @@ export class BridgeModuleResolver extends CompositeModuleResolver implements Mod
  }
 
  const cached = this.resolvedModules[targetAddress]
- if (cached) return await cached
+ if (cached) return (await cached) as T
 
  this.resolvedModules[targetAddress] =
  this.resolvedModules[targetAddress] ??
@@ -157,52 +173,52 @@ export class BridgeModuleResolver extends CompositeModuleResolver implements Mod
  }
  })(targetAddress)
 
- return await this.resolvedModules[targetAddress]
+ return (await this.resolvedModules[targetAddress]) as T
  }
 
- private async resolveByName(name: string): Promise<ModuleInstance | undefined> {
+ private async resolveByName<T extends ModuleInstance = ModuleInstance>(name: string): Promise<T | undefined> {
  const modules = await this.currentResolvedModules()
  return Object.values(modules)
  .filter((module) => module.config.name === name)
- .pop()
+ .pop() as T
  }
 
- private async resolveByQuery(queries: string[]): Promise<ModuleInstance[]> {
+ private async resolveByQuery<T extends ModuleInstance = ModuleInstance>(queries: string[]): Promise<T[]> {
  return Object.values(await this.currentResolvedModules()).filter((module) => {
  //filter out the requested queries
  const found = module.queries.filter((query) => queries.find((q) => q === query))
 
  //did we find all the requested queries?
  return queries.length === found.length
- })
+ }) as T[]
  }
 
- private async resolveRemoteModules(filter?: ModuleFilter): Promise<ModuleInstance[]> {
+ private async resolveRemoteModules<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter): Promise<T[]> {
  if ((filter as AddressModuleFilter)?.address) {
- return await this.resolveRemoteModulesByAddress(filter as AddressModuleFilter)
+ return await this.resolveRemoteModulesByAddress<T>(filter as AddressModuleFilter)
  }
 
  if ((filter as NameModuleFilter)?.name) {
- return await this.resolveRemoteModulesByName(filter as NameModuleFilter)
+ return await this.resolveRemoteModulesByName<T>(filter as NameModuleFilter)
  }
 
  if ((filter as QueryModuleFilter)?.query) {
- return await this.resolveRemoteModulesByQuery(filter as QueryModuleFilter)
+ return await this.resolveRemoteModulesByQuery<T>(filter as QueryModuleFilter)
  }
 
  //get all of them
- return await this.resolveRemoteModulesByAddress({ address: await this.getRemoteAddresses() })
+ return await this.resolveRemoteModulesByAddress<T>({ address: await this.getRemoteAddresses() })
  }
 
- private async resolveRemoteModulesByAddress(filter: AddressModuleFilter): Promise<ModuleInstance[]> {
- return compact(await Promise.all(filter.address.map((address) => this.resolveByAddress(address))))
+ private async resolveRemoteModulesByAddress<T extends ModuleInstance = ModuleInstance>(filter: AddressModuleFilter): Promise<T[]> {
+ return compact(await Promise.all(filter.address.map((address) => this.resolveByAddress<T>(address))))
  }
 
- private async resolveRemoteModulesByName(filter: NameModuleFilter): Promise<ModuleInstance[]> {
- return compact(await Promise.all(filter.name.map(async (name) => await this.resolveByName(name))))
+ private async resolveRemoteModulesByName<T extends ModuleInstance = ModuleInstance>(filter: NameModuleFilter): Promise<T[]> {
+ return compact(await Promise.all(filter.name.map(async (name) => await this.resolveByName<T>(name))))
  }
 
- private async resolveRemoteModulesByQuery(filter: QueryModuleFilter): Promise<ModuleInstance[]> {
- return compact((await Promise.all(filter.query.map(async (query) => await this.resolveByQuery(query)))).flat())
+ private async resolveRemoteModulesByQuery<T extends ModuleInstance = ModuleInstance>(filter: QueryModuleFilter): Promise<T[]> {
+ return compact((await Promise.all(filter.query.map(async (query) => await this.resolveByQuery<T>(query)))).flat())
  }
 }

packages/modules/packages/module/packages/abstract/src/AbstractModule.ts

@@ -291,15 +291,15 @@ export abstract class AbstractModule<
  switch (typeof nameOrAddressOrFilter) {
  case 'string': {
  return (
- (down ? await (this.downResolver as CompositeModuleResolver).resolve(nameOrAddressOrFilter) : undefined) ??
- (up ? await (this.upResolver as ModuleResolver).resolve(nameOrAddressOrFilter) : undefined)
+ (down ? await (this.downResolver as CompositeModuleResolver).resolve(nameOrAddressOrFilter, options) : undefined) ??
+ (up ? await (this.upResolver as ModuleResolver).resolve(nameOrAddressOrFilter, options) : undefined)
  )
  }
  default: {
  const filter: ModuleFilter | undefined = nameOrAddressOrFilter
  return [
- ...(down ? await (this.downResolver as CompositeModuleResolver).resolve(filter) : []),
- ...(up ? await (this.upResolver as ModuleResolver).resolve(filter) : []),
+ ...(down ? await (this.downResolver as CompositeModuleResolver).resolve(filter, options) : []),
+ ...(up ? await (this.upResolver as ModuleResolver).resolve(filter, options) : []),
  ].filter(duplicateModules)
  }
  }

packages/modules/packages/module/packages/abstract/src/AbstractModuleInstance.ts

@@ -26,6 +26,7 @@ export abstract class AbstractModuleInstance<
  // Clone params to prevent mutation of the incoming object
  const mutatedParams = { ...params } as TParams
  super(privateConstructorKey, mutatedParams, account)
+ this.upResolver.add(this)
  this.downResolver.add(this)
  }
 

packages/modules/packages/module/packages/abstract/src/Resolver/CompositeModuleResolver.ts

@@ -1,10 +1,11 @@
 import { exists } from '@xylabs/exists'
 import { Base, BaseParams } from '@xyo-network/core'
-import { duplicateModules, ModuleFilter, ModuleInstance, ModuleRepository, ModuleResolver } from '@xyo-network/module-model'
+import { duplicateModules, ModuleFilter, ModuleFilterOptions, ModuleInstance, ModuleRepository, ModuleResolver } from '@xyo-network/module-model'
 
 import { SimpleModuleResolver } from './SimpleModuleResolver'
 
 export class CompositeModuleResolver extends Base implements ModuleRepository, ModuleResolver {
+ static defaultMaxDepth = 4
  protected resolvers: ModuleResolver[] = []
  private localResolver: SimpleModuleResolver
 
@@ -49,22 +50,35 @@ export class CompositeModuleResolver extends Base implements ModuleRepository, M
  return this
  }
 
- async resolve(filter?: ModuleFilter): Promise<ModuleInstance[]>
- async resolve(nameOrAddress: string): Promise<ModuleInstance | undefined>
- async resolve(nameOrAddressOrFilter?: ModuleFilter | string): Promise<ModuleInstance | ModuleInstance[] | undefined> {
+ async resolve<T extends ModuleInstance = ModuleInstance>(filter?: ModuleFilter<T>, options?: ModuleFilterOptions<T>): Promise<ModuleInstance[]>
+ async resolve<T extends ModuleInstance = ModuleInstance>(
+ nameOrAddress: string,
+ options?: ModuleFilterOptions<T>,
+ ): Promise<ModuleInstance | undefined>
+ async resolve<T extends ModuleInstance = ModuleInstance>(
+ nameOrAddressOrFilter?: ModuleFilter<T> | string,
+ options?: ModuleFilterOptions<T>,
+ ): Promise<ModuleInstance | ModuleInstance[] | undefined> {
+ const mutatedOptions = { ...options, maxDepth: (options?.maxDepth ?? CompositeModuleResolver.defaultMaxDepth) - 1 }
  if (typeof nameOrAddressOrFilter === 'string') {
+ if (mutatedOptions.maxDepth < 0) {
+ return undefined
+ }
  const results = await Promise.all(
  this.resolvers.map(async (resolver) => {
- const result: ModuleInstance | undefined = await resolver.resolve(nameOrAddressOrFilter)
+ const result: ModuleInstance | undefined = await resolver.resolve(nameOrAddressOrFilter, mutatedOptions)
  return result
  }),
  )
  const result: ModuleInstance | undefined = results.filter(exists).filter(duplicateModules).pop()
  return result
  } else {
+ if (mutatedOptions.maxDepth < 0) {
+ return []
+ }
  const result = await Promise.all(
  this.resolvers.map(async (resolver) => {
- const result: ModuleInstance[] = await resolver.resolve(nameOrAddressOrFilter)
+ const result: ModuleInstance[] = await resolver.resolve(nameOrAddressOrFilter, mutatedOptions)
  return result
  }),
  )

packages/modules/packages/module/packages/model/src/instance/ModuleInstance.ts

@@ -39,6 +39,7 @@ export class IsInstanceFactory<T extends ModuleInstance = ModuleInstance> extend
 export interface ModuleFilterOptions<T extends ModuleInstance = ModuleInstance> {
  direction?: 'up' | 'down' | 'all'
  identity?: InstanceTypeCheck<T>
+ maxDepth?: number
  visibility?: 'public' | 'private' | 'all'
 }
 

packages/modules/packages/node/packages/model/src/Node.ts

@@ -37,6 +37,6 @@ export type NodeInstance<
 > = NodeModule<TParams, TEventData> &
  NodeQueryFunctions &
  ModuleInstance & {
- register: (module: ModuleInstance) => void
+ register: (module: ModuleInstance) => Promisable<void>
  registeredModules(): Promisable<ModuleInstance[]>
  }

packages/modules/packages/node/spec/MemoryNode/WithArchivistAndDiviner.spec.ts

@@ -64,5 +64,15 @@ describe('MemoryNode', () => {
  }
  }
  }
+
+ expect((await node.resolve(undefined, { direction: 'up' })).length).toBe(1)
+ expect((await node.resolve(undefined, { direction: 'down' })).length).toBe(3)
+ expect((await node.resolve(undefined, { direction: 'down', maxDepth: 1 })).length).toBe(1)
+ expect((await node.resolve(undefined, { direction: 'all' })).length).toBe(3)
+
+ expect((await archivist.resolve(undefined, { direction: 'up' })).length).toBe(3)
+ expect((await archivist.resolve(undefined, { direction: 'up', maxDepth: 1 })).length).toBe(1)
+ expect((await archivist.resolve(undefined, { direction: 'down' })).length).toBe(1)
+ expect((await archivist.resolve(undefined, { direction: 'all' })).length).toBe(3)
  })
 })

packages/modules/packages/node/src/AbstractNode.ts

@@ -64,7 +64,7 @@ export abstract class AbstractNode<TParams extends NodeModuleParams = NodeModule
  }
 
  async attachedModules(): Promise<Module[]> {
- return (await (this.resolve() ?? [])).filter((module) => module.address !== this.address)
+ return (await (this.resolve(undefined, { direction: 'down', maxDepth: 2 }) ?? [])).filter((module) => module.address !== this.address)
  }
 
  override async manifest(ignoreAddresses?: string[]): Promise<NodeManifestPayload> {

packages/modules/packages/sentinel/package.json

@@ -23,6 +23,7 @@
  "@xyo-network/payload-model": "workspace:~",
  "@xyo-network/payload-wrapper": "workspace:~",
  "@xyo-network/promise": "workspace:~",
+ "@xyo-network/sentinel-model": "workspace:~",
  "@xyo-network/witness": "workspace:~",
  "lodash": "^4.17.21"
  },

packages/modules/packages/sentinel/packages/model/.npmignore

@@ -0,0 +1,21 @@
+.*
+.env
+.eslintcache
+.example.env
+tsconfig*
+jest.config.js
+rollup.config.ts
+yarn.lock
+**/*.spec.ts
+**/*.snap
+
+.github
+docs
+.pnp.*
+.vscode
+.yarn/*
+coverage
+cspell.json
+node_modules
+swagger.json
+packages