@objectql/core 3.0.1 → 4.0.1

package/src/validator-plugin.ts

@@ -0,0 +1,140 @@
+/**
+ * ObjectQL Validator Plugin
+ * 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 type { RuntimePlugin, RuntimeContext, ObjectStackKernel } from '@objectql/runtime';
+import { Validator, ValidatorOptions } from './validator';
+
+/**
+ * Extended ObjectStack Kernel with validator capability
+ */
+interface KernelWithValidator extends ObjectStackKernel {
+    validator?: Validator;
+}
+
+/**
+ * Configuration for the Validator Plugin
+ */
+export interface ValidatorPluginConfig extends ValidatorOptions {
+  /**
+   * Enable validation on queries
+   * @default true
+   */
+  enableQueryValidation?: boolean;
+  
+  /**
+   * Enable validation on mutations
+   * @default true
+   */
+  enableMutationValidation?: boolean;
+}
+
+/**
+ * Validator Plugin
+ * 
+ * Wraps the ObjectQL Validator engine as an ObjectStack plugin.
+ * Registers validation middleware hooks into the kernel lifecycle.
+ */
+export class ValidatorPlugin implements RuntimePlugin {
+  name = '@objectql/validator';
+  version = '4.0.0';
+  
+  private validator: Validator;
+  private config: ValidatorPluginConfig;
+  
+  constructor(config: ValidatorPluginConfig = {}) {
+    this.config = {
+      enableQueryValidation: true,
+      enableMutationValidation: true,
+      ...config
+    };
+    
+    // Initialize the validator with language options
+    this.validator = new Validator({
+      language: config.language,
+      languageFallback: config.languageFallback,
+    });
+  }
+  
+  /**
+   * Install the plugin into the kernel
+   * Registers validation middleware for queries and mutations
+   */
+  async install(ctx: RuntimeContext): Promise<void> {
+    const kernel = ctx.engine as KernelWithValidator;
+    
+    console.log(`[${this.name}] Installing validator plugin...`);
+    
+    // Make validator accessible from the kernel for direct usage
+    kernel.validator = this.validator;
+    
+    // Register validation middleware for queries (if enabled)
+    if (this.config.enableQueryValidation !== false) {
+      this.registerQueryValidation(kernel);
+    }
+    
+    // Register validation middleware for mutations (if enabled)
+    if (this.config.enableMutationValidation !== false) {
+      this.registerMutationValidation(kernel);
+    }
+    
+    console.log(`[${this.name}] Validator plugin installed`);
+  }
+  
+  /**
+   * Register query validation middleware
+   * @private
+   */
+  private registerQueryValidation(kernel: KernelWithValidator): void {
+    // Check if kernel supports middleware hooks
+    if (typeof (kernel as any).use === 'function') {
+      (kernel as any).use('beforeQuery', async (context: any) => {
+        // Query validation logic
+        // In a real implementation, this would validate query parameters
+        // For now, this is a placeholder that demonstrates the integration pattern
+        if (context.query && context.metadata?.validation_rules) {
+          // Validation would happen here
+          // const result = await this.validator.validate(
+          //   context.metadata.validation_rules,
+          //   { /* validation context */ }
+          // );
+        }
+      });
+    }
+  }
+  
+  /**
+   * Register mutation validation middleware
+   * @private
+   */
+  private registerMutationValidation(kernel: KernelWithValidator): void {
+    // Check if kernel supports middleware hooks
+    if (typeof (kernel as any).use === 'function') {
+      (kernel as any).use('beforeMutation', async (context: any) => {
+        // Mutation validation logic
+        // This would validate data before create/update operations
+        if (context.data && context.metadata?.validation_rules) {
+          // Validation would happen here
+          // const result = await this.validator.validate(
+          //   context.metadata.validation_rules,
+          //   { /* validation context */ }
+          // );
+          // if (!result.valid) {
+          //   throw new Error('Validation failed: ' + result.errors.map(e => e.message).join(', '));
+          // }
+        }
+      });
+    }
+  }
+  
+  /**
+   * Get the validator instance for direct access
+   */
+  getValidator(): Validator {
+    return this.validator;
+  }
+}

package/src/validator.ts

@@ -1,3 +1,11 @@
+/**
+ * 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.
+ */
+
 /**
  * Validation engine for ObjectQL.
  * Executes validation rules based on metadata configuration.
@@ -182,11 +190,10 @@ export class Validator {
                 }
             }
 
-            // Pattern validation (supports both pattern and deprecated regex)
-            const patternValue = validation.pattern ?? validation.regex;
-            if (patternValue) {
+            // Pattern validation
+            if (validation.pattern) {
                 try {
-                    const pattern = new RegExp(patternValue);
+                    const pattern = new RegExp(validation.pattern);
                     if (!pattern.test(String(value))) {
                         results.push({
                             rule: `${fieldName}_pattern`,
@@ -200,7 +207,7 @@ export class Validator {
                     results.push({
                         rule: `${fieldName}_pattern`,
                         valid: false,
-                        message: `Invalid regex pattern: ${patternValue}`,
+                        message: `Invalid regex pattern: ${validation.pattern}`,
                         severity: 'error',
                         fields: [fieldName],
                     });

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

@@ -0,0 +1,255 @@
+/**
+ * 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.
+ * 
+ * For now, this mock delegates to the legacy driver to maintain backward compatibility
+ * during the migration phase.
+ */
+
+// Simple mock implementations of runtime managers
+class MockMetadataRegistry {
+    private store = new Map<string, Map<string, any>>();
+    
+    register(type: string, item: 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);
+    }
+    
+    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());
+    }
+    
+    unregisterPackage(packageName: string): void {
+        // Simple implementation - in real runtime this would filter by package
+        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 {
+    private hooks = new Map<string, any[]>();
+    
+    register(hookName: string, objectName: string, handler: any, packageName?: string): void {
+        if (!this.hooks.has(hookName)) {
+            this.hooks.set(hookName, []);
+        }
+        this.hooks.get(hookName)!.push({ objectName, handler, packageName });
+    }
+    
+    async trigger(hookName: string, objectName: string, context: any): Promise<void> {
+        const handlers = this.hooks.get(hookName) || [];
+        for (const entry of handlers) {
+            // Match on wildcard '*' or specific object name
+            if (entry.objectName === '*' || entry.objectName === objectName) {
+                await entry.handler(context);
+            }
+        }
+    }
+    
+    removePackage(packageName: string): void {
+        for (const [hookName, handlers] of this.hooks.entries()) {
+            this.hooks.set(hookName, handlers.filter(h => h.packageName !== packageName));
+        }
+    }
+    
+    clear(): void {
+        this.hooks.clear();
+    }
+}
+
+class MockActionManager {
+    private actions = new Map<string, any>();
+    
+    register(objectName: string, actionName: string, handler: any, packageName?: string): void {
+        const key = `${objectName}.${actionName}`;
+        this.actions.set(key, { handler, packageName });
+    }
+    
+    async execute(objectName: string, actionName: string, context: any): Promise<any> {
+        const key = `${objectName}.${actionName}`;
+        const action = this.actions.get(key);
+        if (!action) {
+            throw new Error(`Action ${actionName} not found for object ${objectName}`);
+        }
+        return await action.handler(context);
+    }
+    
+    get(objectName: string, actionName: string): any {
+        const key = `${objectName}.${actionName}`;
+        return this.actions.get(key)?.handler;
+    }
+    
+    removePackage(packageName: string): void {
+        const toDelete: string[] = [];
+        for (const [key, action] of this.actions.entries()) {
+            if (action.packageName === packageName) {
+                toDelete.push(key);
+            }
+        }
+        toDelete.forEach(key => this.actions.delete(key));
+    }
+    
+    clear(): void {
+        this.actions.clear();
+    }
+}
+
+export class ObjectStackKernel {
+    public ql: unknown = null;
+    public metadata: MockMetadataRegistry;
+    public hooks: MockHookManager;
+    public actions: MockActionManager;
+    
+    private plugins: any[] = [];
+    private driver: any = null; // Will be set by the ObjectQL app
+    
+    constructor(plugins: any[] = []) {
+        this.plugins = plugins;
+        this.metadata = new MockMetadataRegistry();
+        this.hooks = new MockHookManager();
+        this.actions = new MockActionManager();
+    }
+    
+    // Method to set the driver for delegation during migration
+    setDriver(driver: any): void {
+        this.driver = driver;
+    }
+    
+    async start(): Promise<void> {
+        // Mock implementation that calls plugin lifecycle methods
+        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 seed(): Promise<void> {
+        // Mock implementation
+    }
+    
+    async find(objectName: string, query: any): Promise<{ value: Record<string, any>[]; count: number }> {
+        // Delegate to driver during migration phase
+        if (this.driver) {
+            // Convert QueryAST back to UnifiedQuery format for driver
+            const unifiedQuery: any = {};
+            
+            if (query.fields) {
+                unifiedQuery.fields = query.fields;
+            }
+            if (query.filters) {
+                unifiedQuery.filters = query.filters;
+            }
+            if (query.sort) {
+                unifiedQuery.sort = query.sort.map((s: any) => [s.field, s.order]);
+            }
+            if (query.top !== undefined) {
+                unifiedQuery.limit = query.top;
+            }
+            if (query.skip !== undefined) {
+                unifiedQuery.skip = query.skip;
+            }
+            if (query.aggregations) {
+                unifiedQuery.aggregate = query.aggregations.map((agg: any) => ({
+                    func: agg.function,
+                    field: agg.field,
+                    alias: agg.alias
+                }));
+            }
+            if (query.groupBy) {
+                unifiedQuery.groupBy = query.groupBy;
+            }
+            
+            const results = await this.driver.find(objectName, unifiedQuery, {});
+            return { value: results, count: results.length };
+        }
+        return { value: [], count: 0 };
+    }
+    
+    async get(objectName: string, id: string): Promise<Record<string, any>> {
+        // Delegate to driver during migration phase
+        if (this.driver) {
+            return await this.driver.findOne(objectName, id, {}, {});
+        }
+        return {};
+    }
+    
+    async create(objectName: string, data: any): Promise<Record<string, any>> {
+        // Delegate to driver during migration phase
+        if (this.driver) {
+            return await this.driver.create(objectName, data, {});
+        }
+        return data;
+    }
+    
+    async update(objectName: string, id: string, data: any): Promise<Record<string, any>> {
+        // Delegate to driver during migration phase
+        if (this.driver) {
+            return await this.driver.update(objectName, id, data, {});
+        }
+        return data;
+    }
+    
+    async delete(objectName: string, id: string): Promise<boolean> {
+        // Delegate to driver during migration phase
+        if (this.driver) {
+            await this.driver.delete(objectName, id, {});
+            return true;
+        }
+        return true;
+    }
+    
+    getMetadata(objectName: string): any {
+        return {};
+    }
+    
+    getView(objectName: string, viewType?: 'list' | 'form'): any {
+        return null;
+    }
+}
+
+export class ObjectStackRuntimeProtocol {}
+
+export interface RuntimeContext {
+    engine: ObjectStackKernel;
+}
+
+export interface RuntimePlugin {
+    name: string;
+    install?: (ctx: RuntimeContext) => void | Promise<void>;
+    onStart?: (ctx: RuntimeContext) => void | Promise<void>;
+}

package/test/app.test.ts

@@ -1,6 +1,15 @@
+/**
+ * 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 { ObjectQL } from '../src/app';
 import { MockDriver } from './mock-driver';
-import { ObjectConfig, ObjectQLPlugin, HookContext, ActionContext, Metadata } from '@objectql/types';
+import { ObjectConfig, HookContext, ActionContext, Metadata } from '@objectql/types';
+import type { PluginDefinition } from '@objectstack/spec';
 
 const todoObject: ObjectConfig = {
     name: 'todo',
@@ -57,9 +66,9 @@ describe('ObjectQL App', () => {
         });
 
         it('should accept plugin instances', () => {
-            const mockPlugin: ObjectQLPlugin = {
-                name: 'test-plugin',
-                setup: jest.fn()
+            const mockPlugin: PluginDefinition = {
+                id: 'test-plugin',
+                onEnable: jest.fn()
             };
             const app = new ObjectQL({
                 datasources: {},
@@ -282,11 +291,13 @@ describe('ObjectQL App', () => {
     });
 
     describe('Plugin System', () => {
-        it('should initialize plugins on init', async () => {
-            const setupFn = jest.fn();
-            const mockPlugin: ObjectQLPlugin = {
+        it('should initialize runtime plugins on init', async () => {
+            const installFn = jest.fn();
+            const onStartFn = jest.fn();
+            const mockPlugin = {
                 name: 'test-plugin',
-                setup: setupFn
+                install: installFn,
+                onStart: onStartFn
             };
 
             const app = new ObjectQL({
@@ -295,43 +306,20 @@ describe('ObjectQL App', () => {
             });
 
             await app.init();
-            expect(setupFn).toHaveBeenCalledWith(app);
+            expect(installFn).toHaveBeenCalled();
+            expect(onStartFn).toHaveBeenCalled();
         });
 
         it('should use plugin method', () => {
-            const mockPlugin: ObjectQLPlugin = {
+            const mockPlugin = {
                 name: 'test-plugin',
-                setup: jest.fn()
+                install: jest.fn()
             };
 
             const app = new ObjectQL({ datasources: {} });
             app.use(mockPlugin);
             expect(app).toBeDefined();
         });
-
-        it('should provide package-scoped proxy for plugins', async () => {
-            let capturedApp: any;
-            const mockPlugin: ObjectQLPlugin = {
-                name: 'test-plugin',
-                setup: async (app) => {
-                    capturedApp = app;
-                }
-            };
-            (mockPlugin as any)._packageName = 'test-package';
-
-            const app = new ObjectQL({
-                datasources: {},
-                plugins: [mockPlugin]
-            });
-            app.registerObject(todoObject);
-
-            await app.init();
-
-            // Test proxied methods
-            const handler = jest.fn();
-            capturedApp.on('beforeCreate', 'todo', handler);
-            capturedApp.registerAction('todo', 'test', handler);
-        });
     });
 
     describe('Initialization', () => {