feat: add packageId support for metadata filtering and registration across components

hotlong · hotlong · commit 259b7ad30123 · 2026-02-06T23:29:02.000+08:00
diff --git a/apps/console/src/components/app-sidebar.tsx b/apps/console/src/components/app-sidebar.tsx
@@ -129,14 +129,17 @@ export function AppSidebar({ client, selectedObject, onSelectObject, packages, s
       }
       setMetaTypes(types);
 
+      // Package scope: filter metadata by selected package
+      const packageId = selectedPackage?.manifest?.id;
+
       // 2. Load items for each type in parallel
       const entries = await Promise.all(
         types
           .filter(t => !HIDDEN_TYPES.has(t))
           .map(async (type) => {
             try {
               // Spec: GetMetaItemsResponse = { type, items: any[] }
-              const result = await client.meta.getItems(type);
+              const result = await client.meta.getItems(type, packageId ? { packageId } : undefined);
               let items: any[] = [];
               if (Array.isArray(result)) {
                 items = result as any;
@@ -157,7 +160,7 @@ export function AppSidebar({ client, selectedObject, onSelectObject, packages, s
     } finally {
       setLoading(false);
     }
-  }, [client]);
+  }, [client, selectedPackage]);
 
   useEffect(() => { loadMetadata(); }, [loadMetadata]);
 
diff --git a/apps/console/src/mocks/createKernel.ts b/apps/console/src/mocks/createKernel.ts
@@ -204,10 +204,14 @@ export async function createKernel(options: KernelOptions) {
                 }
                 if (method === 'objects') {
                     // Return spec-compliant GetMetaItemsResponse
+                    // Support optional packageId filter
+                    const packageId = params.packageId;
                     let objs = (ql && typeof ql.getObjects === 'function') ? ql.getObjects() : [];
                     
                     if (!objs || objs.length === 0) {
-                         objs = SchemaRegistry.getAllObjects();
+                         objs = SchemaRegistry.getAllObjects(packageId);
+                    } else if (packageId) {
+                         objs = objs.filter((o: any) => o._packageId === packageId);
                     }
                     return { type: 'object', items: objs };
                 }
@@ -230,8 +234,9 @@ export async function createKernel(options: KernelOptions) {
                      }
                      return def || null;
                 }
-                // Generic metadata type: metadata.<type> → SchemaRegistry.listItems(type)
-                const items = SchemaRegistry.listItems(method);
+                // Generic metadata type: metadata.<type> → SchemaRegistry.listItems(type, packageId?)
+                const packageId = params.packageId;
+                const items = SchemaRegistry.listItems(method, packageId);
                 if (items && items.length > 0) {
                     return { type: method, items };
                 }
diff --git a/packages/client/src/index.ts b/packages/client/src/index.ts
@@ -208,10 +208,15 @@ export class ObjectStackClient {
     /**
      * Get all items of a specific metadata type
      * @param type - Metadata type name (e.g., 'object', 'plugin')
+     * @param options - Optional filters (e.g., packageId to scope by package)
      */
-    getItems: async (type: string): Promise<GetMetaItemsResponse> => {
+    getItems: async (type: string, options?: { packageId?: string }): Promise<GetMetaItemsResponse> => {
         const route = this.getRoute('metadata');
-        const res = await this.fetch(`${this.baseUrl}${route}/${type}`);
+        const params = new URLSearchParams();
+        if (options?.packageId) params.set('package', options.packageId);
+        const qs = params.toString();
+        const url = `${this.baseUrl}${route}/${type}${qs ? `?${qs}` : ''}`;
+        const res = await this.fetch(url);
         return this.unwrapResponse<GetMetaItemsResponse>(res);
     },
 
diff --git a/packages/objectql/src/engine.test.ts b/packages/objectql/src/engine.test.ts
@@ -88,7 +88,7 @@ describe('ObjectQL Engine', () => {
             };
             
             engine.registerApp(manifest);
-            expect(SchemaRegistry.registerObject).toHaveBeenCalledWith(expect.objectContaining({ name: 'task' }));
+            expect(SchemaRegistry.registerObject).toHaveBeenCalledWith(expect.objectContaining({ name: 'task' }), 'com.example.app');
         });
 
         it('should register kinds from app manifest', () => {
diff --git a/packages/objectql/src/engine.ts b/packages/objectql/src/engine.ts
@@ -161,15 +161,15 @@ export class ObjectQL implements IDataEngine {
           if (Array.isArray(manifest.objects)) {
              this.logger.debug('Registering objects from manifest (Array)', { id, objectCount: manifest.objects.length });
              for (const objDef of manifest.objects) {
-                SchemaRegistry.registerObject(objDef);
+                SchemaRegistry.registerObject(objDef, id);
                 this.logger.debug('Registered Object', { object: objDef.name, from: id });
              }
           } else {
              this.logger.debug('Registering objects from manifest (Map)', { id, objectCount: Object.keys(manifest.objects).length });
              for (const [name, objDef] of Object.entries(manifest.objects)) {
                 // Ensure name in definition matches key
                 (objDef as any).name = name;
-                SchemaRegistry.registerObject(objDef as any);
+                SchemaRegistry.registerObject(objDef as any, id);
                 this.logger.debug('Registered Object', { object: name, from: id });
              }
           }
@@ -181,7 +181,7 @@ export class ObjectQL implements IDataEngine {
           for (const app of manifest.apps) {
               const appName = app.name || app.id;
               if (appName) {
-                  SchemaRegistry.registerApp(app);
+                  SchemaRegistry.registerApp(app, id);
                   this.logger.debug('Registered App', { app: appName, from: id });
               }
           }
@@ -190,7 +190,7 @@ export class ObjectQL implements IDataEngine {
       // 4. If manifest itself looks like an App (has navigation), also register as app
       //    This handles the case where the manifest IS the app definition (legacy/simple packages)
       if (manifest.name && manifest.navigation && !manifest.apps?.length) {
-          SchemaRegistry.registerApp(manifest);
+          SchemaRegistry.registerApp(manifest, id);
           this.logger.debug('Registered manifest-as-app', { app: manifest.name, from: id });
       }
 
@@ -206,7 +206,7 @@ export class ObjectQL implements IDataEngine {
               for (const item of items) {
                   const itemName = item.name || item.id;
                   if (itemName) {
-                      SchemaRegistry.registerItem(key, item, 'name' as any);
+                      SchemaRegistry.registerItem(key, item, 'name' as any, id);
                   }
               }
           }
diff --git a/packages/objectql/src/registry.ts b/packages/objectql/src/registry.ts
@@ -22,13 +22,18 @@ export class SchemaRegistry {
    * @param type The category of metadata (e.g., 'object', 'package', 'apps')
    * @param item The metadata item itself
    * @param keyField The property to use as the unique key (default: 'name')
+   * @param packageId Optional: the owning package ID for scoped queries
    */
-  static registerItem<T>(type: string, item: T, keyField: keyof T = 'name' as keyof T) {
+  static registerItem<T>(type: string, item: T, keyField: keyof T = 'name' as keyof T, packageId?: string) {
     if (!this.metadata.has(type)) {
       this.metadata.set(type, new Map());
     }
     const collection = this.metadata.get(type)!;
     const key = String(item[keyField]);
+    // Tag item with owning package for scoped queries
+    if (packageId) {
+      (item as any)._packageId = packageId;
+    }
 
     // Validation Hook
     try {
@@ -88,9 +93,15 @@ export class SchemaRegistry {
 
   /**
    * Universal List Method
+   * @param type The metadata type to list
+   * @param packageId Optional: filter items belonging to a specific package
    */
-  static listItems<T>(type: string): T[] {
-    return Array.from(this.metadata.get(type)?.values() || []) as T[];
+  static listItems<T>(type: string, packageId?: string): T[] {
+    const items = Array.from(this.metadata.get(type)?.values() || []) as T[];
+    if (packageId) {
+      return items.filter((item: any) => item._packageId === packageId);
+    }
+    return items;
   }
 
   /**
@@ -107,16 +118,16 @@ export class SchemaRegistry {
   /**
    * Object Helpers
    */
-  static registerObject(schema: ServiceObject) {
-    this.registerItem('object', schema, 'name');
+  static registerObject(schema: ServiceObject, packageId?: string) {
+    this.registerItem('object', schema, 'name', packageId);
   }
 
   static getObject(name: string): ServiceObject | undefined {
     return this.getItem<ServiceObject>('object', name);
   }
 
-  static getAllObjects(): ServiceObject[] {
-    return this.listItems<ServiceObject>('object');
+  static getAllObjects(packageId?: string): ServiceObject[] {
+    return this.listItems<ServiceObject>('object', packageId);
   }
 
   /**
@@ -198,8 +209,8 @@ export class SchemaRegistry {
    * App Helpers — UI navigation shells extracted from packages
    * @deprecated Use registerItem('apps', app, 'name') instead of registerApp for clarity
    */
-  static registerApp(app: any) {
-    this.registerItem('apps', app, 'name');
+  static registerApp(app: any, packageId?: string) {
+    this.registerItem('apps', app, 'name', packageId);
   }
 
   static getApp(name: string): any {
diff --git a/packages/runtime/src/http-dispatcher.ts b/packages/runtime/src/http-dispatcher.ts
@@ -137,7 +137,7 @@ export class HttpDispatcher {
      * Standard: /metadata/:type/:name
      * Fallback for backward compat: /metadata (all objects), /metadata/:objectName (get object)
      */
-    async handleMetadata(path: string, context: HttpProtocolContext, method?: string, body?: any): Promise<HttpDispatcherResult> {
+    async handleMetadata(path: string, context: HttpProtocolContext, method?: string, body?: any, query?: any): Promise<HttpDispatcherResult> {
         const broker = this.ensureBroker();
         const parts = path.replace(/^\/+/, '').split('/').filter(Boolean);
         
@@ -224,12 +224,14 @@ export class HttpDispatcher {
         // GET /metadata/:type (List items of type) OR /metadata/:objectName (Legacy)
         if (parts.length === 1) {
             const typeOrName = parts[0];
+            // Extract optional package filter from query string
+            const packageId = query?.package || undefined;
             
             // Try protocol service first for any type
             const protocol = this.kernel?.context?.getService ? this.kernel.context.getService('protocol') : null;
             if (protocol && typeof protocol.getMetaItems === 'function') {
                 try {
-                    const data = await protocol.getMetaItems({ type: typeOrName });
+                    const data = await protocol.getMetaItems({ type: typeOrName, packageId });
                     if (data && ((data.items && data.items.length > 0) || (Array.isArray(data) && data.length > 0))) {
                         return { handled: true, response: this.success(data) };
                     }
@@ -241,10 +243,10 @@ export class HttpDispatcher {
             // Try broker for the type
             try {
                 if (typeOrName === 'objects') {
-                    const data = await broker.call('metadata.objects', {}, { request: context.request });
+                    const data = await broker.call('metadata.objects', { packageId }, { request: context.request });
                     return { handled: true, response: this.success(data) };
                 }
-                const data = await broker.call(`metadata.${typeOrName}`, {}, { request: context.request });
+                const data = await broker.call(`metadata.${typeOrName}`, { packageId }, { request: context.request });
                 if (data !== null && data !== undefined) {
                     return { handled: true, response: this.success(data) };
                 }
@@ -683,7 +685,7 @@ export class HttpDispatcher {
         }
         
         if (cleanPath.startsWith('/meta')) {
-             return this.handleMetadata(cleanPath.substring(5), context);
+             return this.handleMetadata(cleanPath.substring(5), context, method, body, query);
         }
 
         if (cleanPath.startsWith('/data')) {

Original file line number	Diff line number	Diff line change
`@@ -204,10 +204,14 @@ export async function createKernel(options: KernelOptions) {`
`204`	`204`	`}`
`205`	`205`	`if (method === 'objects') {`
`206`	`206`	`// Return spec-compliant GetMetaItemsResponse`
	`207`	`+ // Support optional packageId filter`
	`208`	`+ const packageId = params.packageId;`
`207`	`209`	`let objs = (ql && typeof ql.getObjects === 'function') ? ql.getObjects() : [];`
`208`	`210`
`209`	`211`	`if (!objs \|\| objs.length === 0) {`
`210`		`- objs = SchemaRegistry.getAllObjects();`
	`212`	`+ objs = SchemaRegistry.getAllObjects(packageId);`
	`213`	`+ } else if (packageId) {`
	`214`	`+ objs = objs.filter((o: any) => o._packageId === packageId);`
`211`	`215`	`}`
`212`	`216`	`return { type: 'object', items: objs };`
`213`	`217`	`}`
`@@ -230,8 +234,9 @@ export async function createKernel(options: KernelOptions) {`
`230`	`234`	`}`
`231`	`235`	`return def \|\| null;`
`232`	`236`	`}`
`233`		`- // Generic metadata type: metadata.<type> → SchemaRegistry.listItems(type)`
`234`		`- const items = SchemaRegistry.listItems(method);`
	`237`	`+ // Generic metadata type: metadata.<type> → SchemaRegistry.listItems(type, packageId?)`
	`238`	`+ const packageId = params.packageId;`
	`239`	`+ const items = SchemaRegistry.listItems(method, packageId);`
`235`	`240`	`if (items && items.length > 0) {`
`236`	`241`	`return { type: method, items };`
`237`	`242`	`}`
Original file line number	Diff line number	Diff line change
`@@ -161,15 +161,15 @@ export class ObjectQL implements IDataEngine {`
`161`	`161`	`if (Array.isArray(manifest.objects)) {`
`162`	`162`	`this.logger.debug('Registering objects from manifest (Array)', { id, objectCount: manifest.objects.length });`
`163`	`163`	`for (const objDef of manifest.objects) {`
`164`		`- SchemaRegistry.registerObject(objDef);`
	`164`	`+ SchemaRegistry.registerObject(objDef, id);`
`165`	`165`	`this.logger.debug('Registered Object', { object: objDef.name, from: id });`
`166`	`166`	`}`
`167`	`167`	`} else {`
`168`	`168`	`this.logger.debug('Registering objects from manifest (Map)', { id, objectCount: Object.keys(manifest.objects).length });`
`169`	`169`	`for (const [name, objDef] of Object.entries(manifest.objects)) {`
`170`	`170`	`// Ensure name in definition matches key`
`171`	`171`	`(objDef as any).name = name;`
`172`		`- SchemaRegistry.registerObject(objDef as any);`
	`172`	`+ SchemaRegistry.registerObject(objDef as any, id);`
`173`	`173`	`this.logger.debug('Registered Object', { object: name, from: id });`
`174`	`174`	`}`
`175`	`175`	`}`
`@@ -181,7 +181,7 @@ export class ObjectQL implements IDataEngine {`
`181`	`181`	`for (const app of manifest.apps) {`
`182`	`182`	`const appName = app.name \|\| app.id;`
`183`	`183`	`if (appName) {`
`184`		`- SchemaRegistry.registerApp(app);`
	`184`	`+ SchemaRegistry.registerApp(app, id);`
`185`	`185`	`this.logger.debug('Registered App', { app: appName, from: id });`
`186`	`186`	`}`
`187`	`187`	`}`
`@@ -190,7 +190,7 @@ export class ObjectQL implements IDataEngine {`
`190`	`190`	`// 4. If manifest itself looks like an App (has navigation), also register as app`
`191`	`191`	`// This handles the case where the manifest IS the app definition (legacy/simple packages)`
`192`	`192`	`if (manifest.name && manifest.navigation && !manifest.apps?.length) {`
`193`		`- SchemaRegistry.registerApp(manifest);`
	`193`	`+ SchemaRegistry.registerApp(manifest, id);`
`194`	`194`	`this.logger.debug('Registered manifest-as-app', { app: manifest.name, from: id });`
`195`	`195`	`}`
`196`	`196`
`@@ -206,7 +206,7 @@ export class ObjectQL implements IDataEngine {`
`206`	`206`	`for (const item of items) {`
`207`	`207`	`const itemName = item.name \|\| item.id;`
`208`	`208`	`if (itemName) {`
`209`		`- SchemaRegistry.registerItem(key, item, 'name' as any);`
	`209`	`+ SchemaRegistry.registerItem(key, item, 'name' as any, id);`
`210`	`210`	`}`
`211`	`211`	`}`
`212`	`212`	`}`