feat: 添加商业智能插件，支持数据集定义和查询功能，扩展插件架构

Author: hotlong

examples/plugin-bi/objectstack.config.ts

@@ -0,0 +1,35 @@
+import { ManifestSchema, ObjectStackManifest } from '@objectstack/spec';
+
+const BiPlugin: ObjectStackManifest = {
+  id: 'com.objectstack.bi',
+  name: 'Business Intelligence Plugin',
+  version: '1.0.0',
+  type: 'plugin',
+  description: 'Provides BI capabilities, dataset definitions, and chart rendering.',
+  
+  // Register Capabilities
+  contributes: {
+    kinds: [
+      {
+        id: 'bi.dataset',
+        globs: ['**/*.dataset.json', '**/*.dataset.ts'],
+        description: 'BI Dataset Definition'
+      },
+      {
+        id: 'bi.dashboard',
+        globs: ['**/*.bi-dash.json'],
+        description: 'Advanced BI Dashboard'
+      }
+    ]
+  },
+
+  // Lifecycle Entry Point
+  // in a real scenario, this would be a path or module name
+  extensions: {
+    runtime: {
+      entry: './src/index.ts'
+    }
+  }
+};
+
+export default BiPlugin;

examples/plugin-bi/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@objectstack/plugin-bi",
+  "version": "1.0.0",
+  "main": "src/index.ts",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@objectstack/spec": "workspace:*"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

examples/plugin-bi/src/index.ts

@@ -0,0 +1,31 @@
+
+export class BiEngine {
+  constructor() {
+    console.log('[BI Plugin] Engine Initialized');
+  }
+
+  registerDataset(path: string) {
+    console.log(`[BI Plugin] Registered dataset: ${path}`);
+  }
+
+  runQuery(query: string) {
+    console.log(`[BI Plugin] Running Query: ${query}`);
+    return { result: 'Mock Data' };
+  }
+}
+
+/**
+ * Plugin Lifecycle Hook
+ * (Simulated interface)
+ */
+export async function onEnable(context: any) {
+  console.log('[BI Plugin] Enabling BI Plugin...');
+  
+  // Register Service
+  const engine = new BiEngine();
+  if (context.services) {
+    context.services.register('bi.engine', engine);
+  }
+
+  console.log('[BI Plugin] Services registered.');
+}

examples/plugin-bi/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*", "objectstack.config.ts"]
+}

examples/server/src/index.ts

@@ -33,21 +33,25 @@ app.get('/api/v1/meta/:type', (c) => {
     'objects': 'object',
     'apps': 'app',
     'flows': 'flow',
-    'reports': 'report'
+    'reports': 'report',
+    'plugins': 'plugin',
+    'kinds': 'kind'
   };
   const type = typeMap[typePlural] || typePlural;
 
   const items = SchemaRegistry.listItems(type);
 
   // Optional: Summary transformation based on type
   const summaries = items.map((item: any) => ({
+    id: item.id, // Some items use ID (plugins)
     name: item.name,
     label: item.label,
+    type: item.type,
     icon: item.icon,
     description: item.description,
     // Add dynamic links
     ...(type === 'object' ? { path: `/api/v1/data/${item.name}` } : {}),
-    self: `/api/v1/meta/${typePlural}/${item.name}`
+    self: `/api/v1/meta/${typePlural}/${item.name || item.id}`
   }));
 
   return c.json({ data: summaries });
@@ -66,7 +70,9 @@ app.get('/api/v1/meta/:type/:name', (c) => {
     'objects': 'object',
     'apps': 'app',
     'flows': 'flow',
-    'reports': 'report'
+    'reports': 'report',
+    'plugins': 'plugin',
+    'kinds': 'kind'
   };
   const type = typeMap[typePlural] || typePlural;
 

examples/server/src/kernel/registry.ts

@@ -1,27 +1,31 @@
-import { ServiceObject, App } from '@objectstack/spec';
+import { ServiceObject, App, ObjectStackManifest } from '@objectstack/spec';
 
 /**
  * Global Schema Registry
  * Unified storage for all metadata types (Objects, Apps, Flows, Layouts, etc.)
  */
 export class SchemaRegistry {
-  // Nested Map: Type -> Name -> MetadataItem
+  // Nested Map: Type -> Name/ID -> MetadataItem
   private static metadata = new Map<string, Map<string, any>>();
 
   /**
    * Universal Register Method
+   * @param type The category of metadata (e.g., 'object', 'app', 'plugin')
+   * @param item The metadata item itself
+   * @param keyField The property to use as the unique key (default: 'name')
    */
-  static registerItem<T extends { name: string }>(type: string, item: T) {
+  static registerItem<T>(type: string, item: T, keyField: keyof T = 'name' as keyof T) {
     if (!this.metadata.has(type)) {
       this.metadata.set(type, new Map());
     }
     const collection = this.metadata.get(type)!;
+    const key = String(item[keyField]);
 
-    if (collection.has(item.name)) {
-      console.warn(`[Registry] Overwriting ${type}: ${item.name}`);
+    if (collection.has(key)) {
+      console.warn(`[Registry] Overwriting ${type}: ${key}`);
     }
-    collection.set(item.name, item);
-    console.log(`[Registry] Registered ${type}: ${item.name}`);
+    collection.set(key, item);
+    console.log(`[Registry] Registered ${type}: ${key}`);
   }
 
   /**
@@ -46,7 +50,7 @@ export class SchemaRegistry {
    * Object Helpers
    */
   static registerObject(schema: ServiceObject) {
-    this.registerItem('object', schema);
+    this.registerItem('object', schema, 'name');
   }
 
   static getObject(name: string): ServiceObject | undefined {
@@ -61,7 +65,7 @@ export class SchemaRegistry {
    * App Helpers
    */
   static registerApp(app: App) {
-    this.registerItem('app', app);
+    this.registerItem('app', app, 'name');
   }
 
   static getApp(name: string): App | undefined {
@@ -71,4 +75,26 @@ export class SchemaRegistry {
   static getAllApps(): App[] {
     return this.listItems<App>('app');
   }
+
+  /**
+   * Plugin Helpers
+   */
+  static registerPlugin(manifest: ObjectStackManifest) {
+    this.registerItem('plugin', manifest, 'id');
+  }
+
+  static getAllPlugins(): ObjectStackManifest[] {
+    return this.listItems<ObjectStackManifest>('plugin');
+  }
+
+  /**
+   * Kind (Metadata Type) Helpers
+   */
+  static registerKind(kind: { id: string, globs: string[] }) {
+    this.registerItem('kind', kind, 'id');
+  }
+  
+  static getAllKinds(): { id: string, globs: string[] }[] {
+    return this.listItems('kind');
+  }
 }

examples/server/src/loader.ts

@@ -1,32 +1,48 @@
 import { SchemaRegistry } from './kernel/registry';
-import { AppSchema } from '@objectstack/spec';
+import { AppSchema, ManifestSchema } from '@objectstack/spec';
 
 // In a real monorepo scenario, we might use path aliases or require.resolve
 // Here we use relative paths to demonstrate loading from the sibling packages
 // @ts-ignore
 import CrmApp from '../../crm/objectstack.config'; 
 // @ts-ignore
 import TodoApp from '../../todo/objectstack.config';
+// @ts-ignore
+import BiPlugin from '../../plugin-bi/objectstack.config';
 
 export function loadPlugins() {
-  const apps = [CrmApp, TodoApp];
+  const packages = [CrmApp, TodoApp, BiPlugin];
 
-  for (const app of apps) {
-    if (!app) continue;
+  for (const pkg of packages) {
+    if (!pkg) continue;
 
-    console.log(`[Loader] Loading App: ${app.name} (${app.label})`);
+    console.log(`[Loader] Loading Package: ${pkg.id || pkg.name} (${pkg.type || 'app'})`);
 
+    // Handle Plugins
+    if (pkg.type === 'plugin') {
+       const parsedPlugin = ManifestSchema.parse(pkg);
+       SchemaRegistry.registerPlugin(parsedPlugin);
+
+       if (parsedPlugin.contributes?.kinds) {
+          for (const kind of parsedPlugin.contributes.kinds) {
+            SchemaRegistry.registerKind(kind);
+          }
+       }
+       continue;
+    }
+
+    // Handle Apps
     // 0. Register App
-    const parsedApp = AppSchema.parse(app);
+    const parsedApp = AppSchema.parse(pkg);
     SchemaRegistry.registerApp(parsedApp);
 
     // 1. Register Objects
-    if (app.objects) {
-      app.objects.forEach((obj: any) => {
+    if (pkg.objects) {
+      pkg.objects.forEach((obj: any) => {
          SchemaRegistry.registerObject(obj);
       });
     }
 
-    console.log(`[Loader] Loaded ${app.objects?.length || 0} objects from ${app.name}`);
+    console.log(`[Loader] Loaded ${pkg.objects?.length || 0} objects from ${pkg.name}`);
   }
 }