@objectql/core 4.2.0 → 4.2.2

package/src/repository.ts

@@ -1,322 +1,6 @@
 /**
- * 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.
+ * @deprecated This file is dead code. Delete it.
+ * ObjectRepository class now comes from @objectstack/objectql.
+ * Re-exported via index.ts for backward compatibility.
  */
-
-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';
-import { z } from 'zod';
-type SortNode = z.infer<typeof Data.SortNodeSchema>;
-
-export class ObjectRepository {
-
-    constructor(
-        private objectName: string,
-        private context: ObjectQLContext,
-        private app: IObjectQL
-    ) {
-    }
-    
-    private getDriver(): Driver {
-        const obj = this.getSchema();
-        const datasourceName = obj.datasource || 'default';
-        return this.app.datasource(datasourceName);
-    }
-    
-    private getKernel(): ObjectKernel {
-        return this.app.getKernel();
-    }
-
-    private getOptions(extra: Record<string, unknown> = {}) {
-        return {
-            transaction: this.context.transactionHandle,
-            ...extra
-        };
-    }
-
-    getSchema(): ObjectConfig {
-        const obj = this.app.getObject(this.objectName);
-        if (!obj) {
-            throw new Error(`Object '${this.objectName}' not found`);
-        }
-        return obj;
-    }
-
-    private getHookAPI(): HookAPI {
-        return {
-            find: (obj, q) => this.context.object(obj).find(q),
-            findOne: (obj, id) => this.context.object(obj).findOne(id),
-            count: (obj, q) => this.context.object(obj).count(q),
-            create: (obj, data) => this.context.object(obj).create(data),
-            update: (obj, id, data) => this.context.object(obj).update(id, data),
-            delete: (obj, id) => this.context.object(obj).delete(id)
-        };
-    }
-
-    private getUserFromContext() {
-        if (!this.context.userId) {
-            return undefined;
-        }
-        // Construct user object from context, including relevant properties
-        return {
-            id: this.context.userId,
-            spaceId: this.context.spaceId,
-            roles: this.context.roles,
-            isSystem: this.context.isSystem
-        };
-    }
-
-
-    async find(query: UnifiedQuery = {}): Promise<any[]> {
-        const hookCtx: RetrievalHookContext = {
-            ...this.context,
-            objectName: this.objectName,
-            operation: 'find',
-            api: this.getHookAPI(),
-            user: this.getUserFromContext(),
-            state: {},
-            query
-        };
-        await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
-
-        // Execute via kernel (delegates to QueryService)
-        const kernelResult = await (this.getKernel() as any).find(this.objectName, hookCtx.query || {});
-        const results = kernelResult.value;
-        
-        // Formula evaluation moved to FormulaPlugin hook
-        hookCtx.result = results;
-        await this.app.triggerHook('afterFind', this.objectName, hookCtx);
-
-        return hookCtx.result as any[];
-    }
-
-    async findOne(idOrQuery: string | number | UnifiedQuery): Promise<any> {
-        if (typeof idOrQuery === 'string' || typeof idOrQuery === 'number') {
-            const hookCtx: RetrievalHookContext = {
-                ...this.context,
-                objectName: this.objectName,
-                operation: 'find',
-                api: this.getHookAPI(),
-                user: this.getUserFromContext(),
-                state: {},
-                query: { _id: idOrQuery }
-            };
-            await this.app.triggerHook('beforeFind', this.objectName, hookCtx);
-            
-            // Use kernel.get() for direct ID lookup
-            const result = await (this.getKernel() as any).get(this.objectName, String(idOrQuery));
-
-            // Formula evaluation moved to FormulaPlugin hook
-            hookCtx.result = result;
-            await this.app.triggerHook('afterFind', this.objectName, hookCtx);
-            return hookCtx.result;
-        } else {
-            const results = await this.find(idOrQuery);
-            return results[0] || null;
-        }
-    }
-
-    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,
-            operation: 'count',
-            api: this.getHookAPI(),
-            user: this.getUserFromContext(),
-            state: {},
-            query
-        };
-        await this.app.triggerHook('beforeCount', this.objectName, hookCtx);
-
-        // 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);
-        return hookCtx.result as number;
-    }
-
-    async create(doc: any): Promise<any> {
-        const hookCtx: MutationHookContext = {
-            ...this.context,
-            objectName: this.objectName,
-            operation: 'create',
-            state: {},
-            api: this.getHookAPI(),
-            user: this.getUserFromContext(),
-            data: doc
-        };
-        await this.app.triggerHook('beforeCreate', this.objectName, hookCtx);
-        const finalDoc = hookCtx.data || doc;
-
-        if (this.context.userId) finalDoc.created_by = this.context.userId;
-        if (this.context.spaceId) finalDoc.space_id = this.context.spaceId;
-        
-        // Validation moved to ValidatorPlugin hook
-        
-        // Execute via kernel
-        const result = await (this.getKernel() as any).create(this.objectName, finalDoc, this.getOptions());
-        
-        hookCtx.result = result;
-        await this.app.triggerHook('afterCreate', this.objectName, hookCtx);
-        return hookCtx.result;
-    }
-
-    async update(id: string | number, doc: any, options?: any): Promise<any> {
-        const previousData = await this.findOne(id);
-        const hookCtx: UpdateHookContext = {
-            ...this.context,
-            objectName: this.objectName,
-            operation: 'update',
-            state: {},
-            api: this.getHookAPI(),
-            user: this.getUserFromContext(),
-            id,
-            data: doc,
-            previousData,
-            isModified: (field) => hookCtx.data ? Object.prototype.hasOwnProperty.call(hookCtx.data, field) : false
-        };
-        await this.app.triggerHook('beforeUpdate', this.objectName, hookCtx);
-
-        // Validation moved to ValidatorPlugin hook
-
-        // Execute via kernel
-        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);
-        return hookCtx.result;
-    }
-
-    async delete(id: string | number): Promise<any> {
-        const previousData = await this.findOne(id);
-        const hookCtx: MutationHookContext = {
-            ...this.context,
-            objectName: this.objectName,
-            operation: 'delete',
-            state: {},
-            api: this.getHookAPI(),
-            user: this.getUserFromContext(),
-            id,
-            previousData
-        };
-        await this.app.triggerHook('beforeDelete', this.objectName, hookCtx);
-
-        // Execute via kernel
-        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);
-        return hookCtx.result;
-    }
-
-    async aggregate(query: any): Promise<any> {
-        const driver = this.getDriver();
-        if (!driver.aggregate) throw new Error("Driver does not support aggregate");
-        
-        return driver.aggregate(this.objectName, query, this.getOptions());
-    }
-
-    async distinct(field: string, filters?: any): Promise<any[]> {
-        const driver = this.getDriver();
-        if (!driver.distinct) throw new Error("Driver does not support distinct");
-        
-        return driver.distinct(this.objectName, field, filters, this.getOptions());
-    }
-
-    async findOneAndUpdate(filters: any, update: any, options?: any): Promise<any> {
-        const driver = this.getDriver();
-        if (!driver.findOneAndUpdate) throw new Error("Driver does not support findOneAndUpdate");
-        return driver.findOneAndUpdate(this.objectName, filters, update, this.getOptions(options));
-    }
-
-    async createMany(data: any[]): Promise<any> {
-        const driver = this.getDriver();
-        
-        // Always use fallback to ensure validation and hooks are executed
-        // This maintains ObjectQL's metadata-driven architecture where
-        // validation rules, hooks, and permissions are enforced consistently
-        const results = [];
-        for (const item of data) {
-            results.push(await this.create(item));
-        }
-        return results;
-    }
-
-    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({ where: filters });
-        let count = 0;
-        for (const record of records) {
-            if (record && record._id) {
-                await this.update(record._id, data);
-                count++;
-            }
-        }
-        return count;
-    }
-
-    async deleteMany(filters: any): Promise<any> {
-        // Find all matching records and delete them individually
-        // to ensure hooks are executed
-        const records = await this.find({ where: filters });
-        let count = 0;
-        for (const record of records) {
-            if (record && record._id) {
-                await this.delete(record._id);
-                count++;
-            }
-        }
-        return count;
-    }
-
-    async execute(actionName: string, id: string | number | undefined, params: any): Promise<any> {
-        const api: HookAPI = {
-            find: (obj, q) => this.context.object(obj).find(q),
-            findOne: (obj, id) => this.context.object(obj).findOne(id),
-            count: (obj, q) => this.context.object(obj).count(q),
-            create: (obj, data) => this.context.object(obj).create(data),
-            update: (obj, id, data) => this.context.object(obj).update(id, data),
-            delete: (obj, id) => this.context.object(obj).delete(id)
-        };
-
-        const ctx: ActionContext = {
-            ...this.context,
-            objectName: this.objectName,
-            actionName,
-            id,
-            input: params,
-            api,
-            user: this.getUserFromContext()
-        };
-        return await this.app.executeAction(this.objectName, actionName, ctx);
-    }
-}
+export { ObjectRepository } from '@objectstack/objectql';

package/src/util.ts

@@ -6,7 +6,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { ObjectConfig, FieldConfig, FieldType, IntrospectedSchema, IntrospectedColumn, IntrospectedTable } from '@objectql/types';
+import { ObjectConfig, FieldConfig, FieldType, IntrospectedSchema } from '@objectql/types';
 
 export function toTitleCase(str: string): string {
     return str
@@ -118,7 +118,8 @@ export function convertIntrospectedSchemaToObjects(
                     reference_to: foreignKey.referencedTable,
                     label: toTitleCase(column.name),
                     required: !column.nullable,
-                    searchable: false
+                    searchable: false,
+                    sortable: false
                 };
             } else {
                 // Regular field
@@ -131,7 +132,8 @@ export function convertIntrospectedSchemaToObjects(
                     type: fieldType,
                     label: toTitleCase(column.name),
                     required: !column.nullable,
-                    searchable: false
+                    searchable: false,
+                    sortable: false
                 };
                 
                 // Add unique constraint

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

@@ -22,6 +22,255 @@ export const createLogger = jest.fn(() => ({
   fatal: jest.fn(),
 }));
 
-export const ObjectKernel = jest.fn();
+class MockMetadataRegistry {
+  private store = new Map<string, Map<string, any>>();
+
+  register(type: string, nameOrConfig: string | any, config?: any): void {
+    if (!this.store.has(type)) {
+      this.store.set(type, new Map());
+    }
+    const typeMap = this.store.get(type)!;
+    let name: string;
+    let item: any;
+    if (config) {
+      name = nameOrConfig as string;
+      item = config;
+    } else {
+      item = nameOrConfig;
+      name = item.id || item.name;
+    }
+    typeMap.set(name, item);
+  }
+
+  get<T = any>(type: string, id: string): T | undefined {
+    const typeMap = this.store.get(type);
+    const item = typeMap?.get(id);
+    return item?.content as T;
+  }
+
+  list<T = any>(type: string): T[] {
+    const typeMap = this.store.get(type);
+    if (!typeMap) return [];
+    return Array.from(typeMap.values()).map(item => item.content as T);
+  }
+
+  unregister(type: string, id: string): boolean {
+    const typeMap = this.store.get(type);
+    if (!typeMap) return false;
+    return typeMap.delete(id);
+  }
+
+  getTypes(): string[] {
+    return Array.from(this.store.keys());
+  }
+
+  getEntry(type: string, id: string): any | undefined {
+    const typeMap = this.store.get(type);
+    return typeMap ? typeMap.get(id) : undefined;
+  }
+
+  unregisterPackage(packageName: string): void {
+    for (const [_type, typeMap] of this.store.entries()) {
+      const toDelete: string[] = [];
+      for (const [id, item] of typeMap.entries()) {
+        if (item.packageName === packageName || item.package === packageName) {
+          toDelete.push(id);
+        }
+      }
+      toDelete.forEach(id => typeMap.delete(id));
+    }
+  }
+}
+
+class MockHookManager {
+  removePackage(_packageName: string): void {
+    // Mock implementation
+  }
+  clear(): void {
+    // Mock implementation
+  }
+}
+
+class MockActionManager {
+  removePackage(_packageName: string): void {
+    // Mock implementation
+  }
+  clear(): void {
+    // Mock implementation
+  }
+}
+
+export class ObjectKernel {
+  public ql: unknown = null;
+  public metadata: MockMetadataRegistry;
+  public hooks: MockHookManager;
+  public actions: MockActionManager;
+  private plugins: any[] = [];
+  private driver: any = null;
+
+  constructor(plugins: any[] = []) {
+    this.plugins = plugins;
+    this.metadata = new MockMetadataRegistry();
+    this.hooks = new MockHookManager();
+    this.actions = new MockActionManager();
+  }
+
+  setDriver(driver: any): void {
+    this.driver = driver;
+  }
+
+  async start(): Promise<void> {
+    for (const plugin of this.plugins) {
+      if (plugin.install) {
+        await plugin.install({ engine: this });
+      }
+    }
+    for (const plugin of this.plugins) {
+      if (plugin.onStart) {
+        await plugin.onStart({ engine: this });
+      }
+    }
+  }
+
+  async stop(): Promise<void> {
+    for (const plugin of this.plugins) {
+      if (plugin.onStop) {
+        await plugin.onStop({ engine: this });
+      }
+    }
+  }
+
+  getDriver(): any {
+    const driver = this.plugins.find(p =>
+      p.constructor.name?.includes('Driver') ||
+      (typeof p.find === 'function' && typeof p.create === 'function')
+    );
+    return driver || this.driver;
+  }
+
+  async seed(): Promise<void> {
+    // Mock implementation
+  }
+
+  async find(objectName: string, query: any): Promise<{ value: Record<string, any>[]; count: number }> {
+    const driver = this.getDriver();
+    if (driver) {
+      const normalizedQuery: any = {};
+      if (query.filters) {
+        normalizedQuery.where = query.filters;
+      } else if (query.filter) {
+        normalizedQuery.where = query.filter;
+      } else if (query.where) {
+        normalizedQuery.where = query.where;
+      }
+      if (query.fields) {
+        normalizedQuery.fields = query.fields;
+      }
+      if (query.sort) {
+        if (Array.isArray(query.sort) && query.sort.length > 0) {
+          const firstItem = query.sort[0];
+          if (firstItem !== undefined) {
+            if (Array.isArray(firstItem)) {
+              normalizedQuery.orderBy = query.sort.map((s: any) => ({
+                field: s[0],
+                order: s[1]
+              }));
+            } else if (typeof firstItem === 'object') {
+              normalizedQuery.orderBy = query.sort.flatMap((s: any) =>
+                Object.entries(s).map(([field, order]) => ({
+                  field,
+                  order: (order === -1 || order === 'desc' || order === 'DESC') ? 'desc' : 'asc'
+                }))
+              );
+            }
+          }
+        } else if (query.sort) {
+          normalizedQuery.orderBy = query.sort;
+        }
+      } else if (query.orderBy) {
+        normalizedQuery.orderBy = query.orderBy;
+      }
+      if (query.limit !== undefined) {
+        normalizedQuery.limit = query.limit;
+      } else if (query.top !== undefined) {
+        normalizedQuery.limit = query.top;
+      }
+      if (query.offset !== undefined) {
+        normalizedQuery.offset = query.offset;
+      } else if (query.skip !== undefined) {
+        normalizedQuery.offset = query.skip;
+      }
+      if (query.aggregations) {
+        normalizedQuery.aggregate = query.aggregations.map((agg: any) => ({
+          func: agg.function,
+          field: agg.field,
+          alias: agg.alias
+        }));
+      }
+      if (query.groupBy) {
+        normalizedQuery.groupBy = query.groupBy;
+      }
+      const results = await driver.find(objectName, normalizedQuery, {});
+      return { value: results, count: results.length };
+    }
+    return { value: [], count: 0 };
+  }
+
+  async get(objectName: string, id: string): Promise<Record<string, any>> {
+    const driver = this.getDriver();
+    if (driver) {
+      return await driver.findOne(objectName, id, {}, {});
+    }
+    return {};
+  }
+
+  async create(objectName: string, data: any): Promise<Record<string, any>> {
+    const driver = this.getDriver();
+    if (driver) {
+      return await driver.create(objectName, data, {});
+    }
+    return data;
+  }
+
+  async update(objectName: string, id: string, data: any): Promise<Record<string, any>> {
+    const driver = this.getDriver();
+    if (driver) {
+      return await driver.update(objectName, id, data, {});
+    }
+    return data;
+  }
+
+  async delete(objectName: string, id: string): Promise<boolean> {
+    const driver = this.getDriver();
+    if (driver) {
+      const result = await driver.delete(objectName, id, {});
+      return result > 0;
+    }
+    return true;
+  }
+
+  getMetadata(_objectName: string): any {
+    return {};
+  }
+
+  getView(_objectName: string, _viewType?: 'list' | 'form'): any {
+    return null;
+  }
+}
+
+export class ObjectStackProtocolImplementation {}
+
+export interface PluginContext {
+  engine: ObjectKernel;
+}
+
+export interface ObjectQLPlugin {
+  name: string;
+  install?: (ctx: PluginContext) => void | Promise<void>;
+  onStart?: (ctx: PluginContext) => void | Promise<void>;
+}
+
+export { MockMetadataRegistry as MetadataRegistry };
+
 export const LiteKernel = jest.fn();
 export const createApiRegistryPlugin = jest.fn();