@objectstack/objectql 4.0.2 → 4.0.3

package/src/protocol.ts

@@ -2,15 +2,16 @@
 
 import { ObjectStackProtocol } from '@objectstack/spec/api';
 import { IDataEngine } from '@objectstack/core';
-import type { 
-    BatchUpdateRequest, 
-    BatchUpdateResponse, 
+import type {
+    BatchUpdateRequest,
+    BatchUpdateResponse,
     UpdateManyDataRequest,
     DeleteManyDataRequest
 } from '@objectstack/spec/api';
 import type { MetadataCacheRequest, MetadataCacheResponse, ServiceInfo, ApiRoutes, WellKnownCapabilities } from '@objectstack/spec/api';
 import type { IFeedService } from '@objectstack/spec/contracts';
 import { parseFilterAST, isFilterAST } from '@objectstack/spec/data';
+import { PLURAL_TO_SINGULAR, SINGULAR_TO_PLURAL } from '@objectstack/spec/shared';
 
 // We import SchemaRegistry directly since this class lives in the same package
 import { SchemaRegistry } from './registry.js';
@@ -180,18 +181,31 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
     }
 
     async getMetaTypes() {
-        return {
-            types: SchemaRegistry.getRegisteredTypes()
-        };
+        const schemaTypes = SchemaRegistry.getRegisteredTypes();
+
+        // Also include types from MetadataService (runtime-registered: agent, tool, etc.)
+        let runtimeTypes: string[] = [];
+        try {
+            const services = this.getServicesRegistry?.();
+            const metadataService = services?.get('metadata');
+            if (metadataService && typeof metadataService.getRegisteredTypes === 'function') {
+                runtimeTypes = await metadataService.getRegisteredTypes();
+            }
+        } catch {
+            // MetadataService not available
+        }
+
+        const allTypes = Array.from(new Set([...schemaTypes, ...runtimeTypes]));
+        return { types: allTypes };
     }
 
     async getMetaItems(request: { type: string; packageId?: string }) {
         const { packageId } = request;
         let items = SchemaRegistry.listItems(request.type, packageId);
-        // Normalize singular/plural: REST uses singular ('app') but registry may store as plural ('apps')
+        // Normalize singular/plural using explicit mapping
         if (items.length === 0) {
-            const alt = request.type.endsWith('s') ? request.type.slice(0, -1) : request.type + 's';
-            items = SchemaRegistry.listItems(alt, packageId);
+            const alt = PLURAL_TO_SINGULAR[request.type] ?? SINGULAR_TO_PLURAL[request.type];
+            if (alt) items = SchemaRegistry.listItems(alt, packageId);
         }
 
         // Fallback to database if registry is empty for this type
@@ -212,8 +226,9 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                         return data;
                     });
                 } else {
-                    // Try alternate type name in DB
-                    const alt = request.type.endsWith('s') ? request.type.slice(0, -1) : request.type + 's';
+                    // Try alternate type name in DB using explicit mapping
+                    const alt = PLURAL_TO_SINGULAR[request.type] ?? SINGULAR_TO_PLURAL[request.type];
+                    if (alt) {
                     const altRecords = await this.engine.find('sys_metadata', {
                         where: { type: alt, state: 'active' }
                     });
@@ -226,12 +241,41 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                             return data;
                         });
                     }
+                    }
                 }
             } catch {
                 // DB not available, return registry results (empty)
             }
         }
 
+        // Merge with MetadataService (runtime-registered items: agents, tools, etc.)
+        try {
+            const services = this.getServicesRegistry?.();
+            const metadataService = services?.get('metadata');
+            if (metadataService && typeof metadataService.list === 'function') {
+                const runtimeItems = await metadataService.list(request.type);
+                if (runtimeItems && runtimeItems.length > 0) {
+                    // Merge, avoiding duplicates by name
+                    const itemMap = new Map<string, any>();
+                    for (const item of items) {
+                        const entry = item as any;
+                        if (entry && typeof entry === 'object' && 'name' in entry) {
+                            itemMap.set(entry.name, entry);
+                        }
+                    }
+                    for (const item of runtimeItems) {
+                        const entry = item as any;
+                        if (entry && typeof entry === 'object' && 'name' in entry) {
+                            itemMap.set(entry.name, entry);
+                        }
+                    }
+                    items = Array.from(itemMap.values());
+                }
+            }
+        } catch {
+            // MetadataService not available or doesn't support this type
+        }
+
         return {
             type: request.type,
             items
@@ -240,10 +284,10 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
 
     async getMetaItem(request: { type: string, name: string, packageId?: string }) {
         let item = SchemaRegistry.getItem(request.type, request.name);
-        // Normalize singular/plural
+        // Normalize singular/plural using explicit mapping
         if (item === undefined) {
-            const alt = request.type.endsWith('s') ? request.type.slice(0, -1) : request.type + 's';
-            item = SchemaRegistry.getItem(alt, request.name);
+            const alt = PLURAL_TO_SINGULAR[request.type] ?? SINGULAR_TO_PLURAL[request.type];
+            if (alt) item = SchemaRegistry.getItem(alt, request.name);
         }
 
         // Fallback to database if not in registry
@@ -259,8 +303,9 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                     // Hydrate back into registry for next time
                     SchemaRegistry.registerItem(request.type, item, 'name' as any);
                 } else {
-                    // Try alternate type name
-                    const alt = request.type.endsWith('s') ? request.type.slice(0, -1) : request.type + 's';
+                    // Try alternate type name using explicit mapping
+                    const alt = PLURAL_TO_SINGULAR[request.type] ?? SINGULAR_TO_PLURAL[request.type];
+                    if (alt) {
                     const altRecord = await this.engine.findOne('sys_metadata', {
                         where: { type: alt, name: request.name, state: 'active' }
                     });
@@ -271,12 +316,26 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                         // Hydrate back into registry for next time
                         SchemaRegistry.registerItem(request.type, item, 'name' as any);
                     }
+                    }
                 }
             } catch {
                 // DB not available, return undefined
             }
         }
 
+        // Fallback to MetadataService for runtime-registered items (agents, tools, etc.)
+        if (item === undefined) {
+            try {
+                const services = this.getServicesRegistry?.();
+                const metadataService = services?.get('metadata');
+                if (metadataService && typeof metadataService.get === 'function') {
+                    item = await metadataService.get(request.type, request.name);
+                }
+            } catch {
+                // MetadataService not available
+            }
+        }
+
         return {
             type: request.type,
             name: request.name,
@@ -563,7 +622,27 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
 
     async getMetaItemCached(request: { type: string, name: string, cacheRequest?: MetadataCacheRequest }): Promise<MetadataCacheResponse> {
         try {
-            const item = SchemaRegistry.getItem(request.type, request.name);
+            let item = SchemaRegistry.getItem(request.type, request.name);
+
+            // Normalize singular/plural using explicit mapping
+            if (!item) {
+                const alt = PLURAL_TO_SINGULAR[request.type] ?? SINGULAR_TO_PLURAL[request.type];
+                if (alt) item = SchemaRegistry.getItem(alt, request.name);
+            }
+
+            // Fallback to MetadataService (e.g. agents, tools registered in MetadataManager)
+            if (!item) {
+                try {
+                    const services = this.getServicesRegistry?.();
+                    const metadataService = services?.get('metadata');
+                    if (metadataService && typeof metadataService.get === 'function') {
+                        item = await metadataService.get(request.type, request.name);
+                    }
+                } catch {
+                    // MetadataService not available
+                }
+            }
+
             if (!item) {
                 throw new Error(`Metadata item ${request.type}/${request.name} not found`);
             }
@@ -984,10 +1063,12 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                     const data = typeof record.metadata === 'string'
                         ? JSON.parse(record.metadata)
                         : record.metadata;
-                    if (record.type === 'object') {
+                    // Normalize DB type to singular (DB may store legacy plural forms)
+                    const normalizedType = PLURAL_TO_SINGULAR[record.type] ?? record.type;
+                    if (normalizedType === 'object') {
                         SchemaRegistry.registerObject(data as any, record.packageId || 'sys_metadata');
                     } else {
-                        SchemaRegistry.registerItem(record.type, data, 'name' as any);
+                        SchemaRegistry.registerItem(normalizedType, data, 'name' as any);
                     }
                     loaded++;
                 } catch (e) {

package/src/registry.test.ts

@@ -353,17 +353,17 @@ describe('SchemaRegistry', () => {
     describe('Generic Metadata', () => {
         it('should register and retrieve generic items', () => {
             const item = { name: 'test_action', type: 'custom' };
-            SchemaRegistry.registerItem('actions', item, 'name', 'com.pkg');
-            
-            const retrieved = SchemaRegistry.getItem('actions', 'test_action');
+            SchemaRegistry.registerItem('action', item, 'name', 'com.pkg');
+
+            const retrieved = SchemaRegistry.getItem('action', 'test_action');
             expect(retrieved).toEqual(item);
         });
 
         it('should list items by type with package filter', () => {
-            SchemaRegistry.registerItem('actions', { name: 'a1' }, 'name', 'com.pkg1');
-            SchemaRegistry.registerItem('actions', { name: 'a2' }, 'name', 'com.pkg2');
-            
-            const filtered = SchemaRegistry.listItems('actions', 'com.pkg1');
+            SchemaRegistry.registerItem('action', { name: 'a1' }, 'name', 'com.pkg1');
+            SchemaRegistry.registerItem('action', { name: 'a2' }, 'name', 'com.pkg2');
+
+            const filtered = SchemaRegistry.listItems('action', 'com.pkg1');
             expect(filtered).toHaveLength(1);
         });
     });
@@ -396,12 +396,12 @@ describe('SchemaRegistry', () => {
     describe('Reset', () => {
         it('should clear all state', () => {
             SchemaRegistry.registerObject({ name: 'obj', fields: {} } as any, 'com.pkg', 'pkg', 'own');
-            SchemaRegistry.registerItem('actions', { name: 'act' }, 'name');
-            
+            SchemaRegistry.registerItem('action', { name: 'act' }, 'name');
+
             SchemaRegistry.reset();
-            
+
             expect(SchemaRegistry.getAllObjects()).toHaveLength(0);
-            expect(SchemaRegistry.listItems('actions')).toHaveLength(0);
+            expect(SchemaRegistry.listItems('action')).toHaveLength(0);
         });
     });
 

package/src/registry.ts

@@ -485,7 +485,7 @@ export class SchemaRegistry {
     if (type === 'object') {
       return ObjectSchema.parse(item);
     }
-    if (type === 'apps') {
+    if (type === 'app') {
       return AppSchema.parse(item);
     }
     if (type === 'package') {
@@ -664,15 +664,15 @@ export class SchemaRegistry {
   // ==========================================
 
   static registerApp(app: any, packageId?: string) {
-    this.registerItem('apps', app, 'name', packageId);
+    this.registerItem('app', app, 'name', packageId);
   }
 
   static getApp(name: string): any {
-    return this.getItem('apps', name);
+    return this.getItem('app', name);
   }
 
   static getAllApps(): any[] {
-    return this.listItems('apps');
+    return this.listItems('app');
   }
 
   // ==========================================