@objectql/core 4.0.6 → 4.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@objectql/core",
-  "version": "4.0.6",
+  "version": "4.1.0",
   "description": "Universal runtime engine for ObjectQL - AI-native metadata-driven ORM with validation, repository pattern, and driver orchestration",
   "keywords": [
     "objectql",
@@ -23,9 +23,9 @@
     "@objectstack/runtime": "^1.0.0",
     "@objectstack/spec": "^1.0.0",
     "js-yaml": "^4.1.0",
-    "@objectql/plugin-formula": "4.0.6",
-    "@objectql/plugin-validator": "4.0.6",
-    "@objectql/types": "4.0.6"
+    "@objectql/plugin-formula": "4.1.0",
+    "@objectql/plugin-validator": "4.1.0",
+    "@objectql/types": "4.1.0"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.5",

package/src/app.ts

@@ -22,8 +22,10 @@ import {
     ActionContext,
     LoaderPlugin
 } from '@objectql/types';
-import { ObjectKernel, type Plugin } from '@objectstack/core';
+import { ObjectKernel, type Plugin } from '@objectstack/runtime';
 import { ObjectQL as RuntimeObjectQL, SchemaRegistry } from '@objectstack/objectql';
+import { ValidatorPlugin } from '@objectql/plugin-validator';
+import { FormulaPlugin } from '@objectql/plugin-formula';
 import { ObjectRepository } from './repository';
 import { convertIntrospectedSchemaToObjects } from './util';
 import { CompiledHookManager } from './optimizations/CompiledHookManager';
@@ -81,10 +83,27 @@ export class ObjectQL implements IObjectQL {
             }
         }
         
+        // Ensure default plugins are present
+        if (!this.kernelPlugins.some(p => p.name === 'validator')) {
+            this.use(new ValidatorPlugin());
+        }
+        if (!this.kernelPlugins.some(p => p.name === 'formula')) {
+            this.use(new FormulaPlugin());
+        }
+        
         // Create the kernel with registered plugins
-        this.kernel = new (ObjectKernel as any)();
+        this.kernel = new (ObjectKernel as any)(this.kernelPlugins);
         for (const plugin of this.kernelPlugins) {
+             // Fallback for kernels that support .use() but maybe didn't take them in constructor or if we need to support both
+             // NOTE: Modern ObjectKernel takes plugins in constructor.
              if ((this.kernel as any).use) {
+                 // Try to avoid double registration if the kernel is smart, but since we don't know the kernel logic perfectly:
+                 // Ideally check if already added. But for now, we leave this for backward compat 
+                 // if ObjectKernel DOESN't take constructor args but HAS use().
+                 
+                 // However, we just instantiated it.
+                 // Let's assume constructor is the way if available.
+                 // But we keep this check for .use() just in case the constructor signature is different (e.g. empty)
                  (this.kernel as any).use(plugin);
              }
         }
@@ -406,10 +425,10 @@ export class ObjectQL implements IObjectQL {
              for (const plugin of this.kernelPlugins) {
                  try {
                      if (typeof (plugin as any).init === 'function') {
-                         await (plugin as any).init();
+                         await (plugin as any).init(this.kernel);
                      }
                      if (typeof (plugin as any).start === 'function') {
-                         await (plugin as any).start();
+                         await (plugin as any).start(this.kernel);
                      }
                  } catch (error) {
                      console.error(`Failed to initialize plugin ${(plugin as any).name || 'unknown'}:`, error);

package/src/plugin.ts

@@ -246,6 +246,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,11 +263,25 @@ 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 || {}, {});
     };

package/src/query/query-service.ts

@@ -16,6 +16,7 @@ import type {
 import { Data } from '@objectstack/spec';
 type QueryAST = Data.QueryAST;
 import { QueryBuilder } from './query-builder';
+import { QueryCompiler } from '../optimizations/QueryCompiler';
 
 /**
  * Options for query execution
@@ -101,12 +102,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 +145,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;
     }
     
     /**

package/src/repository.ts

@@ -11,64 +11,16 @@ import type { ObjectKernel } from '@objectstack/runtime';
 import { Data } from '@objectstack/spec';
 type QueryAST = Data.QueryAST;
 type SortNode = Data.SortNode;
-import { Validator } from '@objectql/plugin-validator';
-import { FormulaEngine } from '@objectql/plugin-formula';
-import { QueryBuilder } from './query';
-import { QueryCompiler } from './optimizations/QueryCompiler';
-
-/**
- * Extended ObjectStack Kernel with optional ObjectQL plugin capabilities.
- * These properties are attached by ValidatorPlugin and FormulaPlugin during installation.
- */
-interface ExtendedKernel extends ObjectKernel {
-    validator?: Validator;
-    formulaEngine?: FormulaEngine;
-    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>;
-}
 
 export class ObjectRepository {
-    private queryBuilder: QueryBuilder;
-    // Shared query compiler for caching compiled queries
-    private static queryCompiler = new QueryCompiler(1000);
 
     constructor(
         private objectName: string,
         private context: ObjectQLContext,
         private app: IObjectQL
     ) {
-        this.queryBuilder = new QueryBuilder();
     }
     
-    /**
-     * Get validator instance from kernel (via plugin)
-     * Falls back to creating a new instance if not available
-     */
-    private getValidator(): Validator {
-        const kernel = this.getKernel() as ExtendedKernel;
-        if (kernel.validator) {
-            return kernel.validator;
-        }
-        // Fallback for backward compatibility
-        return new Validator();
-    }
-    
-    /**
-     * Get formula engine instance from kernel (via plugin)
-     * Falls back to creating a new instance if not available
-     */
-    private getFormulaEngine(): FormulaEngine {
-        const kernel = this.getKernel() as ExtendedKernel;
-        if (kernel.formulaEngine) {
-            return kernel.formulaEngine;
-        }
-        // Fallback for backward compatibility
-        return new FormulaEngine();
-    }
-
     private getDriver(): Driver {
         const obj = this.getSchema();
         const datasourceName = obj.datasource || 'default';
@@ -86,17 +38,6 @@ export class ObjectRepository {
         };
     }
 
-    /**
-     * Translates ObjectQL UnifiedQuery to ObjectStack QueryAST format
-     * Uses query compiler for caching and optimization
-     */
-    private buildQueryAST(query: UnifiedQuery): QueryAST {
-        const ast = this.queryBuilder.build(this.objectName, query);
-        // Use query compiler to cache and optimize the AST
-        const compiled = ObjectRepository.queryCompiler.compile(this.objectName, ast);
-        return compiled.ast;
-    }
-
     getSchema(): ObjectConfig {
         const obj = this.app.getObject(this.objectName);
         if (!obj) {
@@ -129,148 +70,6 @@ export class ObjectRepository {
         };
     }
 
-    /**
-     * Validates a record against field-level and object-level validation rules.
-     * For updates, only fields present in the update payload are validated at the field level,
-     * while object-level rules use the merged record (previousRecord + updates).
-     */
-    private async validateRecord(
-        operation: 'create' | 'update',
-        record: any,
-        previousRecord?: any
-    ): Promise<void> {
-        const schema = this.getSchema();
-        const allResults: ValidationRuleResult[] = [];
-
-        // 1. Validate field-level rules
-        // For updates, only validate fields that are present in the update payload
-        for (const [fieldName, fieldConfig] of Object.entries(schema.fields)) {
-            // Skip field validation for updates if the field is not in the update payload
-            if (operation === 'update' && !(fieldName in record)) {
-                continue;
-            }
-            
-            const value = record[fieldName];
-            const fieldResults = await this.getValidator().validateField(
-                fieldName,
-                fieldConfig,
-                value,
-                {
-                    record,
-                    previousRecord,
-                    operation,
-                    user: this.getUserFromContext(),
-                    api: this.getHookAPI(),
-                }
-            );
-            allResults.push(...fieldResults);
-        }
-
-        // 2. Validate object-level validation rules
-        if (schema.validation?.rules && schema.validation.rules.length > 0) {
-            // For updates, merge the update data with previous record to get the complete final state
-            const mergedRecord = operation === 'update' && previousRecord
-                ? { ...previousRecord, ...record }
-                : record;
-
-            // Track which fields changed (using shallow comparison for performance)
-            // IMPORTANT: Shallow comparison does not detect changes in nested objects/arrays.
-            // If your validation rules rely on detecting changes in complex nested structures,
-            // you may need to implement custom change tracking in hooks.
-            const changedFields = previousRecord 
-                ? Object.keys(record).filter(key => record[key] !== previousRecord[key])
-                : undefined;
-
-            const validationContext: ValidationContext = {
-                record: mergedRecord,
-                previousRecord,
-                operation,
-                user: this.getUserFromContext(),
-                api: this.getHookAPI(),
-                changedFields,
-            };
-
-            const result = await this.getValidator().validate(schema.validation.rules, validationContext);
-            allResults.push(...result.results);
-        }
-
-        // 3. Collect errors and throw if any
-        const errors = allResults.filter(r => !r.valid && r.severity === 'error');
-        if (errors.length > 0) {
-            const errorMessage = errors.map(e => e.message).join('; ');
-            throw new ValidationError(errorMessage, errors);
-        }
-    }
-
-    /**
-     * Evaluate formula fields for a record
-     * Adds computed formula field values to the record
-     */
-    private evaluateFormulas(record: any): any {
-        const schema = this.getSchema();
-        const now = new Date();
-        
-        // Build formula context
-        const formulaContext: FormulaContext = {
-            record,
-            system: {
-                today: new Date(now.getFullYear(), now.getMonth(), now.getDate()),
-                now: now,
-                year: now.getFullYear(),
-                month: now.getMonth() + 1,
-                day: now.getDate(),
-                hour: now.getHours(),
-                minute: now.getMinutes(),
-                second: now.getSeconds(),
-            },
-            current_user: {
-                id: this.context.userId || '',
-                // TODO: Retrieve actual user name from user object if available
-                name: undefined,
-                email: undefined,
-                role: this.context.roles?.[0],
-            },
-            is_new: false,
-            record_id: record._id || record.id,
-        };
-
-        // Evaluate each formula field
-        for (const [fieldName, fieldConfig] of Object.entries(schema.fields)) {
-            const formulaExpression = fieldConfig.expression;
-            
-            if (fieldConfig.type === 'formula' && formulaExpression) {
-                const result = this.getFormulaEngine().evaluate(
-                    formulaExpression,
-                    formulaContext,
-                    fieldConfig.data_type || 'text',
-                    { strict: true }
-                );
-
-                if (result.success) {
-                    record[fieldName] = result.value;
-                } else {
-                    // In case of error, set to null and log for diagnostics
-                    record[fieldName] = null;
-                    // Formula evaluation should not throw here, but we need observability
-                    // This logging is intentionally minimal and side-effect free
-                     
-                    console.error(
-                        '[ObjectQL][FormulaEngine] Formula evaluation failed',
-                        {
-                            objectName: this.objectName,
-                            fieldName,
-                            recordId: formulaContext.record_id,
-                            expression: formulaExpression,
-                            error: result.error,
-                            stack: result.stack,
-                        }
-                    );
-                }
-            }
-        }
-
-        return record;
-    }
 
     async find(query: UnifiedQuery = {}): Promise<any[]> {
         const hookCtx: RetrievalHookContext = {
@@ -284,15 +83,12 @@ export class ObjectRepository {
         };
         await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
 
-        // Build QueryAST and execute via kernel
-        const ast = this.buildQueryAST(hookCtx.query || {});
-        const kernelResult = await (this.getKernel() as any).find(this.objectName, ast);
+        // Execute via kernel (delegates to QueryService)
+        const kernelResult = await (this.getKernel() as any).find(this.objectName, hookCtx.query || {});
         const results = kernelResult.value;
         
-        // Evaluate formulas for each result
-        const resultsWithFormulas = results.map((record: any) => this.evaluateFormulas(record));
-        
-        hookCtx.result = resultsWithFormulas;
+        // Formula evaluation moved to FormulaPlugin hook
+        hookCtx.result = results;
         await this.app.triggerHook('afterFind', this.objectName, hookCtx);
 
         return hookCtx.result as any[];
@@ -314,10 +110,8 @@ export class ObjectRepository {
             // Use kernel.get() for direct ID lookup
             const result = await (this.getKernel() as any).get(this.objectName, String(idOrQuery));
 
-            // Evaluate formulas if result exists
-            const resultWithFormulas = result ? this.evaluateFormulas(result) : result;
-
-            hookCtx.result = resultWithFormulas;
+            // Formula evaluation moved to FormulaPlugin hook
+            hookCtx.result = result;
             await this.app.triggerHook('afterFind', this.objectName, hookCtx);
             return hookCtx.result;
         } else {
@@ -354,10 +148,8 @@ export class ObjectRepository {
         };
         await this.app.triggerHook('beforeCount', this.objectName, hookCtx);
 
-        // Build QueryAST and execute via kernel to get count
-        const ast = this.buildQueryAST(hookCtx.query || {});
-        const kernelResult = await (this.getKernel() as any).find(this.objectName, ast);
-        const result = kernelResult.count;
+        // Execute via kernel (delegates to QueryService)
+        const result = await (this.getKernel() as any).count(this.objectName, hookCtx.query || {});
 
         hookCtx.result = result;
         await this.app.triggerHook('afterCount', this.objectName, hookCtx);
@@ -380,8 +172,7 @@ export class ObjectRepository {
         if (this.context.userId) finalDoc.created_by = this.context.userId;
         if (this.context.spaceId) finalDoc.space_id = this.context.spaceId;
         
-        // Validate the record before creating
-        await this.validateRecord('create', finalDoc);
+        // Validation moved to ValidatorPlugin hook
         
         // Execute via kernel
         const result = await (this.getKernel() as any).create(this.objectName, finalDoc, this.getOptions());
@@ -407,8 +198,7 @@ export class ObjectRepository {
         };
         await this.app.triggerHook('beforeUpdate', this.objectName, hookCtx);
 
-        // Validate the update
-        await this.validateRecord('update', hookCtx.data, previousData);
+        // Validation moved to ValidatorPlugin hook
 
         // Execute via kernel
         const result = await (this.getKernel() as any).update(this.objectName, String(id), hookCtx.data, this.getOptions());

package/test/app.test.ts

@@ -295,12 +295,12 @@ describe('ObjectQL App', () => {
 
     describe('Plugin System', () => {
         it('should initialize runtime plugins on init', async () => {
-            const initFn = jest.fn();
-            const startFn = jest.fn();
+            const installFn = jest.fn();
+            const onStartFn = jest.fn();
             const mockPlugin = {
                 name: 'test-plugin',
-                init: initFn,
-                start: startFn
+                install: installFn,
+                onStart: onStartFn
             };
 
             const app = new ObjectQL({
@@ -309,8 +309,8 @@ describe('ObjectQL App', () => {
             });
 
             await app.init();
-            expect(initFn).toHaveBeenCalled();
-            expect(startFn).toHaveBeenCalled();
+            expect(installFn).toHaveBeenCalled();
+            expect(onStartFn).toHaveBeenCalled();
         });
 
         it('should use plugin method', () => {