@objectql/core 4.0.1 → 4.0.3

package/src/query/query-analyzer.ts

@@ -9,7 +9,6 @@
 import type { UnifiedQuery, ObjectConfig, MetadataRegistry } from '@objectql/types';
 import { Data } from '@objectstack/spec';
 type QueryAST = Data.QueryAST;
-type FilterNode = Data.FilterNode;
 import { QueryService, QueryOptions } from './query-service';
 
 /**
@@ -167,10 +166,10 @@ export class QueryAnalyzer {
         // Build the QueryAST (without executing)
         const ast: QueryAST = {
             object: objectName,
-            filters: query.filters as any, // FilterCondition is compatible with FilterNode
-            sort: query.sort as any, // Will be converted to SortNode[] format
-            top: query.limit, // Changed from limit to top (QueryAST uses 'top')
-            skip: query.skip,
+            where: query.where as any, // FilterCondition format
+            orderBy: query.orderBy as any, // Will be converted to SortNode[] format
+            limit: query.limit,
+            offset: query.offset,
             fields: query.fields
         };
         
@@ -273,7 +272,7 @@ export class QueryAnalyzer {
      * @private
      */
     private getSchema(objectName: string): ObjectConfig {
-        const obj = this.metadata.get<ObjectConfig>('object', objectName);
+        const obj = this.metadata.get('object', objectName);
         if (!obj) {
             throw new Error(`Object '${objectName}' not found`);
         }
@@ -287,7 +286,7 @@ export class QueryAnalyzer {
     private findApplicableIndexes(schema: ObjectConfig, query: UnifiedQuery): string[] {
         const indexes: string[] = [];
         
-        if (!schema.indexes || !query.filters) {
+        if (!schema.indexes || !query.where) {
             return indexes;
         }
         
@@ -316,7 +315,7 @@ export class QueryAnalyzer {
             }
         };
         
-        extractFieldsFromFilter(query.filters);
+        extractFieldsFromFilter(query.where);
         
         // Check which indexes could be used
         const indexesArray = Array.isArray(schema.indexes) ? schema.indexes : Object.values(schema.indexes || {});
@@ -343,7 +342,7 @@ export class QueryAnalyzer {
         const warnings: string[] = [];
         
         // Warning: No filters (full table scan)
-        if (!query.filters || query.filters.length === 0) {
+        if (!query.where || Object.keys(query.where).length === 0) {
             warnings.push('No filters specified - this will scan all records');
         }
         
@@ -361,7 +360,7 @@ export class QueryAnalyzer {
         }
         
         // Warning: Complex filters without indexes
-        if (query.filters && query.filters.length > 5) {
+        if (query.where && Object.keys(query.where).length > 5) {
             const indexes = this.findApplicableIndexes(schema, query);
             if (indexes.length === 0) {
                 warnings.push('Complex filters without matching indexes - consider adding indexes');
@@ -388,10 +387,8 @@ export class QueryAnalyzer {
         }
         
         // Suggest adding indexes
-        if (query.filters && query.filters.length > 0 && indexes.length === 0) {
-            const filterFields = query.filters
-                .filter((f: any) => Array.isArray(f) && f.length >= 1)
-                .map((f: any) => String(f[0]));
+        if (query.where && Object.keys(query.where).length > 0 && indexes.length === 0) {
+            const filterFields = Object.keys(query.where).filter(k => !k.startsWith('$'));
             
             if (filterFields.length > 0) {
                 suggestions.push(`Consider adding an index on: ${filterFields.join(', ')}`);
@@ -404,10 +401,9 @@ export class QueryAnalyzer {
         }
         
         // Suggest composite index for multiple filters
-        if (query.filters && query.filters.length > 1 && indexes.length < 2) {
-            const filterFields = query.filters
-                .filter((f: any) => Array.isArray(f) && f.length >= 1)
-                .map((f: any) => String(f[0]))
+        if (query.where && Object.keys(query.where).length > 1 && indexes.length < 2) {
+            const filterFields = Object.keys(query.where)
+                .filter(k => !k.startsWith('$'))
                 .slice(0, 3); // Top 3 fields
             
             if (filterFields.length > 1) {
@@ -429,21 +425,20 @@ export class QueryAnalyzer {
         complexity += 10;
         
         // Filters add complexity
-        if (query.filters) {
-            complexity += query.filters.length * 5;
+        if (query.where) {
+            const filterCount = Object.keys(query.where).length;
+            complexity += filterCount * 5;
             
-            // Nested filters (OR conditions) add more
-            const hasNestedFilters = query.filters.some((f: any) => 
-                Array.isArray(f) && Array.isArray(f[0])
-            );
-            if (hasNestedFilters) {
+            // Nested filters (OR/AND conditions) add more
+            const hasLogicalOps = query.where.$and || query.where.$or;
+            if (hasLogicalOps) {
                 complexity += 15;
             }
         }
         
         // Sorting adds complexity
-        if (query.sort && query.sort.length > 0) {
-            complexity += query.sort.length * 3;
+        if (query.orderBy && query.orderBy.length > 0) {
+            complexity += query.orderBy.length * 3;
         }
         
         // Field selection reduces complexity slightly
@@ -469,13 +464,14 @@ export class QueryAnalyzer {
         // from the database (row count, index selectivity, etc.)
         
         // Default to unknown
-        if (!query.filters || query.filters.length === 0) {
+        if (!query.where || Object.keys(query.where).length === 0) {
             return -1; // Unknown, full scan
         }
         
         // Very rough estimate based on filter count
         const baseEstimate = 1000;
-        const filterReduction = Math.pow(0.5, query.filters.length);
+        const filterCount = Object.keys(query.where).length;
+        const filterReduction = Math.pow(0.5, filterCount);
         const estimated = Math.floor(baseEstimate * filterReduction);
         
         // Apply limit if present

package/src/query/query-builder.ts

@@ -8,14 +8,23 @@
 
 import type { UnifiedQuery } from '@objectql/types';
 import { Data } from '@objectstack/spec';
-type QueryAST = Data.QueryAST;
+
+// 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;
+}
+
 import { FilterTranslator } from './filter-translator';
 
 /**
  * Query Builder
  * 
  * Builds ObjectStack QueryAST from ObjectQL UnifiedQuery.
- * This is the central query construction module for ObjectQL.
+ * Since UnifiedQuery now uses the standard protocol format directly,
+ * this is now a simple pass-through with object name injection.
  */
 export class QueryBuilder {
     private filterTranslator: FilterTranslator;
@@ -28,53 +37,27 @@ export class QueryBuilder {
      * Build a QueryAST from a UnifiedQuery
      * 
      * @param objectName - Target object name
-     * @param query - ObjectQL UnifiedQuery
+     * @param query - ObjectQL UnifiedQuery (now in standard QueryAST format)
      * @returns ObjectStack QueryAST
      */
     build(objectName: string, query: UnifiedQuery): QueryAST {
+        // UnifiedQuery now uses the same format as QueryAST
+        // Just add the object name and pass through
         const ast: QueryAST = {
-            object: objectName,
+            object: objectName
         };
 
-        // Map fields
-        if (query.fields) {
-            ast.fields = query.fields;
-        }
-
-        // Map filters using FilterTranslator
-        if (query.filters) {
-            ast.filters = this.filterTranslator.translate(query.filters);
-        }
-
-        // Map sort
-        if (query.sort) {
-            ast.sort = query.sort.map(([field, order]) => ({
-                field,
-                order: order as 'asc' | 'desc'
-            }));
-        }
-
-        // Map pagination
-        if (query.limit !== undefined) {
-            ast.top = query.limit;
-        }
-        if (query.skip !== undefined) {
-            ast.skip = query.skip;
-        }
-
-        // Map groupBy
-        if (query.groupBy) {
-            ast.groupBy = query.groupBy;
-        }
-
-        // Map aggregations
-        if (query.aggregate) {
-            ast.aggregations = query.aggregate.map(agg => ({
-                function: agg.func as any,
-                field: agg.field,
-                alias: agg.alias || `${agg.func}_${agg.field}`
-            }));
-        }
+        // Map UnifiedQuery properties to QueryAST
+        if (query.fields) ast.fields = query.fields;
+        if (query.where) ast.where = this.filterTranslator.translate(query.where);
+        if (query.orderBy) ast.orderBy = query.orderBy;
+        if (query.offset !== undefined) ast.offset = query.offset;
+        if (query.limit !== undefined) ast.top = query.limit; // UnifiedQuery uses 'limit', QueryAST uses 'top'
+        if (query.expand) ast.expand = query.expand;
+        if (query.groupBy) ast.groupBy = query.groupBy;
+        if (query.aggregations) ast.aggregations = query.aggregations;
+        if (query.having) ast.having = query.having;
+        if (query.distinct) ast.distinct = query.distinct;
 
         return ast;
     }

package/src/query/query-service.ts

@@ -130,7 +130,7 @@ export class QueryService {
      * @private
      */
     private getSchema(objectName: string): ObjectConfig {
-        const obj = this.metadata.get<ObjectConfig>('object', objectName);
+        const obj = this.metadata.get('object', objectName);
         if (!obj) {
             throw new Error(`Object '${objectName}' not found in metadata`);
         }
@@ -232,7 +232,7 @@ export class QueryService {
         } else if (driver.executeQuery) {
             // Fallback to query with ID filter
             const query: UnifiedQuery = {
-                filters: [['_id', '=', id]]
+                where: { _id: id }
             };
             const ast = this.buildQueryAST(objectName, query);
             const queryResult = await driver.executeQuery(ast, driverOptions);
@@ -256,19 +256,19 @@ export class QueryService {
      * Execute a count query
      * 
      * @param objectName - The object to query
-     * @param filters - Optional filters
+     * @param where - Optional filter condition
      * @param options - Query execution options
      * @returns Count of matching records
      */
     async count(
         objectName: string, 
-        filters?: Filter[], 
+        where?: Filter, 
         options: QueryOptions = {}
     ): Promise<QueryResult<number>> {
         const driver = this.getDriver(objectName);
         const startTime = options.profile ? Date.now() : 0;
         
-        const query: UnifiedQuery = filters ? { filters } : {};
+        const query: UnifiedQuery = where ? { where } : {};
         const ast = this.buildQueryAST(objectName, query);
         
         const driverOptions = {
@@ -280,7 +280,7 @@ export class QueryService {
         
         if (driver.count) {
             // Legacy driver interface
-            count = await driver.count(objectName, filters || [], driverOptions);
+            count = await driver.count(objectName, where || {}, driverOptions);
         } else if (driver.executeQuery) {
             // Use executeQuery and count results
             // Note: This is inefficient for large datasets

package/src/repository.ts

@@ -7,26 +7,33 @@
  */
 
 import { ObjectQLContext, IObjectQL, ObjectConfig, Driver, UnifiedQuery, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext, ValidationContext, ValidationError, ValidationRuleResult, FormulaContext, Filter } from '@objectql/types';
-import type { ObjectStackKernel } from '@objectql/runtime';
+import type { ObjectKernel } from '@objectstack/runtime';
 import { Data } from '@objectstack/spec';
 type QueryAST = Data.QueryAST;
-type FilterNode = Data.FilterNode;
 type SortNode = Data.SortNode;
-import { Validator } from './validator';
-import { FormulaEngine } from './formula-engine';
+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 ObjectStackKernel {
+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,
@@ -68,7 +75,7 @@ export class ObjectRepository {
         return this.app.datasource(datasourceName);
     }
     
-    private getKernel(): ObjectStackKernel {
+    private getKernel(): ObjectKernel {
         return this.app.getKernel();
     }
 
@@ -81,9 +88,13 @@ export class ObjectRepository {
 
     /**
      * Translates ObjectQL UnifiedQuery to ObjectStack QueryAST format
+     * Uses query compiler for caching and optimization
      */
     private buildQueryAST(query: UnifiedQuery): QueryAST {
-        return this.queryBuilder.build(this.objectName, query);
+        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 {
@@ -225,9 +236,11 @@ export class ObjectRepository {
 
         // Evaluate each formula field
         for (const [fieldName, fieldConfig] of Object.entries(schema.fields)) {
-            if (fieldConfig.type === 'formula' && fieldConfig.formula) {
+            const formulaExpression = fieldConfig.expression;
+            
+            if (fieldConfig.type === 'formula' && formulaExpression) {
                 const result = this.getFormulaEngine().evaluate(
-                    fieldConfig.formula,
+                    formulaExpression,
                     formulaContext,
                     fieldConfig.data_type || 'text',
                     { strict: true }
@@ -240,14 +253,14 @@ export class ObjectRepository {
                     record[fieldName] = null;
                     // Formula evaluation should not throw here, but we need observability
                     // This logging is intentionally minimal and side-effect free
-                    // eslint-disable-next-line no-console
+                     
                     console.error(
                         '[ObjectQL][FormulaEngine] Formula evaluation failed',
                         {
                             objectName: this.objectName,
                             fieldName,
                             recordId: formulaContext.record_id,
-                            formula: fieldConfig.formula,
+                            expression: formulaExpression,
                             error: result.error,
                             stack: result.stack,
                         }
@@ -273,7 +286,7 @@ export class ObjectRepository {
 
         // Build QueryAST and execute via kernel
         const ast = this.buildQueryAST(hookCtx.query || {});
-        const kernelResult = await this.getKernel().find(this.objectName, ast);
+        const kernelResult = await (this.getKernel() as any).find(this.objectName, ast);
         const results = kernelResult.value;
         
         // Evaluate formulas for each result
@@ -299,7 +312,7 @@ export class ObjectRepository {
             await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
             
             // Use kernel.get() for direct ID lookup
-            const result = await this.getKernel().get(this.objectName, String(idOrQuery));
+            const result = await (this.getKernel() as any).get(this.objectName, String(idOrQuery));
 
             // Evaluate formulas if result exists
             const resultWithFormulas = result ? this.evaluateFormulas(result) : result;
@@ -319,13 +332,13 @@ export class ObjectRepository {
         // If filters is already a UnifiedQuery (has UnifiedQuery-specific properties), use it as-is
         let query: UnifiedQuery;
         if (Array.isArray(filters)) {
-            query = { filters };
-        } else if (filters && typeof filters === 'object' && (filters.fields || filters.sort || filters.limit !== undefined || filters.skip !== undefined)) {
+            query = { where: filters };
+        } else if (filters && typeof filters === 'object' && (filters.fields || filters.orderBy || filters.limit !== undefined || filters.offset !== undefined)) {
             // It's already a UnifiedQuery object
             query = filters;
         } else if (filters) {
             // It's a raw filter object, wrap it
-            query = { filters };
+            query = { where: filters };
         } else {
             query = {};
         }
@@ -343,7 +356,7 @@ export class ObjectRepository {
 
         // Build QueryAST and execute via kernel to get count
         const ast = this.buildQueryAST(hookCtx.query || {});
-        const kernelResult = await this.getKernel().find(this.objectName, ast);
+        const kernelResult = await (this.getKernel() as any).find(this.objectName, ast);
         const result = kernelResult.count;
 
         hookCtx.result = result;
@@ -371,7 +384,7 @@ export class ObjectRepository {
         await this.validateRecord('create', finalDoc);
         
         // Execute via kernel
-        const result = await this.getKernel().create(this.objectName, finalDoc);
+        const result = await (this.getKernel() as any).create(this.objectName, finalDoc, this.getOptions());
         
         hookCtx.result = result;
         await this.app.triggerHook('afterCreate', this.objectName, hookCtx);
@@ -398,7 +411,7 @@ export class ObjectRepository {
         await this.validateRecord('update', hookCtx.data, previousData);
 
         // Execute via kernel
-        const result = await this.getKernel().update(this.objectName, String(id), hookCtx.data);
+        const result = await (this.getKernel() as any).update(this.objectName, String(id), hookCtx.data, this.getOptions());
 
         hookCtx.result = result;
         await this.app.triggerHook('afterUpdate', this.objectName, hookCtx);
@@ -420,7 +433,7 @@ export class ObjectRepository {
         await this.app.triggerHook('beforeDelete', this.objectName, hookCtx);
 
         // Execute via kernel
-        const result = await this.getKernel().delete(this.objectName, String(id));
+        const result = await (this.getKernel() as any).delete(this.objectName, String(id), this.getOptions());
 
         hookCtx.result = result;
         await this.app.triggerHook('afterDelete', this.objectName, hookCtx);
@@ -463,7 +476,7 @@ export class ObjectRepository {
     async updateMany(filters: any, data: any): Promise<any> {
         // Find all matching records and update them individually
         // to ensure validation and hooks are executed
-        const records = await this.find({ filters });
+        const records = await this.find({ where: filters });
         let count = 0;
         for (const record of records) {
             if (record && record._id) {
@@ -477,7 +490,7 @@ export class ObjectRepository {
     async deleteMany(filters: any): Promise<any> {
         // Find all matching records and delete them individually
         // to ensure hooks are executed
-        const records = await this.find({ filters });
+        const records = await this.find({ where: filters });
         let count = 0;
         for (const record of records) {
             if (record && record._id) {

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

@@ -1,5 +1,5 @@
 /**
- * Mock for @objectql/runtime
+ * Mock for @objectstack/runtime
  * This mock is needed because the npm package has issues with Jest
  * and we want to focus on testing ObjectQL's logic, not the kernel integration.
  * 
@@ -123,7 +123,7 @@ class MockActionManager {
     }
 }
 
-export class ObjectStackKernel {
+export class ObjectKernel {
     public ql: unknown = null;
     public metadata: MockMetadataRegistry;
     public hooks: MockHookManager;
@@ -242,14 +242,14 @@ export class ObjectStackKernel {
     }
 }
 
-export class ObjectStackRuntimeProtocol {}
+export class ObjectStackProtocolImplementation {}
 
-export interface RuntimeContext {
-    engine: ObjectStackKernel;
+export interface any {
+    engine: ObjectKernel;
 }
 
-export interface RuntimePlugin {
+export interface ObjectQLPlugin {
     name: string;
-    install?: (ctx: RuntimeContext) => void | Promise<void>;
-    onStart?: (ctx: RuntimeContext) => void | Promise<void>;
+    install?: (ctx: any) => void | Promise<void>;
+    onStart?: (ctx: any) => void | Promise<void>;
 }

package/test/app.test.ts

@@ -9,7 +9,8 @@
 import { ObjectQL } from '../src/app';
 import { MockDriver } from './mock-driver';
 import { ObjectConfig, HookContext, ActionContext, Metadata } from '@objectql/types';
-import type { PluginDefinition } from '@objectstack/spec';
+import type { Kernel } from '@objectstack/spec';
+type PluginDefinition = Kernel.PluginDefinition;
 
 const todoObject: ObjectConfig = {
     name: 'todo',
@@ -268,6 +269,8 @@ describe('ObjectQL App', () => {
             const entry: Metadata = {
                 type: 'object',
                 id: 'todo',
+                // @ts-expect-error - SchemaRegistry typing limitation
+                name: 'todo', // Ensure SchemaRegistry keys it correctly
                 package: 'test-package',
                 content: obj
             };
@@ -292,12 +295,12 @@ describe('ObjectQL App', () => {
 
     describe('Plugin System', () => {
         it('should initialize runtime plugins on init', async () => {
-            const installFn = jest.fn();
-            const onStartFn = jest.fn();
+            const initFn = jest.fn();
+            const startFn = jest.fn();
             const mockPlugin = {
                 name: 'test-plugin',
-                install: installFn,
-                onStart: onStartFn
+                init: initFn,
+                start: startFn
             };
 
             const app = new ObjectQL({
@@ -306,14 +309,14 @@ describe('ObjectQL App', () => {
             });
 
             await app.init();
-            expect(installFn).toHaveBeenCalled();
-            expect(onStartFn).toHaveBeenCalled();
+            expect(initFn).toHaveBeenCalled();
+            expect(startFn).toHaveBeenCalled();
         });
 
         it('should use plugin method', () => {
             const mockPlugin = {
                 name: 'test-plugin',
-                install: jest.fn()
+                init: jest.fn()
             };
 
             const app = new ObjectQL({ datasources: {} });