feat(objectql): enhance plugin registration to support nested plugins and metadata

Author: hotlong

packages/cli/src/commands/serve.ts

@@ -207,6 +207,17 @@ export const serveCommand = new Command('serve')
               }
             }
 
+            // Wrap raw config objects (no init/start) into AppPlugin
+            // This handles plugins defined as plain { name, objects, ... } bundles
+            if (pluginToLoad && typeof pluginToLoad === 'object' && !pluginToLoad.init) {
+              try {
+                const { AppPlugin } = await import('@objectstack/runtime');
+                pluginToLoad = new AppPlugin(pluginToLoad);
+              } catch (e: any) {
+                // Fall through to kernel.use which will report the error
+              }
+            }
+
             await kernel.use(pluginToLoad);
             const pluginName = plugin.name || plugin.constructor?.name || 'unnamed';
             trackPlugin(pluginName);

packages/objectql/src/engine.ts

@@ -268,6 +268,91 @@ export class ObjectQL implements IDataEngine {
             this.logger.debug('Registered Kind', { kind: kind.name || kind.type, from: id });
           }
        }
+
+      // 7. Recursively register nested plugins
+      if (Array.isArray(manifest.plugins) && manifest.plugins.length > 0) {
+          console.log(`[ObjectQL] Processing ${manifest.plugins.length} nested plugins from ${id}`);
+          this.logger.debug('Processing nested plugins', { id, count: manifest.plugins.length });
+          for (const plugin of manifest.plugins) {
+              if (plugin && typeof plugin === 'object') {
+                  const pluginName = plugin.name || plugin.id || 'unnamed-plugin';
+                  console.log(`[ObjectQL] Registering nested plugin: ${pluginName}, has objects: ${!!plugin.objects}, objects type: ${typeof plugin.objects}`);
+                  this.logger.debug('Registering nested plugin', { pluginName, parentId: id });
+                  this.registerPlugin(plugin, id, namespace);
+              }
+          }
+      }
+  }
+
+  /**
+   * Register a nested plugin's metadata (objects, actions, views, etc.)
+   *
+   * Unlike registerApp(), this does NOT call SchemaRegistry.installPackage()
+   * because plugins are not formal manifests — they are lightweight config
+   * bundles with objects, actions, triggers, and navigation.
+   *
+   * @param plugin - The plugin config object
+   * @param parentId - The parent package ID (for ownership tracking)
+   * @param parentNamespace - The parent package's namespace (for FQN resolution)
+   */
+  private registerPlugin(plugin: any, parentId: string, parentNamespace?: string) {
+      const pluginId = plugin.id || plugin.name || parentId;
+      const pluginNamespace = plugin.namespace || parentNamespace;
+
+      // Register objects (supports both Array and Map formats)
+      if (plugin.objects) {
+          try {
+              if (Array.isArray(plugin.objects)) {
+                  console.log(`[ObjectQL] Registering ${plugin.objects.length} objects (Array) for plugin ${pluginId}`);
+                  for (const objDef of plugin.objects) {
+                      const fqn = SchemaRegistry.registerObject(objDef, pluginId, pluginNamespace, 'own');
+                      console.log(`[ObjectQL] Registered Object: ${fqn}`);
+                  }
+              } else {
+                  const entries = Object.entries(plugin.objects);
+                  console.log(`[ObjectQL] Registering ${entries.length} objects (Map) for plugin ${pluginId}, namespace: ${pluginNamespace}`);
+                  for (const [name, objDef] of entries) {
+                      (objDef as any).name = name;
+                      const fqn = SchemaRegistry.registerObject(objDef as any, pluginId, pluginNamespace, 'own');
+                      console.log(`[ObjectQL] Registered Object: ${fqn}`);
+                  }
+              }
+          } catch (err: any) {
+              console.error(`[ObjectQL] Failed to register plugin objects for ${pluginId}:`, err.message);
+          }
+      } else {
+          console.log(`[ObjectQL] Plugin ${pluginId} has no objects`);
+      }
+
+      // Register plugin as app if it has navigation (for sidebar display)
+      if (plugin.name && plugin.navigation) {
+          try {
+              SchemaRegistry.registerApp(plugin, pluginId);
+              this.logger.debug('Registered plugin-as-app', { app: plugin.name, from: pluginId });
+          } catch (err: any) {
+              this.logger.warn('Failed to register plugin as app', { pluginId, error: err.message });
+          }
+      }
+
+      // Register metadata arrays (actions, views, triggers, etc.)
+      const metadataArrayKeys = [
+          'actions', 'views', 'pages', 'dashboards', 'reports', 'themes',
+          'flows', 'workflows', 'approvals', 'webhooks',
+          'roles', 'permissions', 'profiles', 'sharingRules', 'policies',
+          'agents', 'ragPipelines', 'apis',
+          'hooks', 'mappings', 'analyticsCubes', 'connectors',
+      ];
+      for (const key of metadataArrayKeys) {
+          const items = (plugin as any)[key];
+          if (Array.isArray(items) && items.length > 0) {
+              for (const item of items) {
+                  const itemName = item.name || item.id;
+                  if (itemName) {
+                      SchemaRegistry.registerItem(key, item, 'name' as any, pluginId);
+                  }
+              }
+          }
+      }
   }
 
   /**