feat: Implement SchemaRegistry with static singleton pattern

Co-authored-by: hotlong <50353452+hotlong@users.noreply.github.com>

Author: Copilot

packages/foundation/objectql/src/index.ts

@@ -18,55 +18,123 @@ export interface ObjectConfig {
 
 /**
  * Schema Registry - manages object schemas
+ * Uses a singleton pattern with static methods for global access
  */
 export class SchemaRegistry {
-    private schemas = new Map<string, ObjectConfig>();
+    private static instance: SchemaRegistry;
+    private schemas = new Map<string, Map<string, any>>();
 
+    private constructor() {}
+    
+    private static getInstance(): SchemaRegistry {
+        if (!SchemaRegistry.instance) {
+            SchemaRegistry.instance = new SchemaRegistry();
+        }
+        return SchemaRegistry.instance;
+    }
+    
+    /**
+     * Register an item in the registry
+     * @param type - The type of item (e.g., 'object', 'field', 'action')
+     * @param item - The item to register
+     * @param idField - The field to use as the ID (default: 'name')
+     */
+    static registerItem(type: string, item: any, idField: string = 'name'): void {
+        const registry = SchemaRegistry.getInstance();
+        if (!registry.schemas.has(type)) {
+            registry.schemas.set(type, new Map());
+        }
+        const typeMap = registry.schemas.get(type)!;
+        const id = item[idField];
+        typeMap.set(id, item);
+    }
+    
+    /**
+     * Get an item from the registry
+     */
+    static getItem(type: string, id: string): any | undefined {
+        const registry = SchemaRegistry.getInstance();
+        const typeMap = registry.schemas.get(type);
+        return typeMap?.get(id);
+    }
+    
+    /**
+     * List all items of a type
+     */
+    static listItems(type: string): any[] {
+        const registry = SchemaRegistry.getInstance();
+        const typeMap = registry.schemas.get(type);
+        if (!typeMap) return [];
+        return Array.from(typeMap.values());
+    }
+    
+    /**
+     * Check if an item exists
+     */
+    static hasItem(type: string, id: string): boolean {
+        const registry = SchemaRegistry.getInstance();
+        const typeMap = registry.schemas.get(type);
+        return typeMap?.has(id) || false;
+    }
+    
+    /**
+     * Delete an item
+     */
+    static deleteItem(type: string, id: string): boolean {
+        const registry = SchemaRegistry.getInstance();
+        const typeMap = registry.schemas.get(type);
+        if (!typeMap) return false;
+        return typeMap.delete(id);
+    }
+    
+    /**
+     * Clear all items
+     */
+    static clear(): void {
+        const registry = SchemaRegistry.getInstance();
+        registry.schemas.clear();
+    }
+    
+    // Instance methods for backward compatibility
     register(name: string, schema: ObjectConfig): void {
-        this.schemas.set(name, schema);
+        SchemaRegistry.registerItem('object', schema, 'name');
     }
 
     get(name: string): ObjectConfig | undefined {
-        return this.schemas.get(name);
+        return SchemaRegistry.getItem('object', name);
     }
 
     list(): ObjectConfig[] {
-        return Array.from(this.schemas.values());
+        return SchemaRegistry.listItems('object');
     }
 
     has(name: string): boolean {
-        return this.schemas.has(name);
+        return SchemaRegistry.hasItem('object', name);
     }
 
     delete(name: string): boolean {
-        return this.schemas.delete(name);
-    }
-    
-    clear(): void {
-        this.schemas.clear();
+        return SchemaRegistry.deleteItem('object', name);
     }
 }
 
 /**
  * ObjectQL Engine - runtime query engine
  */
 export class ObjectQL {
-    private schemaRegistry: SchemaRegistry;
-    
     constructor() {
-        this.schemaRegistry = new SchemaRegistry();
+        // Use the singleton SchemaRegistry
     }
 
-    getSchemaRegistry(): SchemaRegistry {
-        return this.schemaRegistry;
+    getSchemaRegistry(): typeof SchemaRegistry {
+        return SchemaRegistry;
     }
 
     registerSchema(name: string, schema: ObjectConfig): void {
-        this.schemaRegistry.register(name, schema);
+        SchemaRegistry.registerItem('object', schema, 'name');
     }
 
     getSchema(name: string): ObjectConfig | undefined {
-        return this.schemaRegistry.get(name);
+        return SchemaRegistry.getItem('object', name);
     }
 }
 

packages/foundation/objectstack-core/src/index.ts

@@ -11,6 +11,7 @@ export {
     ObjectKernel, 
     ObjectStackKernel,
     type Plugin,
+    type RuntimeContext as PluginContext,
     type RuntimeContext,
     type RuntimeAppConfig,
     type RuntimeDriver,

packages/foundation/types/tsconfig.json

@@ -1,8 +1,17 @@
 {
-  "extends": "../../../tsconfig.base.json",
   "compilerOptions": {
+    "target": "ES2019",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "declaration": true,
+    "declarationMap": true,
+    "composite": true,
     "outDir": "./dist",
-    "rootDir": "./src"
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
   },
   "include": ["src/**/*"],
   "references": []