@objectstack/metadata 2.0.6 → 3.0.0

package/src/metadata.test.ts

@@ -1,7 +1,7 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MetadataManager, type MetadataManagerOptions } from './metadata-manager';
+import { MetadataManager } from './metadata-manager';
 import { MemoryLoader } from './loaders/memory-loader';
 import type { MetadataLoader } from './loaders/loader-interface';
 
@@ -109,7 +109,7 @@ describe('MetadataManager', () => {
 
     it('should throw when no writable loader is available', async () => {
       const readOnlyLoader: MetadataLoader = {
-        contract: { name: 'readonly', protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+        contract: { name: 'readonly', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
         load: vi.fn().mockResolvedValue({ data: null }),
         loadMany: vi.fn().mockResolvedValue([]),
         exists: vi.fn().mockResolvedValue(false),
@@ -148,14 +148,14 @@ describe('MetadataManager', () => {
 
   describe('list', () => {
     it('should return empty array for empty type', async () => {
-      const result = await manager.list('object');
+      const result = await manager.listNames('object');
       expect(result).toEqual([]);
     });
 
     it('should list all items of a type', async () => {
       await memoryLoader.save('object', 'account', {});
       await memoryLoader.save('object', 'contact', {});
-      const result = await manager.list('object');
+      const result = await manager.listNames('object');
       expect(result).toHaveLength(2);
       expect(result).toContain('account');
       expect(result).toContain('contact');
@@ -163,7 +163,7 @@ describe('MetadataManager', () => {
 
     it('should deduplicate across loaders', async () => {
       const loader1: MetadataLoader = {
-        contract: { name: 'l1', protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+        contract: { name: 'l1', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
         load: vi.fn().mockResolvedValue({ data: null }),
         loadMany: vi.fn().mockResolvedValue([]),
         exists: vi.fn().mockResolvedValue(false),
@@ -171,7 +171,7 @@ describe('MetadataManager', () => {
         list: vi.fn().mockResolvedValue(['account', 'contact']),
       };
       const loader2: MetadataLoader = {
-        contract: { name: 'l2', protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+        contract: { name: 'l2', protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
         load: vi.fn().mockResolvedValue({ data: null }),
         loadMany: vi.fn().mockResolvedValue([]),
         exists: vi.fn().mockResolvedValue(false),
@@ -180,7 +180,7 @@ describe('MetadataManager', () => {
       };
 
       const m = new MetadataManager({ formats: ['json'], loaders: [loader1, loader2] });
-      const result = await m.list('object');
+      const result = await m.listNames('object');
       expect(result).toHaveLength(3);
       expect(result).toContain('account');
       expect(result).toContain('contact');
@@ -191,7 +191,7 @@ describe('MetadataManager', () => {
   describe('watch / unwatch', () => {
     it('should register and invoke watch callbacks', () => {
       const callback = vi.fn();
-      manager.watch('object', callback);
+      (manager as any).addWatchCallback('object', callback);
 
       // Trigger via protected method — cast to access it
       (manager as any).notifyWatchers('object', {
@@ -207,8 +207,8 @@ describe('MetadataManager', () => {
 
     it('should unwatch callback', () => {
       const callback = vi.fn();
-      manager.watch('object', callback);
-      manager.unwatch('object', callback);
+      (manager as any).addWatchCallback('object', callback);
+      (manager as any).removeWatchCallback('object', callback);
 
       (manager as any).notifyWatchers('object', {
         type: 'changed',
@@ -222,7 +222,7 @@ describe('MetadataManager', () => {
     });
 
     it('should not throw when unwatching non-existent callback', () => {
-      expect(() => manager.unwatch('object', vi.fn())).not.toThrow();
+      expect(() => (manager as any).removeWatchCallback('object', vi.fn())).not.toThrow();
     });
   });
 
@@ -269,7 +269,7 @@ describe('MemoryLoader', () => {
 
   it('should have correct contract', () => {
     expect(loader.contract.name).toBe('memory');
-    expect(loader.contract.protocol).toBe('memory');
+    expect(loader.contract.protocol).toBe('memory:');
     expect(loader.contract.capabilities.read).toBe(true);
     expect(loader.contract.capabilities.write).toBe(true);
   });
@@ -339,24 +339,22 @@ describe('MetadataPlugin', () => {
       loadMany = vi.fn().mockResolvedValue([]);
       registerLoader = vi.fn();
       stopWatching = vi.fn();
+      setTypeRegistry = vi.fn();
+      register = vi.fn();
     };
     return { NodeMetadataManager: MockNodeMetadataManager };
   });
 
-  // Mock the spec import
-  vi.mock('@objectstack/spec', () => ({
-    ObjectStackDefinitionSchema: {
-      shape: {
-        manifest: {},
-        objects: {},
-        apps: {},
-        views: {},
-      },
-    },
+  // Mock the spec kernel import
+  vi.mock('@objectstack/spec/kernel', () => ({
+    DEFAULT_METADATA_TYPE_REGISTRY: [
+      { type: 'object', label: 'Object', filePatterns: ['**/*.object.ts'], supportsOverlay: true, allowRuntimeCreate: false, supportsVersioning: true, loadOrder: 10, domain: 'data' },
+      { type: 'view', label: 'View', filePatterns: ['**/*.view.ts'], supportsOverlay: true, allowRuntimeCreate: true, supportsVersioning: false, loadOrder: 50, domain: 'ui' },
+    ],
   }));
 
   it('should have correct plugin metadata', async () => {
-    const { MetadataPlugin } = await import('./plugin');
+    const { MetadataPlugin } = await import('./plugin.js');
     const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
     expect(plugin.name).toBe('com.objectstack.metadata');
     expect(plugin.version).toBe('1.0.0');
@@ -364,7 +362,7 @@ describe('MetadataPlugin', () => {
   });
 
   it('should call init and register metadata service', async () => {
-    const { MetadataPlugin } = await import('./plugin');
+    const { MetadataPlugin } = await import('./plugin.js');
     const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
 
     const ctx = createMockPluginContext();
@@ -374,7 +372,7 @@ describe('MetadataPlugin', () => {
   });
 
   it('should call start and attempt to load metadata types', async () => {
-    const { MetadataPlugin } = await import('./plugin');
+    const { MetadataPlugin } = await import('./plugin.js');
     const plugin = new MetadataPlugin({ rootDir: '/tmp/test', watch: false });
 
     const ctx = createMockPluginContext();
@@ -390,7 +388,7 @@ describe('MetadataPlugin', () => {
 
 function createMockLoader(name: string, data: any, shouldFail = false): MetadataLoader {
   return {
-    contract: { name, protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+    contract: { name, protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
     load: shouldFail
       ? vi.fn().mockRejectedValue(new Error('loader failed'))
       : vi.fn().mockResolvedValue({ data }),
@@ -403,7 +401,7 @@ function createMockLoader(name: string, data: any, shouldFail = false): Metadata
 
 function createMockLoaderMany(name: string, items: any[], shouldFail = false): MetadataLoader {
   return {
-    contract: { name, protocol: 'test', capabilities: { read: true, write: false, watch: false, list: true } },
+    contract: { name, protocol: 'memory:' as const, capabilities: { read: true, write: false, watch: false, list: true } },
     load: vi.fn().mockResolvedValue({ data: null }),
     loadMany: shouldFail
       ? vi.fn().mockRejectedValue(new Error('loader failed'))
@@ -417,6 +415,7 @@ function createMockLoaderMany(name: string, items: any[], shouldFail = false): M
 function createMockPluginContext() {
   return {
     registerService: vi.fn(),
+    replaceService: vi.fn(),
     getService: vi.fn().mockReturnValue(null),
     getServices: vi.fn().mockReturnValue(new Map()),
     hook: vi.fn(),

package/src/node-metadata-manager.ts

@@ -118,7 +118,7 @@ export class NodeMetadataManager extends MetadataManager {
       name,
       path: filePath,
       data,
-      timestamp: new Date(),
+      timestamp: new Date().toISOString(),
     };
 
     this.notifyWatchers(type, event);

package/src/plugin.ts

@@ -2,11 +2,13 @@
 
 import { Plugin, PluginContext } from '@objectstack/core';
 import { NodeMetadataManager } from './node-metadata-manager.js';
-import { ObjectStackDefinitionSchema } from '@objectstack/spec';
+import { DEFAULT_METADATA_TYPE_REGISTRY } from '@objectstack/spec/kernel';
+import type { MetadataPluginConfig } from '@objectstack/spec/kernel';
 
 export interface MetadataPluginOptions {
     rootDir?: string;
     watch?: boolean;
+    config?: Partial<MetadataPluginConfig>;
 }
 
 export class MetadataPlugin implements Plugin {
@@ -30,6 +32,9 @@ export class MetadataPlugin implements Plugin {
             watch: this.options.watch ?? true,
             formats: ['yaml', 'json', 'typescript', 'javascript'] 
         });
+
+        // Initialize with default type registry
+        this.manager.setTypeRegistry(DEFAULT_METADATA_TYPE_REGISTRY);
     }
 
     init = async (ctx: PluginContext) => {
@@ -43,39 +48,43 @@ export class MetadataPlugin implements Plugin {
         ctx.registerService('metadata', this.manager);
         ctx.logger.info('MetadataPlugin providing metadata service (primary mode)', {
             mode: 'file-system',
-            features: ['watch', 'persistence', 'multi-format']
+            features: ['watch', 'persistence', 'multi-format', 'query', 'overlay', 'type-registry']
         });
     }
 
     start = async (ctx: PluginContext) => {
         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
+        // Use the type registry to discover metadata types (sorted by loadOrder)
+        const sortedTypes = [...DEFAULT_METADATA_TYPE_REGISTRY]
+            .sort((a, b) => a.loadOrder - b.loadOrder);
 
         let totalLoaded = 0;
-        for (const type of metadataTypes) {
+        for (const entry of sortedTypes) {
             try {
-                // Try to load metadata of this type
-                const items = await this.manager.loadMany(type, {
+                const items = await this.manager.loadMany(entry.type, {
                     recursive: true
                 });
 
                 if (items.length > 0) {
-                     ctx.logger.info(`Loaded ${items.length} ${type} from file system`);
-                     totalLoaded += items.length;
+                    // Register loaded items in the in-memory registry
+                    for (const item of items) {
+                        const meta = item as any;
+                        if (meta?.name) {
+                            await this.manager.register(entry.type, meta.name, item);
+                        }
+                    }
+                    ctx.logger.info(`Loaded ${items.length} ${entry.type} from file system`);
+                    totalLoaded += items.length;
                 }
             } catch (e: any) {
-                // Ignore missing directories or errors
-                ctx.logger.debug(`No ${type} metadata found`, { error: e.message });
+                ctx.logger.debug(`No ${entry.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'
+            registeredTypes: sortedTypes.length,
         });
     }
 }

package/vitest.config.ts

@@ -7,6 +7,8 @@ export default defineConfig({
   resolve: {
     alias: {
       '@objectstack/core': path.resolve(__dirname, '../core/src/index.ts'),
+      '@objectstack/spec/contracts': path.resolve(__dirname, '../spec/src/contracts/index.ts'),
+      '@objectstack/spec/kernel': path.resolve(__dirname, '../spec/src/kernel/index.ts'),
       '@objectstack/spec/system': path.resolve(__dirname, '../spec/src/system/index.ts'),
       '@objectstack/spec': path.resolve(__dirname, '../spec/src/index.ts'),
       '@objectstack/types': path.resolve(__dirname, '../types/src/index.ts'),