@objectql/core 4.1.0 → 4.2.1

package/src/index.ts

@@ -6,31 +6,16 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-// Re-export types from @objectstack packages for API compatibility
-export type { ObjectKernel } from '@objectstack/runtime';
-export type { ObjectStackProtocolImplementation } from '@objectstack/objectql';
-// Note: @objectstack/objectql types temporarily commented out due to type incompatibilities
-// in the published package. Will be re-enabled when package is updated.
-// export type { ObjectQL as ObjectQLEngine, SchemaRegistry } from '@objectstack/objectql';
+// ── Convenience factory ──
+export { createObjectQLKernel, type ObjectQLKernelOptions } from './kernel-factory';
 
-// Export ObjectStack spec types for driver development
-import { Data, System } from '@objectstack/spec';
-export type QueryAST = Data.QueryAST;
-export type DriverInterface = Data.DriverInterface;
-export type DriverOptions = Data.DriverOptions;
+// ── Re-export bridge engine (extends upstream with MetadataRegistry + legacy config) ──
+export { ObjectQL, type ObjectQLConfig } from './app';
+export { ObjectRepository, ScopedContext, SchemaRegistry } from '@objectstack/objectql';
+export type { HookHandler, HookEntry, OperationContext, EngineMiddleware, ObjectQLHostContext } from '@objectstack/objectql';
 
-export * from './gateway';
-
-// Export our enhanced runtime components (actual implementations)
-export * from './repository';
-export * from './app';
+// ── Plugin orchestration ──
 export * from './plugin';
 
-// Export query-specific modules (ObjectQL core competency)
-export * from './query';
-
-// Export utilities
+// ── Utilities ──
 export * from './util';
-
-// Export kernel optimizations
-export * from './optimizations';

package/src/kernel-factory.ts

@@ -0,0 +1,47 @@
+/**
+ * ObjectQL Kernel Factory
+ * Copyright (c) 2026-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 { ObjectKernel } from '@objectstack/runtime';
+import { ObjectQLPlugin as UpstreamObjectQLPlugin } from '@objectstack/objectql';
+import type { Plugin } from '@objectstack/core';
+
+/**
+ * Options for creating an ObjectQL Kernel
+ */
+export interface ObjectQLKernelOptions {
+  /**
+   * Additional plugins to register with the kernel
+   */
+  plugins?: Plugin[];
+}
+
+/**
+ * Convenience factory for creating an ObjectQL-ready kernel.
+ *
+ * Creates an ObjectStackKernel pre-configured with the upstream ObjectQLPlugin
+ * (data engine, schema registry, protocol implementation) plus any additional
+ * plugins provided.
+ *
+ * @example
+ * ```typescript
+ * import { createObjectQLKernel } from '@objectql/core';
+ * import { QueryPlugin } from '@objectql/plugin-query';
+ * import { OptimizationsPlugin } from '@objectql/plugin-optimizations';
+ *
+ * const kernel = createObjectQLKernel({
+ *   plugins: [new QueryPlugin(), new OptimizationsPlugin()],
+ * });
+ * await kernel.start();
+ * ```
+ */
+export function createObjectQLKernel(options: ObjectQLKernelOptions = {}): ObjectKernel {
+  return new (ObjectKernel as any)([
+    new UpstreamObjectQLPlugin(),
+    ...(options.plugins || []),
+  ]);
+}

package/src/plugin.ts

@@ -7,29 +7,13 @@
  */
 
 import type { RuntimePlugin, RuntimeContext } from '@objectql/types';
+import { ConsoleLogger, ObjectQLError } from '@objectql/types';
+import type { Logger } from '@objectql/types';
 import { ValidatorPlugin, ValidatorPluginConfig } from '@objectql/plugin-validator';
 import { FormulaPlugin, FormulaPluginConfig } from '@objectql/plugin-formula';
-import { QueryService } from './query/query-service';
-import { QueryAnalyzer } from './query/query-analyzer';
-import { ObjectStackProtocolImplementation } from './protocol';
+import { QueryPlugin } from '@objectql/plugin-query';
 import type { Driver } from '@objectql/types';
-
-/**
- * Extended kernel with ObjectQL services
- */
-interface ExtendedKernel {
-    metadata?: any;
-    actions?: any;
-    hooks?: any;
-    getAllDrivers?: () => Driver[];
-    create?: (objectName: string, data: any) => Promise<any>;
-    update?: (objectName: string, id: string, data: any) => Promise<any>;
-    delete?: (objectName: string, id: string) => Promise<any>;
-    find?: (objectName: string, query: any) => Promise<any>;
-    get?: (objectName: string, id: string) => Promise<any>;
-    queryService?: QueryService;
-    queryAnalyzer?: QueryAnalyzer;
-}
+import { SchemaRegistry } from '@objectstack/objectql';
 
 /**
  * Configuration for the ObjectQL Plugin
@@ -65,12 +49,6 @@ export interface ObjectQLPluginConfig {
    */
   formulaConfig?: FormulaPluginConfig;
   
-  /**
-   * Enable AI integration
-   * @default true
-   */
-  enableAI?: boolean;
-  
   /**
    * Enable query service and analyzer
    * @default true
@@ -87,23 +65,27 @@ export interface ObjectQLPluginConfig {
 /**
  * ObjectQL Plugin
  * 
- * Implements the RuntimePlugin interface to provide ObjectQL's enhanced features
- * (Repository, Validator, Formula, AI) on top of the microkernel.
+ * Thin orchestrator that composes ObjectQL's extension plugins
+ * (QueryPlugin, ValidatorPlugin, FormulaPlugin, AI) on top of the microkernel.
+ * 
+ * Delegates query execution to @objectql/plugin-query and provides
+ * repository-pattern CRUD bridging to the kernel.
  */
 export class ObjectQLPlugin implements RuntimePlugin {
   name = '@objectql/core';
-  version = '4.0.2';
+  version = '4.2.0';
+  private logger: Logger;
   
-  constructor(private config: ObjectQLPluginConfig = {}, ql?: any) {
+  constructor(private config: ObjectQLPluginConfig = {}, _ql?: any) {
     // Set defaults
     this.config = {
       enableRepository: true,
       enableValidator: true,
       enableFormulas: true,
-      enableAI: true,
       enableQueryService: true,
       ...config
     };
+    this.logger = new ConsoleLogger({ name: '@objectql/core/plugin', level: 'info' });
   }
   
   /**
@@ -111,9 +93,9 @@ export class ObjectQLPlugin implements RuntimePlugin {
    * This is called during kernel initialization
    */
   async install(ctx: RuntimeContext): Promise<void> {
-    console.log(`[${this.name}] Installing plugin...`);
+    this.logger.info('Installing plugin...');
     
-    const kernel = ctx.engine as ExtendedKernel;
+    const kernel = ctx.engine as any;
     
     // Get datasources - either from config or from kernel drivers
     let datasources = this.config.datasources;
@@ -127,27 +109,19 @@ export class ObjectQLPlugin implements RuntimePlugin {
           const driverName = driver.name || (index === 0 ? 'default' : `driver_${index + 1}`);
           datasources![driverName] = driver;
         });
-        console.log(`[${this.name}] Using drivers from kernel:`, Object.keys(datasources));
+        this.logger.info('Using drivers from kernel', {
+          drivers: Object.keys(datasources),
+        });
       } else {
-        console.warn(`[${this.name}] No datasources configured and no drivers found in kernel. Repository and QueryService will not be available.`);
+        this.logger.warn('No datasources configured and no drivers found in kernel. Repository and QueryService will not be available.');
       }
     }
     
-    // Register QueryService and QueryAnalyzer if enabled
+    // Delegate query service registration to QueryPlugin
     if (this.config.enableQueryService !== false && datasources) {
-      const queryService = new QueryService(
-        datasources,
-        kernel.metadata
-      );
-      kernel.queryService = queryService;
-      
-      const queryAnalyzer = new QueryAnalyzer(
-        queryService,
-        kernel.metadata
-      );
-      kernel.queryAnalyzer = queryAnalyzer;
-      
-      console.log(`[${this.name}] QueryService and QueryAnalyzer registered`);
+      const queryPlugin = new QueryPlugin({ datasources });
+      await queryPlugin.install(ctx);
+      this.logger.info('QueryPlugin installed (QueryService + QueryAnalyzer)');
     }
     
     // Register components based on configuration
@@ -167,49 +141,41 @@ export class ObjectQLPlugin implements RuntimePlugin {
       await formulaPlugin.install?.(ctx);
     }
     
-    if (this.config.enableAI !== false) {
-      await this.registerAI(kernel);
+    // Register system service aliases
+    if (typeof (ctx as any).registerService === 'function') {
+        const registerService = (ctx as any).registerService.bind(ctx);
+        
+        // 1. Metadata service
+        if (kernel.metadata) {
+            registerService('metadata', kernel.metadata);
+            this.logger.debug('Registered metadata service alias');
+        }
+        
+        // 2. Data service (prefer QueryService, fallback to kernel)
+        const dataService = kernel.queryService || kernel;
+        registerService('data', dataService);
+        this.logger.debug('Registered data service alias');
+
+        // 3. Analytics service (via QueryService)
+        if (kernel.queryService) {
+            registerService('analytics', kernel.queryService);
+            this.logger.debug('Registered analytics service alias');
+        }
     }
-    
-    console.log(`[${this.name}] Plugin installed successfully`);
+
+    this.logger.info('Plugin installed successfully');
   }
   
   /**
    * Called when the kernel starts
    * This is the initialization phase
    */
-  async onStart(ctx: RuntimeContext): Promise<void> {
-    console.log(`[${this.name}] Starting plugin...`);
+  async onStart(_ctx: RuntimeContext): Promise<void> {
+    this.logger.debug('Starting plugin...');
     // Additional startup logic can be added here
   }
 
   // --- Adapter for @objectstack/core compatibility ---
-  async init(kernel: any): Promise<void> {
-      // The new core passes the kernel instance directly
-      // We wrap it to match the old RuntimeContext interface
-      const ctx = {
-          engine: kernel,
-          getKernel: () => kernel
-      };
-
-      // Register Protocol Service
-      // If kernel supports service registration (PluginContext or ExtendedKernel with custom registry)
-      if (kernel && typeof kernel.registerService === 'function') {
-          console.log(`[${this.name}] Registering protocol service...`);
-          const protocolShim = new ObjectStackProtocolImplementation(kernel as any);
-          kernel.registerService('protocol', protocolShim);
-      }
-
-      return this.install(ctx);
-  }
-
-  async start(kernel: any): Promise<void> {
-      const ctx = {
-          engine: kernel,
-          getKernel: () => kernel
-      };
-      return this.onStart(ctx);
-  }
   // ---------------------------------------------------
   
   /**
@@ -223,7 +189,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
       const datasourceName = objectConfig?.datasource || 'default';
       const driver = datasources[datasourceName];
       if (!driver) {
-        throw new Error(`Datasource '${datasourceName}' not found for object '${objectName}'`);
+        throw new ObjectQLError({ code: 'NOT_FOUND', message: `Datasource '${datasourceName}' not found for object '${objectName}'` });
       }
       return driver;
     };
@@ -276,8 +242,6 @@ export class ObjectQLPlugin implements RuntimePlugin {
     kernel.count = async (objectName: string, filters?: any): Promise<number> => {
       // Use QueryService if available
       if ((kernel as any).queryService) {
-          // QueryService.count expects a UnifiedQuery filter or just filter object?
-          // Looking at QueryService.count signature: count(objectName: string, where?: Filter, options?: QueryOptions)
           const result = await (kernel as any).queryService.count(objectName, filters);
           return result.value;
       }
@@ -286,16 +250,74 @@ export class ObjectQLPlugin implements RuntimePlugin {
       return await driver.count(objectName, filters || {}, {});
     };
 
-    console.log(`[${this.name}] Repository pattern registered`);
+    this.logger.info('Repository pattern registered');
   }
   
-  /**
-   * Register AI integration
-   * @private
-   */
-  private async registerAI(kernel: any): Promise<void> {
-    // TODO: Implement AI registration
-    // For now, this is a placeholder to establish the structure
-    console.log(`[${this.name}] AI integration registered`);
-  }
+    // --- Adapter for @objectstack/core compatibility ---
+    init = async (pluginCtx: any): Promise<void> => {
+        // The @objectstack/core kernel passes a PluginContext (with registerService, getKernel, etc.)
+        // We extract the actual kernel and build a RuntimeContext wrapper that proxies registerService.
+        const actualKernel = typeof pluginCtx.getKernel === 'function'
+            ? pluginCtx.getKernel()
+            : pluginCtx;
+
+        // Create metadata facade on the kernel if not already present.
+        // The raw ObjectKernel from @objectstack/core has no .metadata property;
+        // it's normally created by the ObjectQL wrapper (app.ts).
+        // When running via `objectstack serve`, we must create it here.
+        if (!actualKernel.metadata) {
+            const unwrapContent = (item: any) => (item && item.content) ? item.content : item;
+            actualKernel.metadata = {
+                register: (type: string, item: any) => SchemaRegistry.registerItem(type, item, item.id ? 'id' : 'name'),
+                get: (type: string, name: string) => {
+                    const item = SchemaRegistry.getItem(type, name) as any;
+                    return unwrapContent(item);
+                },
+                getEntry: (type: string, name: string) => SchemaRegistry.getItem(type, name),
+                list: (type: string) => {
+                    const items = SchemaRegistry.listItems(type);
+                    return items.map(unwrapContent);
+                },
+                unregister: (type: string, name: string) => {
+                    if (typeof SchemaRegistry.unregisterItem === 'function') {
+                        SchemaRegistry.unregisterItem(type, name);
+                    }
+                },
+                unregisterPackage: (packageName: string) => {
+                    if (typeof (SchemaRegistry as any).unregisterObjectsByPackage === 'function') {
+                        (SchemaRegistry as any).unregisterObjectsByPackage(packageName);
+                    }
+                },
+            };
+            this.logger.info('Created metadata facade on kernel');
+        }
+
+        const ctx: any = {
+            engine: actualKernel,
+            getKernel: () => actualKernel,
+            // Proxy registerService from PluginContext so install() can register metadata/data/analytics
+            registerService: typeof pluginCtx.registerService === 'function'
+                ? pluginCtx.registerService.bind(pluginCtx)
+                : undefined,
+        };
+
+        // Register 'objectql' service for AppPlugin compatibility
+        if (typeof pluginCtx.registerService === 'function') {
+            pluginCtx.registerService('objectql', this);
+            this.logger.debug('Registered objectql service');
+        }
+
+        return this.install(ctx);
+    }
+
+    start = async (pluginCtx: any): Promise<void> => {
+        const actualKernel = typeof pluginCtx.getKernel === 'function'
+            ? pluginCtx.getKernel()
+            : pluginCtx;
+        const ctx: any = {
+            engine: actualKernel,
+            getKernel: () => actualKernel,
+        };
+        return this.onStart(ctx);
+    }
 }