@objectql/core 4.0.0 → 4.0.2

package/src/query/filter-translator.ts

@@ -7,141 +7,35 @@
  */
 
 import type { Filter } from '@objectql/types';
-import type { FilterNode } from '@objectstack/spec';
+import { Data } from '@objectstack/spec';
+type FilterCondition = Data.FilterCondition;
 import { ObjectQLError } from '@objectql/types';
 
 /**
  * Filter Translator
  * 
- * Translates ObjectQL Filter (FilterCondition) to ObjectStack FilterNode format.
- * Converts modern object-based syntax to legacy array-based syntax for backward compatibility.
+ * Translates ObjectQL Filter to ObjectStack FilterCondition format.
+ * Since both now use the same format, this is mostly a pass-through.
  * 
  * @example
  * Input:  { age: { $gte: 18 }, $or: [{ status: "active" }, { role: "admin" }] }
- * Output: [["age", ">=", 18], "or", [["status", "=", "active"], "or", ["role", "=", "admin"]]]
+ * Output: { age: { $gte: 18 }, $or: [{ status: "active" }, { role: "admin" }] }
  */
 export class FilterTranslator {
     /**
-     * Translate filters from ObjectQL format to ObjectStack FilterNode format
+     * Translate filters from ObjectQL format to ObjectStack FilterCondition format
      */
-    translate(filters?: Filter): FilterNode | undefined {
+    translate(filters?: Filter): FilterCondition | undefined {
         if (!filters) {
             return undefined;
         }
 
-        // Backward compatibility: if it's already an array (old format), pass through
-        if (Array.isArray(filters)) {
-            return filters as unknown as FilterNode;
-        }
-
         // If it's an empty object, return undefined
         if (typeof filters === 'object' && Object.keys(filters).length === 0) {
             return undefined;
         }
 
-        return this.convertToNode(filters);
-    }
-
-    /**
-     * Recursively converts FilterCondition to FilterNode array format
-     */
-    private convertToNode(filter: Filter): FilterNode {
-        const nodes: any[] = [];
-        
-        // Process logical operators first
-        if (filter.$and) {
-            const andNodes = filter.$and.map((f: Filter) => this.convertToNode(f));
-            nodes.push(...this.interleaveWithOperator(andNodes, 'and'));
-        }
-        
-        if (filter.$or) {
-            const orNodes = filter.$or.map((f: Filter) => this.convertToNode(f));
-            if (nodes.length > 0) {
-                nodes.push('and');
-            }
-            nodes.push(...this.interleaveWithOperator(orNodes, 'or'));
-        }
-        
-        // Note: $not operator is not currently supported in the legacy FilterNode format
-        if (filter.$not) {
-            throw new ObjectQLError({
-                code: 'UNSUPPORTED_OPERATOR',
-                message: '$not operator is not supported. Use $ne for field negation instead.'
-            });
-        }
-        
-        // Process field conditions
-        for (const [field, value] of Object.entries(filter)) {
-            if (field.startsWith('$')) {
-                continue; // Skip logical operators (already processed)
-            }
-            
-            if (nodes.length > 0) {
-                nodes.push('and');
-            }
-            
-            // Handle field value
-            if (value === null || value === undefined) {
-                nodes.push([field, '=', value]);
-            } else if (typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
-                // Explicit operators - multiple operators on same field are AND-ed together
-                const entries = Object.entries(value);
-                for (let i = 0; i < entries.length; i++) {
-                    const [op, opValue] = entries[i];
-                    
-                    // Add 'and' before each operator (except the very first node)
-                    if (nodes.length > 0 || i > 0) {
-                        nodes.push('and');
-                    }
-                    
-                    const legacyOp = this.mapOperatorToLegacy(op);
-                    nodes.push([field, legacyOp, opValue]);
-                }
-            } else {
-                // Implicit equality
-                nodes.push([field, '=', value]);
-            }
-        }
-        
-        // Return as FilterNode (type assertion for backward compatibility)
-        return (nodes.length === 1 ? nodes[0] : nodes) as unknown as FilterNode;
-    }
-    
-    /**
-     * Interleaves filter nodes with a logical operator
-     */
-    private interleaveWithOperator(nodes: FilterNode[], operator: string): any[] {
-        if (nodes.length === 0) return [];
-        if (nodes.length === 1) return [nodes[0]];
-        
-        const result: any[] = [nodes[0]];
-        for (let i = 1; i < nodes.length; i++) {
-            result.push(operator, nodes[i]);
-        }
-        return result;
-    }
-    
-    /**
-     * Maps modern $-prefixed operators to legacy format
-     */
-    private mapOperatorToLegacy(operator: string): string {
-        const mapping: Record<string, string> = {
-            '$eq': '=',
-            '$ne': '!=',
-            '$gt': '>',
-            '$gte': '>=',
-            '$lt': '<',
-            '$lte': '<=',
-            '$in': 'in',
-            '$nin': 'nin',
-            '$contains': 'contains',
-            '$startsWith': 'startswith',
-            '$endsWith': 'endswith',
-            '$null': 'is_null',
-            '$exist': 'is_not_null',
-            '$between': 'between',
-        };
-        
-        return mapping[operator] || operator.replace('$', '');
+        // Both ObjectQL Filter and ObjectStack FilterCondition use the same format now
+        return filters as unknown as FilterCondition;
     }
 }

package/src/query/query-analyzer.ts

@@ -7,7 +7,8 @@
  */
 
 import type { UnifiedQuery, ObjectConfig, MetadataRegistry } from '@objectql/types';
-import type { QueryAST, FilterNode } from '@objectstack/spec';
+import { Data } from '@objectstack/spec';
+type QueryAST = Data.QueryAST;
 import { QueryService, QueryOptions } from './query-service';
 
 /**
@@ -165,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
         };
         
@@ -285,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;
         }
         
@@ -314,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 || {});
@@ -341,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');
         }
         
@@ -359,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');
@@ -386,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(', ')}`);
@@ -402,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) {
@@ -427,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
@@ -467,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

@@ -7,14 +7,16 @@
  */
 
 import type { UnifiedQuery } from '@objectql/types';
-import type { QueryAST } from '@objectstack/spec';
+import { Data } from '@objectstack/spec';
+type QueryAST = Data.QueryAST;
 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;
@@ -27,52 +29,20 @@ 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,
+            ...query
         };
 
-        // 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}`
-            }));
+        // Ensure where is properly formatted
+        if (query.where) {
+            ast.where = this.filterTranslator.translate(query.where);
         }
 
         return ast;

package/src/query/query-service.ts

@@ -13,7 +13,8 @@ import type {
     Filter,
     MetadataRegistry
 } from '@objectql/types';
-import type { QueryAST } from '@objectstack/spec';
+import { Data } from '@objectstack/spec';
+type QueryAST = Data.QueryAST;
 import { QueryBuilder } from './query-builder';
 
 /**
@@ -231,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);
@@ -255,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 = {
@@ -279,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,8 +7,10 @@
  */
 
 import { ObjectQLContext, IObjectQL, ObjectConfig, Driver, UnifiedQuery, ActionContext, HookAPI, RetrievalHookContext, MutationHookContext, UpdateHookContext, ValidationContext, ValidationError, ValidationRuleResult, FormulaContext, Filter } from '@objectql/types';
-import type { ObjectStackKernel } from '@objectstack/runtime';
-import type { QueryAST, FilterNode, SortNode } from '@objectstack/spec';
+import type { ObjectStackKernel } from '@objectql/runtime';
+import { Data } from '@objectstack/spec';
+type QueryAST = Data.QueryAST;
+type SortNode = Data.SortNode;
 import { Validator } from './validator';
 import { FormulaEngine } from './formula-engine';
 import { QueryBuilder } from './query';
@@ -222,9 +224,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 }
@@ -244,7 +248,7 @@ export class ObjectRepository {
                             objectName: this.objectName,
                             fieldName,
                             recordId: formulaContext.record_id,
-                            formula: fieldConfig.formula,
+                            expression: formulaExpression,
                             error: result.error,
                             stack: result.stack,
                         }
@@ -311,6 +315,22 @@ export class ObjectRepository {
     }
 
     async count(filters: any): Promise<number> {
+        // Normalize filters to UnifiedQuery format
+        // If filters is an array, wrap it in a query object
+        // If filters is already a UnifiedQuery (has UnifiedQuery-specific properties), use it as-is
+        let query: UnifiedQuery;
+        if (Array.isArray(filters)) {
+            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 = { where: filters };
+        } else {
+            query = {};
+        }
+
         const hookCtx: RetrievalHookContext = {
             ...this.context,
             objectName: this.objectName,
@@ -318,7 +338,7 @@ export class ObjectRepository {
             api: this.getHookAPI(),
             user: this.getUserFromContext(),
             state: {},
-            query: filters
+            query
         };
         await this.app.triggerHook('beforeCount', this.objectName, hookCtx);
 
@@ -444,7 +464,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) {
@@ -458,7 +478,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/src/validator-plugin.ts

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import type { RuntimePlugin, RuntimeContext, ObjectStackKernel } from '@objectstack/runtime';
+import type { RuntimePlugin, RuntimeContext, ObjectStackKernel } from '@objectql/runtime';
 import { Validator, ValidatorOptions } from './validator';
 
 /**

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

@@ -1,5 +1,5 @@
 /**
- * Mock for @objectstack/runtime
+ * Mock for @objectql/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.
  * 

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',

package/test/formula-integration.test.ts

@@ -42,7 +42,7 @@ describe('Formula Integration', () => {
         },
         full_name: {
           type: 'formula',
-          formula: 'first_name + " " + last_name',
+          expression: 'first_name + " " + last_name',
           data_type: 'text',
           label: 'Full Name',
         },
@@ -54,7 +54,7 @@ describe('Formula Integration', () => {
         },
         total: {
           type: 'formula',
-          formula: 'quantity * unit_price',
+          expression: 'quantity * unit_price',
           data_type: 'currency',
           label: 'Total',
         },
@@ -63,7 +63,7 @@ describe('Formula Integration', () => {
         },
         status_label: {
           type: 'formula',
-          formula: 'is_active ? "Active" : "Inactive"',
+          expression: 'is_active ? "Active" : "Inactive"',
           data_type: 'text',
           label: 'Status',
         },
@@ -165,7 +165,7 @@ describe('Formula Integration', () => {
           tax_rate: { type: 'percent' },
           final_price: {
             type: 'formula',
-            formula: 'subtotal * (1 - discount_rate / 100) * (1 + tax_rate / 100)',
+            expression: 'subtotal * (1 - discount_rate / 100) * (1 + tax_rate / 100)',
             data_type: 'currency',
             label: 'Final Price',
           },
@@ -173,7 +173,7 @@ describe('Formula Integration', () => {
           status: { type: 'select', options: ['draft', 'confirmed', 'shipped'] },
           risk_level: {
             type: 'formula',
-            formula: `
+            expression: `
               if (subtotal > 10000) {
                 return 'High';
               } else if (subtotal > 1000) {
@@ -256,7 +256,7 @@ describe('Formula Integration', () => {
           price: { type: 'currency' },
           invalid_formula: {
             type: 'formula',
-            formula: 'nonexistent_field * 2',
+            expression: 'nonexistent_field * 2',
             data_type: 'number',
           },
         },

package/test/formula-plugin.test.ts

@@ -7,7 +7,7 @@
  */
 
 import { FormulaPlugin } from '../src/formula-plugin';
-import { ObjectStackKernel } from '@objectstack/runtime';
+import { ObjectStackKernel } from '@objectql/runtime';
 
 describe('FormulaPlugin', () => {
     let plugin: FormulaPlugin;