refactor: Improve metadata service integration between ObjectQL and MetadataPlugin

Copilot · hotlong · Copilot · commit ca105a9e0c09 · 2026-02-10T09:17:19.000Z
Co-authored-by: hotlong &lt;50353452+hotlong@users.noreply.github.com&gt;
diff --git a/packages/metadata/src/plugin.ts b/packages/metadata/src/plugin.ts
@@ -33,21 +33,29 @@ export class MetadataPlugin implements Plugin {
     }
 
     init = async (ctx: PluginContext) => {
-        ctx.logger.info('Initializing Metadata Manager', { root: this.options.rootDir || process.cwd() });
+        ctx.logger.info('Initializing Metadata Manager', { 
+            root: this.options.rootDir || process.cwd(),
+            watch: this.options.watch
+        });
         
-        // Register Metadata Manager as a service
-        // This allows other plugins to query raw metadata or listen to changes
+        // Register Metadata Manager as primary metadata service provider
+        // This takes precedence over ObjectQL's fallback metadata service
         ctx.registerService('metadata', this.manager);
+        ctx.logger.info('MetadataPlugin providing metadata service (primary mode)', {
+            mode: 'file-system',
+            features: ['watch', 'persistence', 'multi-format']
+        });
     }
 
     start = async (ctx: PluginContext) => {
-        ctx.logger.info('Loading metadata...');
+        ctx.logger.info('Loading metadata from file system...');
         
         // Define metadata types directly from the Protocol Definition
         // This ensures the loader is always in sync with the Spec
         const metadataTypes = Object.keys(ObjectStackDefinitionSchema.shape)
             .filter(key => key !== 'manifest'); // Manifest is handled separately
 
+        let totalLoaded = 0;
         for (const type of metadataTypes) {
             try {
                 // Try to load metadata of this type
@@ -56,37 +64,18 @@ export class MetadataPlugin implements Plugin {
                 });
 
                 if (items.length > 0) {
-                     ctx.logger.info(`Loaded ${items.length} ${type}`);
-                     
-                     // Helper: Register with ObjectQL Registry
-                     const ql = ctx.getService('objectql') as any;
-                     if (ql && ql.registry) {
-                        items.forEach((item: any) => {
-                            // Determine key field (id or name)
-                            const keyField = item.id ? 'id' : 'name';
-                            
-                            // Map plural type to singular/registry type if needed
-                            // For now, we use the singular form for standard types: 
-                            // objects -> object, apps -> app, etc.
-                            // But Registry seems to accept arbitrary strings.
-                            // To match Protocol standard, we might want to normalize.
-                            // Let's use the directory name (plural) as the type for now,
-                            // OR map 'objects' -> 'object' specifically.
-                            
-                            let registryType = type;
-                            if (type === 'objects') registryType = 'object';
-                            if (type === 'apps') registryType = 'app';
-                            if (type === 'plugins') registryType = 'plugin';
-                            if (type === 'functions') registryType = 'function';
-                            
-                            ql.registry.registerItem(registryType, item, keyField);
-                        });
-                     }
+                     ctx.logger.info(`Loaded ${items.length} ${type} from file system`);
+                     totalLoaded += items.length;
                 }
             } catch (e: any) {
                 // Ignore missing directories or errors
-                // ctx.logger.debug(`No metadata found for type: ${type}`);
+                ctx.logger.debug(`No ${type} metadata found`, { error: e.message });
             }
         }
+        
+        ctx.logger.info('Metadata loading complete', { 
+            totalItems: totalLoaded,
+            note: 'ObjectQL will sync these into its registry during its start phase'
+        });
     }
 }
diff --git a/packages/objectql/src/plugin.integration.test.ts b/packages/objectql/src/plugin.integration.test.ts
@@ -0,0 +1,241 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ObjectKernel } from '@objectstack/core';
+import { ObjectQLPlugin } from '../src/plugin';
+import { ObjectSchema } from '@objectstack/spec/data';
+
+describe('ObjectQLPlugin - Metadata Service Integration', () => {
+  let kernel: ObjectKernel;
+
+  beforeEach(() => {
+    kernel = new ObjectKernel({ logLevel: 'silent' });
+  });
+
+  describe('Simple Mode (ObjectQL-only)', () => {
+    it('should register ObjectQL as metadata service provider', async () => {
+      // Arrange
+      const plugin = new ObjectQLPlugin();
+      kernel.use(plugin);
+
+      // Act
+      await kernel.bootstrap();
+
+      // Assert
+      const metadataService = kernel.getService('metadata');
+      expect(metadataService).toBeDefined();
+      
+      // Should be the ObjectQL instance
+      const objectql = kernel.getService('objectql');
+      expect(metadataService).toBe(objectql);
+    });
+
+    it('should serve in-memory metadata definitions', async () => {
+      // Arrange
+      const plugin = new ObjectQLPlugin();
+      kernel.use(plugin);
+      await kernel.bootstrap();
+
+      const objectql = kernel.getService('objectql') as any;
+      const testObject: ObjectSchema = {
+        name: 'test_object',
+        label: 'Test Object',
+        fields: {
+          name: {
+            name: 'name',
+            label: 'Name',
+            type: 'text'
+          }
+        }
+      };
+
+      // Act - Register object programmatically
+      objectql.registry.registerObject({
+        packageId: 'test',
+        namespace: 'test',
+        ownership: 'own',
+        object: testObject
+      });
+
+      // Assert - Should be retrievable via registry
+      const objects = objectql.registry.listObjects();
+      expect(objects).toContain('test__test_object');
+    });
+  });
+
+  describe('Service Registration', () => {
+    it('should register objectql, data, and protocol services', async () => {
+      // Arrange
+      const plugin = new ObjectQLPlugin();
+      kernel.use(plugin);
+
+      // Act
+      await kernel.bootstrap();
+
+      // Assert
+      expect(kernel.getService('objectql')).toBeDefined();
+      expect(kernel.getService('data')).toBeDefined();
+      expect(kernel.getService('protocol')).toBeDefined();
+    });
+
+    it('should respect existing metadata service', async () => {
+      // Arrange - Register a mock metadata service first
+      const mockMetadataService = {
+        load: async () => null,
+        loadMany: async () => [],
+        save: async () => ({ success: true }),
+        exists: async () => false,
+        list: async () => []
+      };
+
+      kernel.use({
+        name: 'mock-metadata',
+        type: 'test',
+        version: '1.0.0',
+        init: async (ctx) => {
+          ctx.registerService('metadata', mockMetadataService);
+        }
+      });
+
+      const plugin = new ObjectQLPlugin();
+      kernel.use(plugin);
+
+      // Act
+      await kernel.bootstrap();
+
+      // Assert - metadata service should be the mock, not ObjectQL
+      const metadataService = kernel.getService('metadata');
+      expect(metadataService).toBe(mockMetadataService);
+      
+      const objectql = kernel.getService('objectql');
+      expect(metadataService).not.toBe(objectql);
+    });
+  });
+
+  describe('Driver and App Discovery', () => {
+    it('should discover and register drivers from kernel services', async () => {
+      // Arrange
+      const mockDriver = {
+        name: 'mock-driver',
+        connect: async () => {},
+        disconnect: async () => {},
+        query: async () => ({ rows: [] }),
+        insert: async () => ({ id: '1' }),
+        update: async () => ({ count: 1 }),
+        delete: async () => ({ count: 1 })
+      };
+
+      kernel.use({
+        name: 'mock-driver-plugin',
+        type: 'driver',
+        version: '1.0.0',
+        init: async (ctx) => {
+          ctx.registerService('driver.mock', mockDriver);
+        }
+      });
+
+      const plugin = new ObjectQLPlugin();
+      kernel.use(plugin);
+
+      // Act
+      await kernel.bootstrap();
+
+      // Assert
+      const objectql = kernel.getService('objectql') as any;
+      expect(objectql.drivers?.has('mock-driver')).toBe(true);
+    });
+
+    it('should discover and register apps from kernel services', async () => {
+      // Arrange
+      const mockApp = {
+        manifest: {
+          id: 'test-app',
+          name: 'test_app',
+          version: '1.0.0',
+          type: 'app'
+        }
+      };
+
+      kernel.use({
+        name: 'mock-app-plugin',
+        type: 'app',
+        version: '1.0.0',
+        init: async (ctx) => {
+          ctx.registerService('app.test', mockApp.manifest);
+        }
+      });
+
+      const plugin = new ObjectQLPlugin();
+      kernel.use(plugin);
+
+      // Act
+      await kernel.bootstrap();
+
+      // Assert
+      const objectql = kernel.getService('objectql') as any;
+      // App should be registered (check via registry or apps list)
+      expect(objectql.registry).toBeDefined();
+    });
+  });
+
+  describe('Metadata Sync from External Service', () => {
+    it('should load metadata from external service into ObjectQL registry', async () => {
+      // Arrange - Mock external metadata service with test data
+      const testObject: ObjectSchema = {
+        name: 'external_object',
+        label: 'External Object',
+        fields: {
+          title: {
+            name: 'title',
+            label: 'Title',
+            type: 'text'
+          }
+        }
+      };
+
+      const mockMetadataService = {
+        load: async (type: string, name: string) => {
+          if (type === 'object' && name === 'external_object') {
+            return testObject;
+          }
+          return null;
+        },
+        loadMany: async (type: string) => {
+          if (type === 'object') {
+            return [testObject];
+          }
+          return [];
+        },
+        save: async () => ({ success: true, path: '/test' }),
+        exists: async () => false,
+        list: async () => []
+      };
+
+      // Register mock metadata service BEFORE ObjectQL
+      kernel.use({
+        name: 'mock-metadata',
+        type: 'metadata',
+        version: '1.0.0',
+        init: async (ctx) => {
+          ctx.registerService('metadata', mockMetadataService);
+        }
+      });
+
+      const plugin = new ObjectQLPlugin();
+      kernel.use(plugin);
+
+      // Act
+      await kernel.bootstrap();
+
+      // Assert - Metadata should be synced
+      const metadataService = kernel.getService('metadata');
+      expect(metadataService).toBe(mockMetadataService);
+      
+      const objectql = kernel.getService('objectql') as any;
+      expect(objectql.registry).toBeDefined();
+      
+      // Note: The actual sync happens in start phase
+      // We can verify by checking if ObjectQL detected external service
+    });
+  });
+});
diff --git a/packages/objectql/src/plugin.ts b/packages/objectql/src/plugin.ts
