@objectql/core 4.2.0 → 4.2.2

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

@@ -11,9 +11,249 @@
  */
 
 export class ObjectQL {
+  private drivers = new Map<string, any>();
+  private defaultDriver: any = null;
+  private hooks = new Map<string, any[]>();
+  private middlewares: Array<{ fn: any; object?: string }> = [];
+  
   constructor(public config: any) {}
+  
   async connect() {}
   async disconnect() {}
+  async init() {
+    // Initialize drivers (connect + sync schema)
+    for (const [_name, driver] of this.drivers) {
+      if (driver.connect) {
+        await driver.connect();
+      }
+      if (driver.init) {
+        const objects = SchemaRegistry.getAllObjects();
+        await driver.init(objects);
+      }
+    }
+  }
+  
+  registerDriver(driver: any, isDefault: boolean = false) {
+    if (!driver.name) {
+      throw new Error('Driver must have a name');
+    }
+    this.drivers.set(driver.name, driver);
+    if (isDefault) {
+      this.defaultDriver = driver.name;
+    }
+  }
+
+  datasource(name: string): any {
+    const driver = this.drivers.get(name);
+    if (!driver) {
+      throw new Error(`[ObjectQL] Datasource '${name}' not found`);
+    }
+    return driver;
+  }
+
+  getDriverByName(name: string): any {
+    return this.drivers.get(name);
+  }
+  
+  registerObject(schema: any, packageId: string = '__runtime__', namespace?: string): string {
+    // Auto-assign field names from keys
+    if (schema.fields) {
+      for (const [key, field] of Object.entries(schema.fields)) {
+        if (field && typeof field === 'object' && !('name' in field)) {
+          (field as any).name = key;
+        }
+      }
+    }
+    return SchemaRegistry.registerObject(schema, packageId, namespace);
+  }
+  
+  getObject(name: string) {
+    return SchemaRegistry.getObject(name);
+  }
+  
+  getConfigs(): Record<string, any> {
+    return SchemaRegistry.getAllObjects().reduce((acc: any, obj: any) => {
+      if (obj.name) {
+        acc[obj.name] = obj;
+      }
+      return acc;
+    }, {});
+  }
+  
+  removePackage(packageId: string) {
+    SchemaRegistry.unregisterObjectsByPackage(packageId);
+  }
+  
+  registerHook(event: string, handler: any, options?: any) {
+    if (!this.hooks.has(event)) {
+      this.hooks.set(event, []);
+    }
+    this.hooks.get(event)!.push({ handler, options });
+  }
+
+  on(event: string, objectName: string, handler: any, packageId?: string) {
+    this.registerHook(event, handler, { object: objectName, packageId });
+  }
+
+  registerMiddleware(fn: any, options?: { object?: string }) {
+    this.middlewares.push({ fn, object: options?.object });
+  }
+
+  private async executeWithMiddleware(opCtx: any, executor: () => Promise<any>) {
+    const applicable = this.middlewares.filter(
+      (m) => !m.object || m.object === '*' || m.object === opCtx.object
+    );
+    let index = 0;
+    const next = async () => {
+      if (index < applicable.length) {
+        const mw = applicable[index++];
+        await mw.fn(opCtx, next);
+      } else {
+        opCtx.result = await executor();
+      }
+    };
+    await next();
+    return opCtx.result;
+  }
+
+  private async triggerHooks(event: string, context: any) {
+    const entries = this.hooks.get(event) || [];
+    for (const entry of entries) {
+      if (entry.options?.object) {
+        const targets = Array.isArray(entry.options.object) ? entry.options.object : [entry.options.object];
+        if (!targets.includes('*') && !targets.includes(context.object)) {
+          continue;
+        }
+      }
+      await entry.handler(context);
+    }
+  }
+  
+  createContext(options: any = {}) {
+    return {
+      isSystem: options.isSystem || false,
+      object: (name: string) => ({
+        find: async (filter: any) => {
+          const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
+          const opCtx = { object: name, operation: 'find', options: filter, context: options, result: undefined as any };
+          await this.executeWithMiddleware(opCtx, async () => {
+            const hookContext = { object: name, event: 'beforeFind', input: { options: filter }, session: options };
+            await this.triggerHooks('beforeFind', hookContext);
+            const result = driver?.find ? await driver.find(name, filter) : [];
+            hookContext.event = 'afterFind';
+            (hookContext as any).result = result;
+            await this.triggerHooks('afterFind', hookContext);
+            return (hookContext as any).result;
+          });
+          return opCtx.result;
+        },
+        findOne: async (filter: any) => {
+          const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
+          const opCtx = { object: name, operation: 'findOne', options: filter, context: options, result: undefined as any };
+          await this.executeWithMiddleware(opCtx, async () => {
+            return driver?.findOne ? await driver.findOne(name, filter) : null;
+          });
+          return opCtx.result;
+        },
+        create: async (data: any) => {
+          const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
+          const opCtx = { object: name, operation: 'insert', data, context: options, result: undefined as any };
+          await this.executeWithMiddleware(opCtx, async () => {
+            const hookContext: any = {
+              object: name, event: 'beforeCreate',
+              input: { data: opCtx.data }, session: options,
+              data: opCtx.data, user: options.userId ? { id: options.userId } : options.user
+            };
+            await this.triggerHooks('beforeCreate', hookContext);
+            const finalData = hookContext.data || hookContext.input.data;
+            const result = driver?.create ? await driver.create(name, finalData, options) : finalData;
+            hookContext.event = 'afterCreate';
+            hookContext.result = result;
+            await this.triggerHooks('afterCreate', hookContext);
+            return hookContext.result;
+          });
+          return opCtx.result;
+        },
+        insert: async (data: any) => {
+          const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
+          const opCtx = { object: name, operation: 'insert', data, context: options, result: undefined as any };
+          await this.executeWithMiddleware(opCtx, async () => {
+            const hookContext: any = {
+              object: name, event: 'beforeCreate',
+              input: { data: opCtx.data }, session: options,
+              data: opCtx.data, user: options.userId ? { id: options.userId } : options.user
+            };
+            await this.triggerHooks('beforeCreate', hookContext);
+            const finalData = hookContext.data || hookContext.input.data;
+            const result = driver?.create ? await driver.create(name, finalData, options)
+              : driver?.insert ? await driver.insert(name, finalData)
+              : finalData;
+            hookContext.event = 'afterCreate';
+            hookContext.result = result;
+            await this.triggerHooks('afterCreate', hookContext);
+            return hookContext.result;
+          });
+          return opCtx.result;
+        },
+        update: async (id: string, data: any) => {
+          const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
+          const opCtx = { object: name, operation: 'update', data, context: options, result: undefined as any };
+          await this.executeWithMiddleware(opCtx, async () => {
+            // Fetch previous data for hooks that need it
+            let previousData: any;
+            if (driver?.findOne) {
+              try { previousData = await driver.findOne(name, { _id: id }); } catch (_e) { /* ignore */ }
+            }
+            const hookContext: any = {
+              object: name, event: 'beforeUpdate',
+              input: { id, data: opCtx.data }, session: options,
+              data: opCtx.data, previousData, user: options.userId ? { id: options.userId } : options.user
+            };
+            await this.triggerHooks('beforeUpdate', hookContext);
+            const finalData = hookContext.data || hookContext.input.data;
+            const result = driver?.update ? await driver.update(name, id, finalData, options) : finalData;
+            hookContext.event = 'afterUpdate';
+            hookContext.result = result;
+            await this.triggerHooks('afterUpdate', hookContext);
+            return hookContext.result;
+          });
+          return opCtx.result;
+        },
+        delete: async (id: string) => {
+          const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
+          const opCtx = { object: name, operation: 'delete', context: options, result: undefined as any };
+          await this.executeWithMiddleware(opCtx, async () => {
+            // Fetch current data for hooks that need it
+            let previousData: any;
+            if (driver?.findOne) {
+              try { previousData = await driver.findOne(name, { _id: id }); } catch (_e) { /* ignore */ }
+            }
+            const hookContext: any = {
+              object: name, event: 'beforeDelete',
+              input: { id }, session: options,
+              data: previousData, previousData, user: options.userId ? { id: options.userId } : options.user
+            };
+            await this.triggerHooks('beforeDelete', hookContext);
+            const result = driver?.delete ? await driver.delete(name, id) : true;
+            hookContext.event = 'afterDelete';
+            hookContext.result = result;
+            await this.triggerHooks('afterDelete', hookContext);
+            return hookContext.result;
+          });
+          return opCtx.result;
+        },
+        count: async (filter?: any) => {
+          const driver = this.drivers.get(this.defaultDriver || this.drivers.keys().next().value);
+          if (driver?.count) {
+            return driver.count(name, filter);
+          }
+          // Fallback: use find and count
+          const results = driver?.find ? await driver.find(name, filter) : [];
+          return Array.isArray(results) ? results.length : 0;
+        }
+      })
+    };
+  }
 }
 
 const mockStore = new Map<string, Map<string, any>>();
@@ -42,4 +282,37 @@ export const SchemaRegistry = {
     return items ? Array.from(items.values()) : [];
   }),
   metadata: mockStore,
+  
+  // Additional methods needed for ObjectQL compatibility
+  registerObject: jest.fn((schema: any, packageId?: string, namespace?: string) => {
+    if (!mockStore.has('object')) {
+      mockStore.set('object', new Map());
+    }
+    const name = schema.name || 'unnamed';
+    mockStore.get('object')!.set(name, schema);
+    return namespace ? `${namespace}.${name}` : name;
+  }),
+  
+  getObject: jest.fn((name: string) => {
+    return mockStore.get('object')?.get(name);
+  }),
+  
+  getAllObjects: jest.fn(() => {
+    const objects = mockStore.get('object');
+    return objects ? Array.from(objects.values()) : [];
+  }),
+  
+  unregisterObjectsByPackage: jest.fn((packageId: string) => {
+    // In mock, just clear the objects store
+    const objects = mockStore.get('object');
+    if (objects) {
+      const toDelete: string[] = [];
+      objects.forEach((obj, key) => {
+        if ((obj as any).__packageId === packageId) {
+          toDelete.push(key);
+        }
+      });
+      toDelete.forEach(key => objects.delete(key));
+    }
+  }),
 };

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

@@ -11,12 +11,21 @@
 class MockMetadataRegistry {
     private store = new Map<string, Map<string, any>>();
     
-    register(type: string, item: any): void {
+    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)!;
-        typeMap.set(item.id || item.name, item);
+        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 {
@@ -43,7 +52,7 @@ class MockMetadataRegistry {
     
     unregisterPackage(packageName: string): void {
         // Simple implementation - in real runtime this would filter by package
-        for (const [type, typeMap] of this.store.entries()) {
+        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) {
@@ -233,11 +242,11 @@ export class ObjectKernel {
         return true;
     }
     
-    getMetadata(objectName: string): any {
+    getMetadata(_objectName: string): any {
         return {};
     }
     
-    getView(objectName: string, viewType?: 'list' | 'form'): any {
+    getView(_objectName: string, _viewType?: 'list' | 'form'): any {
         return null;
     }
 }

package/test/introspection.test.ts

@@ -7,7 +7,7 @@
  */
 
 import { convertIntrospectedSchemaToObjects } from '../src/util';
-import { IntrospectedSchema, ObjectConfig } from '@objectql/types';
+import { IntrospectedSchema } from '@objectql/types';
 
 describe('convertIntrospectedSchemaToObjects', () => {
     it('should convert simple table to object config', () => {

package/test/mock-driver.ts

@@ -25,7 +25,7 @@ export class MockDriver implements Driver {
         return this.data[objectName];
     }
 
-    async find(objectName: string, query: any, options?: any): Promise<any[]> {
+    async find(objectName: string, query: any, _options?: any): Promise<any[]> {
         const items = this.getData(objectName);
         // Very basic filter implementation for testing
         if (query.filters) {
@@ -42,12 +42,12 @@ export class MockDriver implements Driver {
         return items;
     }
 
-    async findOne(objectName: string, id: string | number, query?: any, options?: any): Promise<any> {
+    async findOne(objectName: string, id: string | number, _query?: any, _options?: any): Promise<any> {
         const items = this.getData(objectName);
         return items.find((item: any) => item._id === id);
     }
 
-    async create(objectName: string, data: any, options?: any): Promise<any> {
+    async create(objectName: string, data: any, _options?: any): Promise<any> {
         const items = this.getData(objectName);
         const newItem = {
             ...data,
@@ -57,7 +57,7 @@ export class MockDriver implements Driver {
         return newItem;
     }
 
-    async update(objectName: string, id: string | number, data: any, options?: any): Promise<any> {
+    async update(objectName: string, id: string | number, data: any, _options?: any): Promise<any> {
         const items = this.getData(objectName);
         const index = items.findIndex((item: any) => item._id === id);
         if (index > -1) {
@@ -67,7 +67,7 @@ export class MockDriver implements Driver {
         throw new Error('Not found');
     }
 
-    async delete(objectName: string, id: string | number, options?: any): Promise<any> {
+    async delete(objectName: string, id: string | number, _options?: any): Promise<any> {
         const items = this.getData(objectName);
         const index = items.findIndex((item: any) => item._id === id);
         if (index > -1) {

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 from the plugin package where the optimization modules now live
 import {
     OptimizedMetadataRegistry,
     QueryCompiler,
@@ -16,7 +16,7 @@ import {
     LazyMetadataLoader,
     DependencyGraph,
     SQLQueryOptimizer
-} from '../src/optimizations';
+} from '@objectql/plugin-optimizations';
 
 describe('Kernel Optimizations', () => {
     describe('OptimizedMetadataRegistry', () => {

package/test/plugin-integration.test.ts

@@ -46,7 +46,7 @@ describe('ObjectQLPlugin Integration', () => {
         it('should have correct name and version', () => {
             plugin = new ObjectQLPlugin();
             expect(plugin.name).toBe('@objectql/core');
-            expect(plugin.version).toBe('4.0.2');
+            expect(plugin.version).toBe('4.2.0');
         });
     });
 
@@ -61,7 +61,6 @@ describe('ObjectQLPlugin Integration', () => {
                 enableRepository: false,
                 enableValidator: false,
                 enableFormulas: true,
-                enableAI: false,
             });
             expect(plugin).toBeDefined();
         });
@@ -176,7 +175,6 @@ describe('ObjectQLPlugin Integration', () => {
                 enableRepository: false,
                 enableValidator: false,
                 enableFormulas: false,
-                enableAI: false,
             });
             
             const runtimeContext = { engine: mockContext.app };

package/test/utils.ts

@@ -20,22 +20,22 @@ export class MockDriver implements Driver {
         return this.data[objectName];
     }
 
-    async find(objectName: string, query: any, options?: any): Promise<any[]> {
+    async find(objectName: string, _query: any, _options?: any): Promise<any[]> {
         return this.getData(objectName);
     }
 
-    async findOne(objectName: string, id: string | number, query?: any, options?: any): Promise<any> {
+    async findOne(objectName: string, id: string | number, _query?: any, _options?: any): Promise<any> {
         return this.getData(objectName).find(item => item.id == id);
     }
 
-    async create(objectName: string, data: any, options?: any): Promise<any> {
+    async create(objectName: string, data: any, _options?: any): Promise<any> {
         const list = this.getData(objectName);
         if (!data.id) data.id = list.length + 1;
         list.push(data);
         return data;
     }
 
-    async update(objectName: string, id: string | number, data: any, options?: any): Promise<any> {
+    async update(objectName: string, id: string | number, data: any, _options?: any): Promise<any> {
         const list = this.getData(objectName);
         const idx = list.findIndex(item => item.id == id);
         if (idx >= 0) {
@@ -45,7 +45,7 @@ export class MockDriver implements Driver {
         return null;
     }
 
-    async delete(objectName: string, id: string | number, options?: any): Promise<any> {
+    async delete(objectName: string, id: string | number, _options?: any): Promise<any> {
         const list = this.getData(objectName);
         const idx = list.findIndex(item => item.id == id);
         if (idx >= 0) {
@@ -56,7 +56,7 @@ export class MockDriver implements Driver {
         return null;
     }
 
-    async count(objectName: string, filters: any, options?: any): Promise<number> {
+    async count(objectName: string, _filters: any, _options?: any): Promise<number> {
         return this.getData(objectName).length;
     }
 }

package/tsconfig.json

@@ -12,6 +12,8 @@
   "references": [
     { "path": "../types" },
     { "path": "../plugin-validator" },
-    { "path": "../plugin-formula" }
+    { "path": "../plugin-formula" },
+    { "path": "../plugin-query" },
+    { "path": "../plugin-optimizations" }
   ]
 }