feat: add in-memory metadata service and update related fallbacks and tests

Author: hotlong

packages/core/src/fallbacks/fallbacks.test.ts

@@ -6,8 +6,8 @@ import { createMemoryI18n, resolveLocale } from './memory-i18n';
 import { CORE_FALLBACK_FACTORIES } from './index';
 
 describe('CORE_FALLBACK_FACTORIES', () => {
-    it('should have exactly 4 entries: cache, queue, job, i18n', () => {
-        expect(Object.keys(CORE_FALLBACK_FACTORIES)).toEqual(['cache', 'queue', 'job', 'i18n']);
+    it('should have exactly 5 entries: metadata, cache, queue, job, i18n', () => {
+        expect(Object.keys(CORE_FALLBACK_FACTORIES)).toEqual(['metadata', 'cache', 'queue', 'job', 'i18n']);
     });
 
     it('should map to factory functions', () => {

packages/core/src/fallbacks/index.ts

@@ -4,18 +4,21 @@ import { createMemoryCache } from './memory-cache.js';
 import { createMemoryQueue } from './memory-queue.js';
 import { createMemoryJob } from './memory-job.js';
 import { createMemoryI18n } from './memory-i18n.js';
+import { createMemoryMetadata } from './memory-metadata.js';
 
 export { createMemoryCache } from './memory-cache.js';
 export { createMemoryQueue } from './memory-queue.js';
 export { createMemoryJob } from './memory-job.js';
 export { createMemoryI18n, resolveLocale } from './memory-i18n.js';
+export { createMemoryMetadata } from './memory-metadata.js';
 
 /**
  * Map of core-criticality service names to their in-memory fallback factories.
  * Used by ObjectKernel.validateSystemRequirements() to auto-inject fallbacks
  * when no real plugin provides the service.
  */
 export const CORE_FALLBACK_FACTORIES: Record<string, () => Record<string, any>> = {
+  metadata: createMemoryMetadata,
   cache: createMemoryCache,
   queue: createMemoryQueue,
   job:   createMemoryJob,

packages/core/src/fallbacks/memory-metadata.ts

@@ -0,0 +1,50 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
+/**
+ * In-memory metadata service fallback.
+ *
+ * Implements the IMetadataService contract with a simple Map-of-Maps store.
+ * Used by ObjectKernel as an automatic fallback when no real metadata plugin
+ * (e.g. MetadataPlugin with file-system persistence) is registered.
+ */
+export function createMemoryMetadata() {
+  // type -> name -> data
+  const store = new Map<string, Map<string, any>>();
+
+  function getTypeMap(type: string): Map<string, any> {
+    let map = store.get(type);
+    if (!map) {
+      map = new Map();
+      store.set(type, map);
+    }
+    return map;
+  }
+
+  return {
+    _fallback: true, _serviceName: 'metadata',
+    async register(type: string, name: string, data: any): Promise<void> {
+      getTypeMap(type).set(name, data);
+    },
+    async get(type: string, name: string): Promise<any> {
+      return getTypeMap(type).get(name);
+    },
+    async list(type: string): Promise<any[]> {
+      return Array.from(getTypeMap(type).values());
+    },
+    async unregister(type: string, name: string): Promise<void> {
+      getTypeMap(type).delete(name);
+    },
+    async exists(type: string, name: string): Promise<boolean> {
+      return getTypeMap(type).has(name);
+    },
+    async listNames(type: string): Promise<string[]> {
+      return Array.from(getTypeMap(type).keys());
+    },
+    async getObject(name: string): Promise<any> {
+      return getTypeMap('object').get(name);
+    },
+    async listObjects(): Promise<any[]> {
+      return Array.from(getTypeMap('object').values());
+    },
+  };
+}

packages/metadata/src/plugin.ts

@@ -44,8 +44,7 @@ export class MetadataPlugin implements Plugin {
             watch: this.options.watch
         });
 
-        // Register Metadata Manager as primary metadata service provider
-        // This takes precedence over ObjectQL's fallback metadata service
+        // Register Metadata Manager as the primary metadata service provider.
         ctx.registerService('metadata', this.manager);
 
         // Register metadata system objects via the manifest service (if available).

packages/objectql/src/plugin.integration.test.ts

@@ -15,24 +15,23 @@ describe('ObjectQLPlugin - Metadata Service Integration', () => {
   });
 
   describe('Simple Mode (ObjectQL-only)', () => {
-    it('should register ObjectQL as metadata service provider', async () => {
+    it('should register objectql, data, and protocol services', async () => {
       // Arrange
       const plugin = new ObjectQLPlugin();
       await kernel.use(plugin);
 
       // Act
       await kernel.bootstrap();
 
-      // Assert
-      const metadataService = kernel.getService('metadata');
-      expect(metadataService).toBeDefined();
-
-      // ObjectQL registers a MetadataFacade as the metadata service;
-      // it is separate from (but backed by the same registry as) the objectql service.
+      // Assert — ObjectQL no longer registers metadata (kernel provides fallback)
       const objectql = kernel.getService('objectql');
       expect(objectql).toBeDefined();
-      // metadata and objectql are distinct service instances
-      expect(metadataService).not.toBe(objectql);
+      expect(kernel.getService('data')).toBeDefined();
+      expect(kernel.getService('protocol')).toBeDefined();
+      // metadata is provided by kernel's core fallback, not ObjectQL
+      const metadataService = kernel.getService('metadata');
+      expect(metadataService).toBeDefined();
+      expect((metadataService as any)._fallback).toBe(true);
     });
 
     it('should serve in-memory metadata definitions', async () => {

packages/objectql/src/plugin.ts

@@ -1,7 +1,6 @@
 // Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
 
 import { ObjectQL } from './engine.js';
-import { MetadataFacade } from './metadata-facade.js';
 import { ObjectStackProtocolImplementation } from './protocol.js';
 import { Plugin, PluginContext } from '@objectstack/core';
 
@@ -33,40 +32,7 @@ export class ObjectQLPlugin implements Plugin {
 
     // Register as provider for Core Kernel Services
     ctx.registerService('objectql', this.ql);
-    
-    // Register MetadataFacade as metadata service (unless external service exists)
-    let hasMetadata = false;
-    let metadataProvider = 'objectql';
-    try {
-        if (ctx.getService('metadata')) {
-            hasMetadata = true;
-            metadataProvider = 'external';
-        }
-    } catch (e: any) {
-        // Ignore errors during check (e.g. "Service is async")
-    }
 
-    if (!hasMetadata) {
-        try {
-            const metadataFacade = new MetadataFacade();
-            ctx.registerService('metadata', metadataFacade);
-            ctx.logger.info('MetadataFacade registered as metadata service', {
-                mode: 'in-memory',
-                features: ['registry', 'fast-lookup']
-            });
-        } catch (e: any) {
-             // Ignore if already registered (race condition or async mis-detection)
-             if (!e.message?.includes('already registered')) {
-                 throw e;
-             }
-        }
-    } else {
-        ctx.logger.info('External metadata service detected', {
-            provider: metadataProvider,
-            mode: 'will-sync-in-start-phase'
-        });
-    }
-    
     ctx.registerService('data', this.ql); // ObjectQL implements IDataEngine
 
     // Register manifest service for direct app/package registration.
@@ -84,7 +50,6 @@ export class ObjectQLPlugin implements Plugin {
 
     ctx.logger.info('ObjectQL engine registered', {
         services: ['objectql', 'data', 'manifest'],
-        metadataProvider: metadataProvider
     });
 
     // Register Protocol Implementation
@@ -99,16 +64,14 @@ export class ObjectQLPlugin implements Plugin {
 
   start = async (ctx: PluginContext) => {
     ctx.logger.info('ObjectQL engine starting...');
-    
-    // Check if we should load from external metadata service
+
+    // Sync from external metadata service (e.g. MetadataPlugin) if available
     try {
         const metadataService = ctx.getService('metadata') as any;
-        // Only sync if metadata service is external (not our own MetadataFacade)
-        if (metadataService && !(metadataService instanceof MetadataFacade) && this.ql) {
+        if (metadataService && typeof metadataService.loadMany === 'function' && this.ql) {
             await this.loadMetadataFromService(metadataService, ctx);
         }
     } catch (e: any) {
-        // No external metadata service or error accessing it
         ctx.logger.debug('No external metadata service to sync from');
     }
 

packages/spec/src/system/core-services.test.ts

@@ -46,8 +46,8 @@ describe('ServiceCriticalitySchema', () => {
 
 describe('ServiceRequirementDef', () => {
   it('should define required services', () => {
-    expect(ServiceRequirementDef.metadata).toBe('required');
     expect(ServiceRequirementDef.data).toBe('required');
+    expect(ServiceRequirementDef.metadata).toBe('core');
     expect(ServiceRequirementDef.auth).toBe('core');
   });
 

packages/spec/src/system/core-services.zod.ts

@@ -58,10 +58,10 @@ export const ServiceCriticalitySchema = z.enum([
  */
 export const ServiceRequirementDef = {
   // Required: The kernel cannot function without these
-  metadata: 'required',
   data: 'required',
 
   // Core: Highly recommended, defaults to in-memory / no-op if missing
+  metadata: 'core',
   auth: 'core',
 
   // Core: Highly recommended, defaults to in-memory / no-op if missing