Add support for both legacy and @objectstack/spec plugin types

Co-authored-by: huangyiirene <7665279+huangyiirene@users.noreply.github.com>

Author: Copilot

packages/foundation/core/src/app.ts

@@ -15,6 +15,7 @@ import {
     IObjectQL, 
     ObjectQLConfig,
     ObjectQLPlugin,
+    PluginDefinition,
     HookName,
     HookHandler,
     HookContext,
@@ -37,7 +38,7 @@ export class ObjectQL implements IObjectQL {
     private remotes: string[] = [];
     private hooks: Record<string, HookEntry[]> = {};
     private actions: Record<string, ActionEntry> = {};
-    private pluginsList: ObjectQLPlugin[] = [];
+    private pluginsList: Array<ObjectQLPlugin | PluginDefinition> = [];
 
     // Store config for lazy loading in init()
     private config: ObjectQLConfig;
@@ -63,7 +64,7 @@ export class ObjectQL implements IObjectQL {
             }
         }
     }
-    use(plugin: ObjectQLPlugin) {
+    use(plugin: ObjectQLPlugin | PluginDefinition) {
         this.pluginsList.push(plugin);
     }
 
@@ -214,10 +215,87 @@ export class ObjectQL implements IObjectQL {
         }
     }
 
+    /**
+     * Create a PluginContext from the current IObjectQL instance.
+     * This adapts the IObjectQL interface to the PluginContext expected by @objectstack/spec plugins.
+     * 
+     * @private
+     */
+    private createPluginContext(app: IObjectQL): any {
+        // TODO: Implement full PluginContext conversion
+        // For now, provide a minimal adapter that maps IObjectQL to PluginContext
+        return {
+            ql: {
+                object: (name: string) => {
+                    // Return a repository-like interface
+                    return app.createContext().object(name);
+                },
+                query: async (soql: string) => {
+                    // TODO: Implement SOQL query execution
+                    throw new Error('SOQL queries not yet implemented in adapter');
+                }
+            },
+            os: {
+                getCurrentUser: async () => {
+                    // TODO: Get from context
+                    return null;
+                },
+                getConfig: async (key: string) => {
+                    // TODO: Implement config access
+                    return null;
+                }
+            },
+            logger: {
+                debug: (...args: any[]) => console.debug('[Plugin]', ...args),
+                info: (...args: any[]) => console.info('[Plugin]', ...args),
+                warn: (...args: any[]) => console.warn('[Plugin]', ...args),
+                error: (...args: any[]) => console.error('[Plugin]', ...args),
+            },
+            storage: {
+                get: async (key: string) => {
+                    // TODO: Implement plugin storage
+                    return null;
+                },
+                set: async (key: string, value: any) => {
+                    // TODO: Implement plugin storage
+                },
+                delete: async (key: string) => {
+                    // TODO: Implement plugin storage
+                }
+            },
+            i18n: {
+                t: (key: string, params?: any) => key, // Fallback: return key
+                getLocale: () => 'en'
+            },
+            metadata: app.metadata,
+            events: {
+                // TODO: Implement event bus
+            },
+            app: {
+                router: {
+                    get: (path: string, handler: Function) => {
+                        // TODO: Implement router registration
+                    },
+                    post: (path: string, handler: Function) => {
+                        // TODO: Implement router registration
+                    },
+                    use: (pathOrHandler: string | Function, handler?: Function) => {
+                        // TODO: Implement middleware registration
+                    }
+                },
+                scheduler: undefined // Optional in spec
+            }
+        };
+    }
+
     async init() {
         // 0. Init Plugins (This allows plugins to register custom loaders)
         for (const plugin of this.pluginsList) {
-            console.log(`Initializing plugin '${plugin.name}'...`);
+            // Type guard: check if it's a legacy plugin or new PluginDefinition
+            const isLegacyPlugin = 'setup' in plugin && typeof plugin.setup === 'function';
+            const pluginId = isLegacyPlugin ? (plugin as ObjectQLPlugin).name : (plugin as PluginDefinition).id || 'unknown';
+            
+            console.log(`Initializing plugin '${pluginId}'...`);
 
             let app: IObjectQL = this;
             const pkgName = (plugin as any)._packageName;
@@ -239,7 +317,21 @@ export class ObjectQL implements IObjectQL {
                 });
             }
 
-            await plugin.setup(app);
+            if (isLegacyPlugin) {
+                // Legacy plugin with setup() method
+                await (plugin as ObjectQLPlugin).setup(app);
+            } else {
+                // New plugin with lifecycle hooks
+                const newPlugin = plugin as PluginDefinition;
+                
+                // Call onEnable hook if it exists
+                if (newPlugin.onEnable) {
+                    // TODO: Build proper PluginContext from IObjectQL
+                    // For now, we'll create a minimal context adapter
+                    const context = this.createPluginContext(app);
+                    await newPlugin.onEnable(context);
+                }
+            }
         }
 
         // Packages, Presets, Source, Objects loading logic removed from Core.

packages/foundation/platform-node/src/plugin.ts

@@ -6,9 +6,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { ObjectQLPlugin } from '@objectql/types';
+import { ObjectQLPlugin, PluginDefinition } from '@objectql/types';
 
-export function loadPlugin(packageName: string): ObjectQLPlugin {
+export function loadPlugin(packageName: string): ObjectQLPlugin | PluginDefinition {
     let mod: any;
     try {
         const modulePath = require.resolve(packageName, { paths: [process.cwd()] });
@@ -17,26 +17,51 @@ export function loadPlugin(packageName: string): ObjectQLPlugin {
         throw new Error(`Failed to resolve plugin '${packageName}': ${e}`);
     }
 
+    // Helper to check if candidate is a legacy ObjectQLPlugin
+    const isLegacyPlugin = (candidate: any): candidate is ObjectQLPlugin => {
+        return candidate && typeof candidate.setup === 'function' && candidate.name;
+    };
+
+    // Helper to check if candidate is a new PluginDefinition
+    const isNewPlugin = (candidate: any): candidate is PluginDefinition => {
+        return candidate && (
+            typeof candidate.onEnable === 'function' ||
+            typeof candidate.onDisable === 'function' ||
+            typeof candidate.onInstall === 'function' ||
+            typeof candidate.onUninstall === 'function' ||
+            typeof candidate.onUpgrade === 'function'
+        );
+    };
+
     // Helper to find plugin instance
-    const findPlugin = (candidate: any): ObjectQLPlugin | undefined => {
+    const findPlugin = (candidate: any): ObjectQLPlugin | PluginDefinition | undefined => {
             if (!candidate) return undefined;
 
-            // 1. Try treating as Class
+            // 1. Check if it's a new PluginDefinition
+            if (isNewPlugin(candidate)) {
+                return candidate;
+            }
+
+            // 2. Try treating as Class (legacy)
             if (typeof candidate === 'function') {
                 try {
                     const inst = new candidate();
-                    if (inst && typeof inst.setup === 'function') {
-                        return inst; // Found it!
+                    if (isLegacyPlugin(inst)) {
+                        return inst;
+                    }
+                    if (isNewPlugin(inst)) {
+                        return inst;
                     }
                 } catch (e) {
                     // Not a constructor or instantiation failed
                 }
             }
 
-            // 2. Try treating as Instance
-            if (candidate && typeof candidate.setup === 'function') {
-                if (candidate.name) return candidate;
+            // 3. Try treating as Instance (legacy)
+            if (isLegacyPlugin(candidate)) {
+                return candidate;
             }
+            
             return undefined;
     };
 
@@ -55,7 +80,7 @@ export function loadPlugin(packageName: string): ObjectQLPlugin {
         (instance as any)._packageName = packageName;
         return instance;
     } else {
-        console.error(`[PluginLoader] Failed to find ObjectQLPlugin in '${packageName}'. Exports:`, Object.keys(mod));
-        throw new Error(`Plugin '${packageName}' must export a class or object implementing ObjectQLPlugin.`);
+        console.error(`[PluginLoader] Failed to find plugin in '${packageName}'. Exports:`, Object.keys(mod));
+        throw new Error(`Plugin '${packageName}' must export a PluginDefinition (with lifecycle hooks) or legacy ObjectQLPlugin (with setup method).`);
     }
 }

packages/foundation/types/src/config.ts

@@ -9,7 +9,7 @@
 import { MetadataRegistry } from "./registry";
 import { Driver } from "./driver";
 import { ObjectConfig } from "./object";
-import { ObjectQLPlugin } from "./plugin";
+import { ObjectQLPlugin, PluginDefinition } from "./plugin";
 
 export interface ObjectQLConfig {
     registry?: MetadataRegistry;
@@ -39,9 +39,12 @@ export interface ObjectQLConfig {
     modules?: string[];
     /**
      * List of plugins to load. 
-     * Can be an instance of ObjectQLPlugin or a package name string.
+     * Can be:
+     * - An instance of ObjectQLPlugin (legacy, deprecated)
+     * - An instance of PluginDefinition (from @objectstack/spec, recommended)
+     * - A package name string
      */
-    plugins?: (ObjectQLPlugin | string)[];
+    plugins?: (ObjectQLPlugin | PluginDefinition | string)[];
     /**
      * List of remote ObjectQL instances to connect to.
      * e.g. ["http://user-service:3000", "http://order-service:3000"]