@objectql/core 4.0.6 → 4.2.0

package/src/gateway.ts

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { ApiRequest, ApiResponse, GatewayProtocol } from '@objectql/types';
+import { ApiRequest, ApiResponse, GatewayProtocol, Logger, ConsoleLogger } from '@objectql/types';
 
 export type RequestTransformer = (request: ApiRequest) => Promise<ApiRequest>;
 export type ResponseTransformer = (response: ApiResponse) => Promise<ApiResponse>;
@@ -19,9 +19,11 @@ export class ObjectGateway {
     private protocols: GatewayProtocol[] = [];
     private requestTransforms: RequestTransformer[] = [];
     private responseTransforms: ResponseTransformer[] = [];
+    private logger: Logger;
 
-    constructor(protocols: GatewayProtocol[] = []) {
+    constructor(protocols: GatewayProtocol[] = [], logger?: Logger) {
         this.protocols = protocols;
+        this.logger = logger ?? new ConsoleLogger({ name: '@objectql/gateway', level: 'info' });
     }
 
     /**
@@ -78,7 +80,9 @@ export class ObjectGateway {
         try {
             response = await protocol.handle(req);
         } catch (error: any) {
-            console.error(`[ObjectGateway] Error in ${protocol.name}:`, error);
+            this.logger.error(`Error in ${protocol.name}`, error as Error, {
+                protocol: protocol.name,
+            });
             response = {
                 status: 500,
                 headers: { 'Content-Type': 'application/json' },

package/src/index.ts

@@ -9,15 +9,29 @@
 // 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';
+
+// 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';
 
 // 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;
+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>;
+
+// 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>;
 
 export * from './gateway';
 
@@ -34,3 +48,6 @@ export * from './util';
 
 // Export kernel optimizations
 export * from './optimizations';
+
+// Export AI runtime
+export * from './ai';

package/src/optimizations/CompiledHookManager.ts

@@ -6,6 +6,8 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+import { Logger, ConsoleLogger } from '@objectql/types';
+
 /**
  * Hook definition
  */
@@ -30,6 +32,9 @@ export class CompiledHookManager {
     
     // Keep track of all registered hooks for management
     private allHooks = new Map<string, Hook>();
+    
+    // Structured logger
+    private logger: Logger = new ConsoleLogger({ name: '@objectql/hook-manager', level: 'warn' });
 
     /**
      * Expand a pattern like "before*" to all matching events
@@ -135,7 +140,10 @@ export class CompiledHookManager {
             try {
                 return Promise.resolve(hook.handler(context));
             } catch (error) {
-                console.error(`Hook execution failed for ${event}:${objectName}`, error);
+                this.logger.error(`Hook execution failed for ${event}:${objectName}`, error as Error, {
+                    event,
+                    objectName,
+                });
                 return Promise.resolve();
             }
         }));

package/src/plugin.ts

@@ -7,12 +7,15 @@
  */
 
 import type { RuntimePlugin, RuntimeContext } from '@objectql/types';
+import { ConsoleLogger } 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 type { Driver } from '@objectql/types';
+import { createDefaultAiRegistry } from './ai';
 
 /**
  * Extended kernel with ObjectQL services
@@ -93,6 +96,7 @@ export interface ObjectQLPluginConfig {
 export class ObjectQLPlugin implements RuntimePlugin {
   name = '@objectql/core';
   version = '4.0.2';
+  private logger: Logger;
   
   constructor(private config: ObjectQLPluginConfig = {}, ql?: any) {
     // Set defaults
@@ -104,6 +108,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
       enableQueryService: true,
       ...config
     };
+    this.logger = new ConsoleLogger({ name: '@objectql/core/plugin', level: 'info' });
   }
   
   /**
@@ -111,7 +116,7 @@ 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;
     
@@ -127,9 +132,11 @@ 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.');
       }
     }
     
@@ -147,7 +154,7 @@ export class ObjectQLPlugin implements RuntimePlugin {
       );
       kernel.queryAnalyzer = queryAnalyzer;
       
-      console.log(`[${this.name}] QueryService and QueryAnalyzer registered`);
+      this.logger.info('QueryService and QueryAnalyzer registered');
     }
     
     // Register components based on configuration
@@ -171,7 +178,23 @@ export class ObjectQLPlugin implements RuntimePlugin {
       await this.registerAI(kernel);
     }
     
-    console.log(`[${this.name}] Plugin installed successfully`);
+    // 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');
+    }
+
+    this.logger.info('Plugin installed successfully');
   }
   
   /**
@@ -179,37 +202,11 @@ export class ObjectQLPlugin implements RuntimePlugin {
    * This is the initialization phase
    */
   async onStart(ctx: RuntimeContext): Promise<void> {
-    console.log(`[${this.name}] Starting plugin...`);
+    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);
-  }
   // ---------------------------------------------------
   
   /**
@@ -246,6 +243,16 @@ export class ObjectQLPlugin implements RuntimePlugin {
     };
 
     kernel.find = async (objectName: string, query: any): Promise<{ value: any[]; count: number }> => {
+      // Use QueryService if available for advanced query processing (AST, optimizations)
+      if ((kernel as any).queryService) {
+        const result = await (kernel as any).queryService.find(objectName, query);
+        return { 
+            value: result.value, 
+            count: result.count !== undefined ? result.count : result.value.length 
+        };
+      }
+
+      // Fallback to direct driver call
       const driver = getDriver(objectName);
       const value = await driver.find(objectName, query);
       const count = value.length;
@@ -253,16 +260,30 @@ export class ObjectQLPlugin implements RuntimePlugin {
     };
 
     kernel.get = async (objectName: string, id: string): Promise<any> => {
+      // Use QueryService if available
+      if ((kernel as any).queryService) {
+          const result = await (kernel as any).queryService.findOne(objectName, id);
+          return result.value;
+      }
+
       const driver = getDriver(objectName);
       return await driver.findOne(objectName, id);
     };
 
     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;
+      }
+
       const driver = getDriver(objectName);
       return await driver.count(objectName, filters || {}, {});
     };
 
-    console.log(`[${this.name}] Repository pattern registered`);
+    this.logger.info('Repository pattern registered');
   }
   
   /**
@@ -270,8 +291,41 @@ export class ObjectQLPlugin implements RuntimePlugin {
    * @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`);
+    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
+        const ctx: any = {
+            engine: kernel,
+            getKernel: () => kernel
+        };
+
+        // 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');
+        }
+
+        return this.install(ctx);
+    }
+
+    start = async (kernel: any): Promise<void> => {
+        const ctx: any = {
+            engine: kernel,
+            getKernel: () => kernel
+        };
+        return this.onStart(ctx);
+    }
 }

package/src/protocol.ts

@@ -72,6 +72,19 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         return this.getMetaItem(args);
     }
 
+    /**
+     * Save Metadata Item
+     */
+    async saveMetaItem(args: { type: string; name: string; item?: any }): Promise<{ success: boolean; message?: string }> {
+        const { type, name, item } = args;
+        if (this.engine.metadata && typeof this.engine.metadata.register === 'function') {
+            const data = { ...(item || {}), name }; // Ensure name is in data
+            this.engine.metadata.register(type, data);
+            return { success: true };
+        }
+        throw new Error('Engine does not support saving metadata');
+    }
+
     /**
      * Get UI View
      */

package/src/query/filter-translator.ts

@@ -8,7 +8,7 @@
 
 import type { Filter } from '@objectql/types';
 import { Data } from '@objectstack/spec';
-type FilterCondition = Data.FilterCondition;
+import { z } from 'zod';
 import { ObjectQLError } from '@objectql/types';
 
 /**
@@ -25,7 +25,7 @@ export class FilterTranslator {
     /**
      * Translate filters from ObjectQL format to ObjectStack FilterCondition format
      */
-    translate(filters?: Filter): FilterCondition | undefined {
+    translate(filters?: Filter): Filter | undefined {
         if (!filters) {
             return undefined;
         }
@@ -36,6 +36,6 @@ export class FilterTranslator {
         }
 
         // Both ObjectQL Filter and ObjectStack FilterCondition use the same format now
-        return filters as unknown as FilterCondition;
+        return filters;
     }
 }

package/src/query/query-analyzer.ts

@@ -7,8 +7,7 @@
  */
 
 import type { UnifiedQuery, ObjectConfig, MetadataRegistry } from '@objectql/types';
-import { Data } from '@objectstack/spec';
-type QueryAST = Data.QueryAST;
+import { QueryAST } from '@objectql/types';
 import { QueryService, QueryOptions } from './query-service';
 
 /**

package/src/query/query-builder.ts

@@ -6,16 +6,16 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type { UnifiedQuery } from '@objectql/types';
-import { Data } from '@objectstack/spec';
+import type { UnifiedQuery, QueryAST } from '@objectql/types';
+// import { QueryAST } from './types'; (Removed)
 
 // Local QueryAST type extension to include all properties we need
-interface QueryAST extends Data.QueryAST {
-    top?: number;
-    expand?: Record<string, any>;
-    aggregations?: any[];
-    having?: any;
-}
+// interface QueryAST extends Data.QueryAST {
+//    top?: number;
+//    expand?: Record<string, any>;
+//    aggregations?: any[];
+//    having?: any;
+// }
 
 import { FilterTranslator } from './filter-translator';
 

package/src/query/query-service.ts

@@ -13,9 +13,9 @@ import type {
     Filter,
     MetadataRegistry
 } from '@objectql/types';
-import { Data } from '@objectstack/spec';
-type QueryAST = Data.QueryAST;
+import { QueryAST } from '@objectql/types';
 import { QueryBuilder } from './query-builder';
+import { QueryCompiler } from '../optimizations/QueryCompiler';
 
 /**
  * Options for query execution
@@ -101,12 +101,14 @@ export interface QueryProfile {
  */
 export class QueryService {
     private queryBuilder: QueryBuilder;
+    private queryCompiler: QueryCompiler;
     
     constructor(
         private datasources: Record<string, Driver>,
         private metadata: MetadataRegistry
     ) {
         this.queryBuilder = new QueryBuilder();
+        this.queryCompiler = new QueryCompiler(1000);
     }
     
     /**
@@ -142,7 +144,9 @@ export class QueryService {
      * @private
      */
     private buildQueryAST(objectName: string, query: UnifiedQuery): QueryAST {
-        return this.queryBuilder.build(objectName, query);
+        const ast = this.queryBuilder.build(objectName, query);
+        const compiled = this.queryCompiler.compile(objectName, ast);
+        return compiled.ast;
     }
     
     /**