@objectql/core 4.0.6 → 4.2.0

package/src/repository.ts

@@ -6,69 +6,21 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { ObjectQLContext, IObjectQL, ObjectConfig, Driver, UnifiedQuery, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext, ValidationContext, ValidationError, ValidationRuleResult, FormulaContext, Filter } from '@objectql/types';
+import { ObjectQLContext, IObjectQL, ObjectConfig, Driver, UnifiedQuery, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext, ValidationContext, ValidationError, ValidationRuleResult, FormulaContext, Filter, QueryAST } from '@objectql/types';
 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>;
-}
+import { z } from 'zod';
+type SortNode = z.infer<typeof Data.SortNodeSchema>;
 
 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,15 @@ 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)
+        let result: number;
+        const kernel = this.getKernel() as any;
+        if (typeof kernel.count === 'function') {
+            result = await kernel.count(this.objectName, hookCtx.query || {});
+        } else {
+            // Fallback to driver if kernel doesn't support count
+            result = await this.getDriver().count(this.objectName, hookCtx.query || {});
+        }
 
         hookCtx.result = result;
         await this.app.triggerHook('afterCount', this.objectName, hookCtx);
@@ -380,8 +179,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 +205,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/ai-registry.test.ts

@@ -0,0 +1,42 @@
+/**
+ * ObjectQL - AI Registry Tests
+ * 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 { createDefaultAiRegistry } from '../src/ai';
+
+describe('AI Registry', () => {
+  it('registers and retrieves models', () => {
+    const registry = createDefaultAiRegistry();
+
+    registry.models.register({
+      id: 'embed-small',
+      provider: 'openai',
+      model: 'text-embedding-3-small',
+      type: 'embedding',
+      embeddingDimensions: 1536,
+    });
+
+    const model = registry.models.get('embed-small');
+    expect(model?.model).toBe('text-embedding-3-small');
+    expect(registry.models.list().length).toBe(1);
+  });
+
+  it('registers and retrieves prompt templates', () => {
+    const registry = createDefaultAiRegistry();
+
+    registry.prompts.register({
+      id: 'greeting',
+      template: 'Hello, {{name}}!',
+      variables: ['name'],
+      version: 'v1',
+    });
+
+    const prompt = registry.prompts.get('greeting', 'v1');
+    expect(prompt?.template).toBe('Hello, {{name}}!');
+    expect(registry.prompts.list('greeting').length).toBe(1);
+  });
+});

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', () => {

package/test/optimizations.test.ts

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { describe, it, expect, beforeEach } from '@jest/globals';
+// import { describe, it, expect, beforeEach } from '@jest/globals';
 import {
     OptimizedMetadataRegistry,
     QueryCompiler,

package/test/plugin-integration.test.ts

@@ -9,10 +9,11 @@
 import { ObjectQLPlugin } from '../src/plugin';
 import { ValidatorPlugin } from '@objectql/plugin-validator';
 import { FormulaPlugin } from '@objectql/plugin-formula';
+import { vi } from 'vitest';
 
 // Mock the sub-plugins
-jest.mock('@objectql/plugin-validator');
-jest.mock('@objectql/plugin-formula');
+vi.mock('@objectql/plugin-validator');
+vi.mock('@objectql/plugin-formula');
 
 describe('ObjectQLPlugin Integration', () => {
     let plugin: ObjectQLPlugin;