@objectstack/core 4.0.1 → 4.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectstack/core",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "license": "Apache-2.0",
   "description": "Microkernel Core for ObjectStack",
   "type": "module",
@@ -14,15 +14,15 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^25.5.0",
+    "@types/node": "^25.6.0",
     "typescript": "^6.0.2",
-    "vitest": "^4.1.2"
+    "vitest": "^4.1.4"
   },
   "dependencies": {
     "pino": "^10.3.1",
     "pino-pretty": "^13.1.3",
     "zod": "^4.3.6",
-    "@objectstack/spec": "4.0.1"
+    "@objectstack/spec": "4.0.3"
   },
   "peerDependencies": {
     "pino": "^8.0.0"

package/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', () => {

package/src/fallbacks/index.ts

@@ -4,11 +4,13 @@ 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.
@@ -16,6 +18,7 @@ export { createMemoryI18n, resolveLocale } from './memory-i18n.js';
  * 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,

package/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());
+    },
+  };
+}

package/src/kernel.ts

@@ -213,6 +213,28 @@ export class ObjectKernel {
         return this;
     }
 
+    /**
+     * Pre-inject in-memory fallbacks for 'core' services that were not registered
+     * by plugins during Phase 1. Called before Phase 2 so that all core services
+     * (e.g. 'metadata', 'cache', 'queue') are resolvable via ctx.getService()
+     * when plugin start() methods execute.
+     */
+    private preInjectCoreFallbacks() {
+        if (this.config.skipSystemValidation) return;
+        for (const [serviceName, criticality] of Object.entries(ServiceRequirementDef)) {
+            if (criticality !== 'core') continue;
+            const hasService = this.services.has(serviceName) || this.pluginLoader.hasService(serviceName);
+            if (!hasService) {
+                const factory = CORE_FALLBACK_FACTORIES[serviceName];
+                if (factory) {
+                    const fallback = factory();
+                    this.registerService(serviceName, fallback);
+                    this.logger.debug(`[Kernel] Pre-injected in-memory fallback for '${serviceName}' before Phase 2`);
+                }
+            }
+        }
+    }
+
     /**
      * Validate Critical System Requirements
      */
@@ -291,6 +313,12 @@ export class ObjectKernel {
                 await this.initPluginWithTimeout(plugin);
             }
 
+            // Pre-inject in-memory fallbacks for 'core' services that were not
+            // registered by any plugin during Phase 1. This ensures services like
+            // 'metadata', 'cache', 'queue', etc. are always available when plugins
+            // call ctx.getService() during their start() methods.
+            this.preInjectCoreFallbacks();
+
             // Phase 2: Start - Plugins execute business logic
             this.logger.info('Phase 2: Start plugins');
             this.state = 'running';