@objectql/core 4.2.0 → 4.2.2

package/src/index.ts

@@ -1,53 +1,29 @@
 /**
- * ObjectQL
+ * ObjectQL Core — DEPRECATED
  * 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.
+ *
+ * @deprecated This package is deprecated. Migrate to `@objectstack/objectql`.
+ * See: https://github.com/objectstack-ai/spec/blob/main/content/docs/guides/objectql-migration.mdx
  */
 
-// Re-export types from @objectstack packages for API compatibility
-export type { ObjectKernel } from '@objectstack/runtime';
-export type { ObjectStackProtocolImplementation } from '@objectstack/objectql';
-
-// Re-export new @objectstack/objectql 1.1.0 FQN (Fully Qualified Name) utilities
-export {
-    computeFQN,
-    parseFQN,
-    RESERVED_NAMESPACES,
-    DEFAULT_OWNER_PRIORITY,
-    DEFAULT_EXTENDER_PRIORITY,
-    SchemaRegistry,
-} from '@objectstack/objectql';
-export type { ObjectContributor } from '@objectstack/objectql';
+// ── Bridge engine (deprecated — use @objectstack/objectql ObjectQL directly) ──
+/** @deprecated Import ObjectQL from `@objectstack/objectql` instead. This bridge class will be removed in a future version. */
+export { ObjectQL, type ObjectQLConfig } from './app';
 
-// Export ObjectStack spec types for driver development
-import { Data, System, Automation } from '@objectstack/spec';
-import { z } from 'zod';
-export { QueryAST } from '@objectql/types';
-export type DriverInterface = z.infer<typeof Data.DriverInterfaceSchema>;
-export type DriverOptions = z.infer<typeof Data.DriverOptionsSchema>;
+// ── Convenience factory (local implementation — wraps upstream kernel) ──
+export { createObjectQLKernel } from './kernel-factory';
+export type { ObjectQLKernelOptions } from './kernel-factory';
 
-// Re-export new @objectstack/spec 1.1.0 types
-export type StateMachineConfig = z.infer<typeof Automation.StateMachineSchema>;
-export type ObjectOwnership = z.infer<typeof Data.ObjectOwnershipEnum>;
-export type ObjectExtension = z.infer<typeof Data.ObjectExtensionSchema>;
+// ── Re-exports from @objectstack/objectql (deprecated — import directly from upstream) ──
+/** @deprecated Import from `@objectstack/objectql` instead. */
+export { ObjectRepository, ScopedContext, SchemaRegistry } from '@objectstack/objectql';
+/** @deprecated Import from `@objectstack/objectql` instead. */
+export { toTitleCase, convertIntrospectedSchemaToObjects } from '@objectstack/objectql';
+/** @deprecated Import from `@objectstack/objectql` instead. */
+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 (downstream — stays in @objectql ecosystem) ──
 export * from './plugin';
-
-// Export query-specific modules (ObjectQL core competency)
-export * from './query';
-
-// Export utilities
-export * from './util';
-
-// Export kernel optimizations
-export * from './optimizations';
-
-// Export AI runtime
-export * from './ai';

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,32 +7,13 @@
  */
 
 import type { RuntimePlugin, RuntimeContext } from '@objectql/types';
-import { ConsoleLogger } 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';
-import { createDefaultAiRegistry } from './ai';
-
-/**
- * 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
@@ -68,12 +49,6 @@ export interface ObjectQLPluginConfig {
    */
   formulaConfig?: FormulaPluginConfig;
   
-  /**
-   * Enable AI integration
-   * @default true
-   */
-  enableAI?: boolean;
-  
   /**
    * Enable query service and analyzer
    * @default true
@@ -90,21 +65,23 @@ 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
     };
@@ -118,7 +95,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
   async install(ctx: RuntimeContext): Promise<void> {
     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;
@@ -140,21 +117,11 @@ export class ObjectQLPlugin implements RuntimePlugin {
       }
     }
     
-    // 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;
-      
-      this.logger.info('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
@@ -174,10 +141,6 @@ 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);
@@ -192,6 +155,12 @@ export class ObjectQLPlugin implements RuntimePlugin {
         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');
+        }
     }
 
     this.logger.info('Plugin installed successfully');
@@ -201,7 +170,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
    * Called when the kernel starts
    * This is the initialization phase
    */
-  async onStart(ctx: RuntimeContext): Promise<void> {
+  async onStart(_ctx: RuntimeContext): Promise<void> {
     this.logger.debug('Starting plugin...');
     // Additional startup logic can be added here
   }
@@ -220,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;
     };
@@ -273,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,45 +253,70 @@ export class ObjectQLPlugin implements RuntimePlugin {
     this.logger.info('Repository pattern registered');
   }
   
-  /**
-   * Register AI integration
-   * @private
-   */
-  private async registerAI(kernel: any): Promise<void> {
-    if (!(kernel as any).ai) {
-      (kernel as any).ai = createDefaultAiRegistry();
-    }
-    this.logger.debug('AI integration registered');
-  }
-
     // --- Adapter for @objectstack/core compatibility ---
-    init = async (kernel: any): Promise<void> => {
-        // The new core passes the kernel instance directly
-        // We wrap it to match the old RuntimeContext interface
+    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: kernel,
-            getKernel: () => kernel
+            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 Protocol Service
-        // If kernel supports service registration (PluginContext or ExtendedKernel with custom registry)
-        if (kernel && typeof kernel.registerService === 'function') {
-            this.logger.info('Registering protocol service...');
-            const protocolShim = new ObjectStackProtocolImplementation(kernel);
-             kernel.registerService('protocol', protocolShim);
-             
-             // Register 'objectql' service for AppPlugin compatibility
-             kernel.registerService('objectql', this);
-             this.logger.debug('Registered objectql service');
+        // 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 (kernel: any): Promise<void> => {
+    start = async (pluginCtx: any): Promise<void> => {
+        const actualKernel = typeof pluginCtx.getKernel === 'function'
+            ? pluginCtx.getKernel()
+            : pluginCtx;
         const ctx: any = {
-            engine: kernel,
-            getKernel: () => kernel
+            engine: actualKernel,
+            getKernel: () => actualKernel,
         };
         return this.onStart(ctx);
     }