@objectql/core 4.0.5 → 4.1.0

package/src/protocol.ts

@@ -246,4 +246,46 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         // Not implemented in this shim yet
         throw new Error('Action execution not implemented in protocol shim');
     }
+
+    /**
+     * Analytics Query - Execute analytics query
+     */
+    async analyticsQuery(args: any): Promise<any> {
+        throw new Error('analyticsQuery not implemented');
+    }
+
+    /**
+     * Get Analytics Metadata
+     */
+    async getAnalyticsMeta(args: any): Promise<any> {
+        throw new Error('getAnalyticsMeta not implemented');
+    }
+
+    /**
+     * Trigger Automation
+     */
+    async triggerAutomation(args: { trigger: string; payload: Record<string, any> }): Promise<{ success: boolean; jobId?: string; result?: any }> {
+        throw new Error('triggerAutomation not implemented');
+    }
+
+    /**
+     * List Spaces (Hub/Workspace Management)
+     */
+    async listSpaces(args: any): Promise<any> {
+        throw new Error('listSpaces not implemented');
+    }
+
+    /**
+     * Create Space (Hub/Workspace Management)
+     */
+    async createSpace(args: any): Promise<any> {
+        throw new Error('createSpace not implemented');
+    }
+
+    /**
+     * Install Plugin (Hub/Extension Management)
+     */
+    async installPlugin(args: any): Promise<any> {
+        throw new Error('installPlugin not implemented');
+    }
 }

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/__mocks__/@objectstack/core.ts

@@ -0,0 +1,27 @@
+/**
+ * ObjectQL
+ * 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.
+ */
+
+/**
+ * Mock for @objectstack/core to enable Jest testing
+ * 
+ * Since @objectstack/core@0.9.2 uses ES modules with import.meta,
+ * which Jest doesn't support well, we provide this mock for testing.
+ */
+
+export const createLogger = jest.fn(() => ({
+  trace: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn(),
+  fatal: jest.fn(),
+}));
+
+export const ObjectKernel = jest.fn();
+export const LiteKernel = jest.fn();
+export const createApiRegistryPlugin = jest.fn();

package/test/__mocks__/@objectstack/objectql.ts

@@ -0,0 +1,45 @@
+/**
+ * ObjectQL
+ * 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.
+ */
+
+/**
+ * Mock for @objectstack/objectql to enable Jest testing
+ */
+
+export class ObjectQL {
+  constructor(public config: any) {}
+  async connect() {}
+  async disconnect() {}
+}
+
+const mockStore = new Map<string, Map<string, any>>();
+
+export const SchemaRegistry = {
+  register: jest.fn(),
+  get: jest.fn(),
+  registerItem: jest.fn((type: string, item: any, keyField: string = 'name') => {
+    if (!mockStore.has(type)) {
+      mockStore.set(type, new Map());
+    }
+    const key = item[keyField];
+    mockStore.get(type)!.set(key, item);
+  }),
+  unregisterItem: jest.fn((type: string, name: string) => {
+    const collection = mockStore.get(type);
+    if (collection) {
+      collection.delete(name);
+    }
+  }),
+  getItem: jest.fn((type: string, name: string) => {
+    return mockStore.get(type)?.get(name);
+  }),
+  listItems: jest.fn((type: string) => {
+    const items = mockStore.get(type);
+    return items ? Array.from(items.values()) : [];
+  }),
+  metadata: mockStore,
+};

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/gateway.test.ts

@@ -0,0 +1,88 @@
+/**
+ * ObjectQL
+ * 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 { ObjectGateway } from '../src/gateway';
+import { ApiRequest, ApiResponse, GatewayProtocol } from '@objectql/types';
+
+describe('ObjectGateway', () => {
+    let gateway: ObjectGateway;
+    let mockProtocol: GatewayProtocol;
+
+    beforeEach(() => {
+        gateway = new ObjectGateway();
+        mockProtocol = {
+            name: 'mock',
+            route: jest.fn().mockReturnValue(true),
+            handle: jest.fn().mockResolvedValue({ status: 200, body: 'ok' })
+        };
+        gateway.registerProtocol(mockProtocol);
+    });
+
+    it('should route request to registered protocol', async () => {
+        const req: ApiRequest = {
+            path: '/test',
+            method: 'GET',
+            headers: {},
+            query: {}
+        };
+        
+        const response = await gateway.handle(req);
+        
+        expect(mockProtocol.route).toHaveBeenCalledWith(req);
+        expect(mockProtocol.handle).toHaveBeenCalledWith(req);
+        expect(response.status).toBe(200);
+    });
+
+    it('should return 404 if no protocol matches', async () => {
+        const specializedGateway = new ObjectGateway();
+        const response = await specializedGateway.handle({
+            path: '/unknown',
+            method: 'GET',
+            headers: {},
+            query: {}
+        });
+        
+        expect(response.status).toBe(404);
+        expect(response.body.error.code).toBe('PROTOCOL_NOT_FOUND');
+    });
+
+    it('should apply request transformers', async () => {
+        const req: ApiRequest = {
+            path: '/original',
+            method: 'GET',
+            headers: {},
+            query: {}
+        };
+
+        gateway.addRequestTransform(async (r) => {
+            return { ...r, path: '/transformed' };
+        });
+
+        await gateway.handle(req);
+        
+        // Protocol should see the transformed request
+        expect(mockProtocol.route).toHaveBeenCalledWith(expect.objectContaining({ path: '/transformed' }));
+    });
+
+    it('should apply response transformers', async () => {
+        const req: ApiRequest = {
+            path: '/test',
+            method: 'GET',
+            headers: {},
+            query: {}
+        };
+
+        gateway.addResponseTransform(async (res) => {
+            return { ...res, headers: { ...res.headers, 'X-Custom': 'Added' } };
+        });
+
+        const response = await gateway.handle(req);
+        
+        expect(response.headers?.['X-Custom']).toBe('Added');
+    });
+});