maxDepth and down only for manifest queries

packages/manifest/package.json

@@ -51,6 +51,9 @@
         }
       }
     },
+    "./schema": {
+      "default": "./src/schema.json"
+    },
     "./docs": {
       "default": "./dist/docs.json"
     },
@@ -70,4 +73,4 @@
   },
   "sideEffects": false,
   "version": "2.75.6"
-}
+}

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

@@ -116,7 +116,7 @@ export class ProxyModule extends BaseEmitter<ModuleParams, ModuleEventData> impl
     })
   }
 
-  manifest(): Promisable<ModuleManifestPayload> {
+  manifest(_depth?: number): Promisable<ModuleManifestPayload> {
     const name = this.config.name ?? 'Anonymous'
     return { config: { name, ...this.config }, schema: ManifestPayloadSchema }
   }

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

@@ -540,7 +540,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     }
   }
 
-  protected manifestHandler(_ignoreAddresses?: string[]): Promisable<ModuleManifestPayload> {
+  protected manifestHandler(_depth?: number, _ignoreAddresses?: string[]): Promisable<ModuleManifestPayload> {
     const name = this.config.name ?? 'Anonymous'
     return { config: { name, ...this.config }, schema: ModuleManifestPayloadSchema }
   }
@@ -581,7 +581,7 @@ export abstract class AbstractModule<TParams extends ModuleParams = ModuleParams
     const resultPayloads: Payload[] = []
     switch (queryPayload.schema) {
       case ModuleManifestQuerySchema: {
-        resultPayloads.push(await this.manifestHandler())
+        resultPayloads.push(await this.manifestHandler(queryPayload.depth))
         break
       }
       case ModuleDiscoverQuerySchema: {

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

@@ -31,9 +31,9 @@ export abstract class AbstractModuleInstance<TParams extends ModuleParams = Modu
     })
   }
 
-  manifest(ignoreAddresses?: string[]): Promise<ModuleManifestPayload> {
+  manifest(maxDepth?: number, ignoreAddresses?: string[]): Promise<ModuleManifestPayload> {
     return this.busy(async () => {
-      return await this.manifestHandler(ignoreAddresses)
+      return await this.manifestHandler(maxDepth, ignoreAddresses)
     })
   }
 

packages/modules/packages/module/packages/model/src/Queries/Manifest.ts

@@ -4,5 +4,6 @@ export type ModuleManifestQuerySchema = 'network.xyo.query.module.manifest'
 export const ModuleManifestQuerySchema: ModuleManifestQuerySchema = 'network.xyo.query.module.manifest'
 
 export type ModuleManifestQuery = Query<{
+  depth?: number
   schema: ModuleManifestQuerySchema
 }>

packages/modules/packages/module/packages/model/src/module/ModuleQueryFunctions.ts

@@ -8,6 +8,6 @@ import { AddressPreviousHashPayload } from '../Queries'
 export type ModuleQueryFunctions = {
   describe: () => Promise<ModuleDescription>
   discover: () => Promisable<Payload[]>
-  manifest: (ignoreAddresses?: string[]) => Promisable<ModuleManifestPayload>
+  manifest: (maxDepth?: number, ignoreAddresses?: string[]) => Promisable<ModuleManifestPayload>
   moduleAddress: () => Promisable<AddressPreviousHashPayload[]>
 }

packages/modules/packages/module/packages/wrapper/src/ModuleWrapper.ts

@@ -253,8 +253,8 @@ export class ModuleWrapper<TWrappedModule extends Module = Module>
     return this.module.listenerCount(eventNames)
   }
 
-  async manifest(): Promise<ModuleManifestPayload> {
-    const queryPayload: ModuleManifestQuery = { schema: ModuleManifestQuerySchema }
+  async manifest(maxDepth?: number): Promise<ModuleManifestPayload> {
+    const queryPayload: ModuleManifestQuery = { schema: ModuleManifestQuerySchema, ...(maxDepth !== undefined ? { maxDepth } : {}) }
     return (await this.sendQuery(queryPayload))[0] as ModuleManifestPayload
   }
 

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

@@ -71,8 +71,8 @@ export abstract class AbstractNode<TParams extends NodeParams = NodeParams, TEve
     return (await (this.resolve(undefined, { direction: 'down', maxDepth: 2 }) ?? [])).filter((module) => module.address !== this.address)
   }
 
-  override async manifest(ignoreAddresses?: string[]): Promise<NodeManifestPayload> {
-    return await this.manifestHandler(ignoreAddresses)
+  override async manifest(maxDepth?: number, ignoreAddresses?: string[]): Promise<NodeManifestPayload> {
+    return await this.manifestHandler(maxDepth, ignoreAddresses)
   }
 
   register(_module: ModuleInstance): Promisable<void> {
@@ -135,20 +135,20 @@ export abstract class AbstractNode<TParams extends NodeParams = NodeParams, TEve
     return [...(await super.discoverHandler()), ...childModAddresses]
   }
 
-  protected override async manifestHandler(ignoreAddresses: string[] = []): Promise<NodeManifestPayload> {
+  protected override async manifestHandler(maxDepth?: number, ignoreAddresses: string[] = []): Promise<NodeManifestPayload> {
     const manifest: NodeManifestPayload = { ...(await super.manifestHandler()), schema: NodeManifestPayloadSchema }
     const newIgnoreAddresses = [...ignoreAddresses, this.address]
 
     const notThisModule = (module: ModuleInstance) => module.address !== this.address && !ignoreAddresses.includes(module.address)
     const toManifest = (module: ModuleInstance) => module.manifest(newIgnoreAddresses)
 
-    const privateModules = await Promise.all((await this.privateResolver.resolve()).filter(notThisModule).map(toManifest))
+    /*const privateModules = await Promise.all((await this.privateResolver.resolve()).filter(notThisModule).map(toManifest))
     if (privateModules.length > 0) {
       manifest.modules = manifest.modules ?? {}
       manifest.modules.private = privateModules
-    }
+    }*/
 
-    const publicModules = await Promise.all((await this.resolve()).filter(notThisModule).map(toManifest))
+    const publicModules = await Promise.all((await this.resolve(undefined, { direction: 'down', maxDepth })).filter(notThisModule).map(toManifest))
     if (publicModules.length > 0) {
       manifest.modules = manifest.modules ?? {}
       manifest.modules.public = publicModules

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

@@ -9,7 +9,7 @@ export interface NodeQueryFunctions {
   attach(nameOrAddress: string, external?: boolean): Promisable<string | undefined>
   attached(): Promisable<string[]>
   detach(nameOrAddress: string): Promisable<string | undefined>
-  manifest(): Promise<NodeManifestPayload>
+  manifest(maxDepth?: number): Promise<NodeManifestPayload>
   registered(): Promisable<string[]>
 }
 

packages/modules/packages/node/packages/wrapper/src/NodeWrapper.ts

@@ -46,8 +46,8 @@ export class NodeWrapper<TWrappedModule extends NodeModule = NodeModule>
     return payloads.pop()?.address
   }
 
-  override async manifest(): Promise<NodeManifestPayload> {
-    const queryPayload: ModuleManifestQuery = { schema: ModuleManifestQuerySchema }
+  override async manifest(maxDepth?: number): Promise<NodeManifestPayload> {
+    const queryPayload: ModuleManifestQuery = { schema: ModuleManifestQuerySchema, ...(maxDepth ? { maxDepth } : {}) }
     const payloads: NodeManifestPayload[] = (await this.sendQuery(queryPayload)).filter(
       isPayloadOfSchemaType<NodeManifestPayload>(NodeManifestPayloadSchema),
     )

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

@@ -42,6 +42,6 @@ describe('MemoryNode', () => {
 
     const manifest = (await memoryNode.manifest()) as NodeManifestPayload
     expect(manifest.modules?.public).toBeArrayOfSize(4)
-    expect(manifest.modules?.private).toBeArrayOfSize(3)
+    //expect(manifest.modules?.private).toBeArrayOfSize(3)
   })
 })