Merge pull request #282 from objectstack-ai/copilot/enhance-plugin-registration

Author: hotlong

PLUGIN_SYSTEM.md

@@ -28,6 +28,7 @@
     "lint": "pnpm -r lint",
     "cli": "node packages/cli/dist/cli.js",
     "objectui": "node packages/cli/dist/cli.js",
+    "create-plugin": "node packages/create-plugin/dist/index.js",
     "storybook": "storybook dev -p 6006",
     "storybook:build": "storybook build",
     "storybook:test": "test-storybook --testTimeout=90000",

package.json

@@ -8,6 +8,7 @@
 
 export * from './types';
 export * from './registry/Registry';
+export * from './registry/PluginSystem';
 export * from './validation';
 export * from './builder/schema-builder';
 export * from './utils/filter-converter';

packages/core/src/index.ts

@@ -0,0 +1,123 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import type { Registry } from './Registry';
+
+export interface PluginDefinition {
+  name: string;
+  version: string;
+  dependencies?: string[];  // Dependencies on other plugins
+  peerDependencies?: string[];  // Peer dependencies
+  register: (registry: Registry) => void;
+  onLoad?: () => void | Promise<void>;  // Lifecycle hook: called after registration
+  onUnload?: () => void | Promise<void>;  // Lifecycle hook: called before unload
+}
+
+export class PluginSystem {
+  private plugins = new Map<string, PluginDefinition>();
+  private loaded = new Set<string>();
+
+  /**
+   * Load a plugin into the system
+   * @param plugin The plugin definition to load
+   * @param registry The component registry to use for registration
+   * @throws Error if dependencies are missing
+   */
+  async loadPlugin(plugin: PluginDefinition, registry: Registry): Promise<void> {
+    // Check if already loaded
+    if (this.loaded.has(plugin.name)) {
+      console.warn(`Plugin "${plugin.name}" is already loaded. Skipping.`);
+      return;
+    }
+
+    // Check dependencies
+    for (const dep of plugin.dependencies || []) {
+      if (!this.loaded.has(dep)) {
+        throw new Error(`Missing dependency: ${dep} required by ${plugin.name}`);
+      }
+    }
+
+    try {
+      // Execute registration
+      plugin.register(registry);
+
+      // Store plugin definition
+      this.plugins.set(plugin.name, plugin);
+
+      // Execute lifecycle hook
+      await plugin.onLoad?.();
+
+      // Mark as loaded
+      this.loaded.add(plugin.name);
+    } catch (error) {
+      // Clean up on failure
+      this.plugins.delete(plugin.name);
+      throw error;
+    }
+  }
+
+  /**
+   * Unload a plugin from the system
+   * @param name The name of the plugin to unload
+   * @throws Error if other plugins depend on this plugin
+   */
+  async unloadPlugin(name: string): Promise<void> {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      throw new Error(`Plugin "${name}" is not loaded`);
+    }
+
+    // Check if any loaded plugins depend on this one
+    for (const [pluginName, pluginDef] of this.plugins.entries()) {
+      if (this.loaded.has(pluginName) && pluginDef.dependencies?.includes(name)) {
+        throw new Error(`Cannot unload plugin "${name}" - plugin "${pluginName}" depends on it`);
+      }
+    }
+
+    // Execute lifecycle hook
+    await plugin.onUnload?.();
+
+    // Remove from loaded set
+    this.loaded.delete(name);
+    this.plugins.delete(name);
+  }
+
+  /**
+   * Check if a plugin is loaded
+   * @param name The name of the plugin
+   * @returns true if the plugin is loaded
+   */
+  isLoaded(name: string): boolean {
+    return this.loaded.has(name);
+  }
+
+  /**
+   * Get a loaded plugin definition
+   * @param name The name of the plugin
+   * @returns The plugin definition or undefined
+   */
+  getPlugin(name: string): PluginDefinition | undefined {
+    return this.plugins.get(name);
+  }
+
+  /**
+   * Get all loaded plugin names
+   * @returns Array of loaded plugin names
+   */
+  getLoadedPlugins(): string[] {
+    return Array.from(this.loaded);
+  }
+
+  /**
+   * Get all plugin definitions
+   * @returns Array of all plugin definitions
+   */
+  getAllPlugins(): PluginDefinition[] {
+    return Array.from(this.plugins.values());
+  }
+}

packages/core/src/registry/PluginSystem.ts

@@ -0,0 +1,224 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PluginSystem, type PluginDefinition } from '../PluginSystem';
+import { Registry } from '../Registry';
+
+describe('PluginSystem', () => {
+  let pluginSystem: PluginSystem;
+  let registry: Registry;
+
+  beforeEach(() => {
+    pluginSystem = new PluginSystem();
+    registry = new Registry();
+  });
+
+  it('should load a simple plugin', async () => {
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: (reg) => {
+        reg.register('test', () => 'test');
+      }
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    expect(pluginSystem.isLoaded('test-plugin')).toBe(true);
+    expect(pluginSystem.getLoadedPlugins()).toContain('test-plugin');
+    expect(registry.has('test')).toBe(true);
+  });
+
+  it('should execute onLoad lifecycle hook', async () => {
+    const onLoad = vi.fn();
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {},
+      onLoad
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    expect(onLoad).toHaveBeenCalledTimes(1);
+  });
+
+  it('should execute async onLoad lifecycle hook', async () => {
+    const onLoad = vi.fn().mockResolvedValue(undefined);
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {},
+      onLoad
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    expect(onLoad).toHaveBeenCalledTimes(1);
+  });
+
+  it('should not load plugin twice', async () => {
+    const onLoad = vi.fn();
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {},
+      onLoad
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    expect(onLoad).toHaveBeenCalledTimes(1);
+  });
+
+  it('should check dependencies before loading', async () => {
+    const plugin: PluginDefinition = {
+      name: 'dependent-plugin',
+      version: '1.0.0',
+      dependencies: ['base-plugin'],
+      register: () => {}
+    };
+
+    await expect(pluginSystem.loadPlugin(plugin, registry)).rejects.toThrow(
+      'Missing dependency: base-plugin required by dependent-plugin'
+    );
+  });
+
+  it('should load plugins with dependencies in correct order', async () => {
+    const basePlugin: PluginDefinition = {
+      name: 'base-plugin',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    const dependentPlugin: PluginDefinition = {
+      name: 'dependent-plugin',
+      version: '1.0.0',
+      dependencies: ['base-plugin'],
+      register: () => {}
+    };
+
+    await pluginSystem.loadPlugin(basePlugin, registry);
+    await pluginSystem.loadPlugin(dependentPlugin, registry);
+    
+    expect(pluginSystem.isLoaded('base-plugin')).toBe(true);
+    expect(pluginSystem.isLoaded('dependent-plugin')).toBe(true);
+  });
+
+  it('should unload a plugin', async () => {
+    const onUnload = vi.fn();
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {},
+      onUnload
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    expect(pluginSystem.isLoaded('test-plugin')).toBe(true);
+    
+    await pluginSystem.unloadPlugin('test-plugin');
+    
+    expect(pluginSystem.isLoaded('test-plugin')).toBe(false);
+    expect(onUnload).toHaveBeenCalledTimes(1);
+  });
+
+  it('should prevent unloading plugin with dependents', async () => {
+    const basePlugin: PluginDefinition = {
+      name: 'base-plugin',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    const dependentPlugin: PluginDefinition = {
+      name: 'dependent-plugin',
+      version: '1.0.0',
+      dependencies: ['base-plugin'],
+      register: () => {}
+    };
+
+    await pluginSystem.loadPlugin(basePlugin, registry);
+    await pluginSystem.loadPlugin(dependentPlugin, registry);
+    
+    await expect(pluginSystem.unloadPlugin('base-plugin')).rejects.toThrow(
+      'Cannot unload plugin "base-plugin" - plugin "dependent-plugin" depends on it'
+    );
+  });
+
+  it('should throw error when unloading non-existent plugin', async () => {
+    await expect(pluginSystem.unloadPlugin('non-existent')).rejects.toThrow(
+      'Plugin "non-existent" is not loaded'
+    );
+  });
+
+  it('should get plugin definition', async () => {
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    const retrieved = pluginSystem.getPlugin('test-plugin');
+    expect(retrieved).toBe(plugin);
+  });
+
+  it('should get all plugins', async () => {
+    const plugin1: PluginDefinition = {
+      name: 'plugin-1',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    const plugin2: PluginDefinition = {
+      name: 'plugin-2',
+      version: '1.0.0',
+      register: () => {}
+    };
+
+    await pluginSystem.loadPlugin(plugin1, registry);
+    await pluginSystem.loadPlugin(plugin2, registry);
+    
+    const allPlugins = pluginSystem.getAllPlugins();
+    expect(allPlugins).toHaveLength(2);
+    expect(allPlugins).toContain(plugin1);
+    expect(allPlugins).toContain(plugin2);
+  });
+
+  it('should call register function with registry', async () => {
+    const registerFn = vi.fn();
+    const plugin: PluginDefinition = {
+      name: 'test-plugin',
+      version: '1.0.0',
+      register: registerFn
+    };
+
+    await pluginSystem.loadPlugin(plugin, registry);
+    
+    expect(registerFn).toHaveBeenCalledWith(registry);
+    expect(registerFn).toHaveBeenCalledTimes(1);
+  });
+
+  it('should cleanup on registration failure', async () => {
+    const plugin: PluginDefinition = {
+      name: 'failing-plugin',
+      version: '1.0.0',
+      register: () => {
+        throw new Error('Registration failed');
+      }
+    };
+
+    await expect(pluginSystem.loadPlugin(plugin, registry)).rejects.toThrow('Registration failed');
+    
+    expect(pluginSystem.isLoaded('failing-plugin')).toBe(false);
+    expect(pluginSystem.getPlugin('failing-plugin')).toBeUndefined();
+  });
+});