feat: 重构元数据 API，支持按类型列出项目并获取单个项目

Author: hotlong

examples/server/src/index.ts

@@ -21,50 +21,59 @@ console.log('--- Plugins Loaded ---');
 // 3. Define Unified Routes
 
 /**
- * Metadata API: Get All Objects
+ * Unified Metadata API: List Items by Type
+ * GET /api/v1/meta/objects
+ * GET /api/v1/meta/apps
  */
-app.get('/api/v1/meta/objects', (c) => {
-  const objects = SchemaRegistry.getAll().map(obj => ({
-    name: obj.name,
-    label: obj.label,
-    icon: obj.icon,
-    path: `/api/v1/data/${obj.name}`
+app.get('/api/v1/meta/:type', (c) => {
+  const typePlural = c.req.param('type');
+  
+  // Simple singularization mapping (can be enhanced)
+  const typeMap: Record<string, string> = {
+    'objects': 'object',
+    'apps': 'app',
+    'flows': 'flow',
+    'reports': 'report'
+  };
+  const type = typeMap[typePlural] || typePlural;
+  
+  const items = SchemaRegistry.listItems(type);
+  
+  // Optional: Summary transformation based on type
+  const summaries = items.map((item: any) => ({
+    name: item.name,
+    label: item.label,
+    icon: item.icon,
+    description: item.description,
+    // Add dynamic links
+    ...(type === 'object' ? { path: `/api/v1/data/${item.name}` } : {}),
+    self: `/api/v1/meta/${typePlural}/${item.name}`
   }));
-  return c.json({ data: objects });
-});
 
-/**
- * Metadata API: Get Single Object
- */
-app.get('/api/v1/meta/objects/:name', (c) => {
-  const name = c.req.param('name');
-  const schema = SchemaRegistry.get(name);
-  if (!schema) return c.json({ error: 'Not found' }, 404);
-  return c.json(schema);
+  return c.json({ data: summaries });
 });
 
 /**
- * Metadata API: Get All Apps
+ * Unified Metadata API: Get Single Item
+ * GET /api/v1/meta/objects/account
+ * GET /api/v1/meta/apps/crm
  */
-app.get('/api/v1/meta/apps', (c) => {
-  const apps = SchemaRegistry.getAllApps().map(app => ({
-    name: app.name,
-    label: app.label,
-    icon: app.icon,
-    description: app.description,
-    path: `/api/v1/meta/apps/${app.name}`
-  }));
-  return c.json({ data: apps });
-});
-
-/**
- * Metadata API: Get Single App
- */
-app.get('/api/v1/meta/apps/:name', (c) => {
+app.get('/api/v1/meta/:type/:name', (c) => {
+  const typePlural = c.req.param('type');
   const name = c.req.param('name');
-  const app = SchemaRegistry.getApp(name);
-  if (!app) return c.json({ error: 'Not found' }, 404);
-  return c.json(app);
+  
+  const typeMap: Record<string, string> = {
+    'objects': 'object',
+    'apps': 'app',
+    'flows': 'flow',
+    'reports': 'report'
+  };
+  const type = typeMap[typePlural] || typePlural;
+
+  const item = SchemaRegistry.getItem(type, name);
+  if (!item) return c.json({ error: `Metadata not found: ${type}/${name}` }, 404);
+  
+  return c.json(item);
 });
 
 /**
@@ -144,7 +153,7 @@ app.delete('/api/v1/data/:object/:id', async (c) => {
 });
 
 // 4. Start Server
-const port = 3003;
+const port = 3004;
 console.log(`Server is running on http://localhost:${port}`);
 
 serve({

examples/server/src/kernel/engine.ts

@@ -65,7 +65,7 @@ export class DataEngine {
   }
 
   private ensureSchema(name: string): ServiceObject {
-    const schema = SchemaRegistry.get(name);
+    const schema = SchemaRegistry.getObject(name);
     if (!schema) throw new Error(`Unknown object: ${name}`);
     return schema;
   }

examples/server/src/kernel/registry.ts

@@ -2,46 +2,73 @@ import { ServiceObject, App } from '@objectstack/spec';
 
 /**
  * Global Schema Registry
+ * Unified storage for all metadata types (Objects, Apps, Flows, Layouts, etc.)
  */
 export class SchemaRegistry {
-  private static objects = new Map<string, ServiceObject>();
-  private static apps = new Map<string, App>();
+  // Nested Map: Type -> Name -> MetadataItem
+  private static metadata = new Map<string, Map<string, any>>();
 
   /**
-   * Register a new object schema
+   * Universal Register Method
    */
-  static register(schema: ServiceObject) {
-    if (this.objects.has(schema.name)) {
-      console.warn(`[Registry] Overwriting object: ${schema.name}`);
+  static registerItem<T extends { name: string }>(type: string, item: T) {
+    if (!this.metadata.has(type)) {
+      this.metadata.set(type, new Map());
     }
-    this.objects.set(schema.name, schema);
-    console.log(`[Registry] Registered object: ${schema.name}`);
+    const collection = this.metadata.get(type)!;
+
+    if (collection.has(item.name)) {
+      console.warn(`[Registry] Overwriting ${type}: ${item.name}`);
+    }
+    collection.set(item.name, item);
+    console.log(`[Registry] Registered ${type}: ${item.name}`);
+  }
+
+  /**
+   * Universal Get Method
+   */
+  static getItem<T>(type: string, name: string): T | undefined {
+    return this.metadata.get(type)?.get(name) as T;
+  }
+
+  /**
+   * Universal List Method
+   */
+  static listItems<T>(type: string): T[] {
+    return Array.from(this.metadata.get(type)?.values() || []) as T[];
+  }
+
+  // ==========================================
+  // Typed Helper Methods (Shortcuts)
+  // ==========================================
+
+  /**
+   * Object Helpers
+   */
+  static registerObject(schema: ServiceObject) {
+    this.registerItem('object', schema);
   }
 
-  static get(name: string): ServiceObject | undefined {
-    return this.objects.get(name);
+  static getObject(name: string): ServiceObject | undefined {
+    return this.getItem<ServiceObject>('object', name);
   }
 
-  static getAll(): ServiceObject[] {
-    return Array.from(this.objects.values());
+  static getAllObjects(): ServiceObject[] {
+    return this.listItems<ServiceObject>('object');
   }
 
   /**
-   * Register a new app schema
+   * App Helpers
    */
   static registerApp(app: App) {
-    if (this.apps.has(app.name)) {
-      console.warn(`[Registry] Overwriting app: ${app.name}`);
-    }
-    this.apps.set(app.name, app);
-    console.log(`[Registry] Registered app: ${app.name}`);
+    this.registerItem('app', app);
   }
 
   static getApp(name: string): App | undefined {
-    return this.apps.get(name);
+    return this.getItem<App>('app', name);
   }
 
   static getAllApps(): App[] {
-    return Array.from(this.apps.values());
+    return this.listItems<App>('app');
   }
 }

examples/server/src/loader.ts

@@ -23,7 +23,7 @@ export function loadPlugins() {
     // 1. Register Objects
     if (app.objects) {
       app.objects.forEach((obj: any) => {
-         SchemaRegistry.register(obj);
+         SchemaRegistry.registerObject(obj);
       });
     }