@objectstack/objectql 0.9.2 → 1.0.1

package/src/engine.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ObjectQL } from './engine';
+import { SchemaRegistry } from './registry';
+import { DriverInterface } from '@objectstack/spec/data';
+
+// Mock the SchemaRegistry to avoid side effects between tests
+vi.mock('./registry', () => {
+  const mockObjects = new Map();
+  return {
+    SchemaRegistry: {
+      getObject: vi.fn((name) => mockObjects.get(name)),
+      registerObject: vi.fn((obj) => mockObjects.set(obj.name, obj)),
+      registerKind: vi.fn(),
+      metadata: {
+        get: vi.fn(() => mockObjects) // Expose for verification if needed
+      }
+    }
+  };
+});
+
+describe('ObjectQL Engine', () => {
+    let engine: ObjectQL;
+    let mockDriver: DriverInterface;
+    let mockDriver2: DriverInterface;
+
+    beforeEach(() => {
+        // Clear Registry Mocks
+        vi.clearAllMocks();
+        
+        // Setup Drivers
+        mockDriver = {
+            name: 'default-driver',
+            connect: vi.fn().mockResolvedValue(undefined),
+            disconnect: vi.fn().mockResolvedValue(undefined),
+            find: vi.fn().mockResolvedValue([{ id: '1', name: 'Test Record' }]),
+            findOne: vi.fn(),
+            create: vi.fn().mockResolvedValue({ id: '1', success: true }),
+            update: vi.fn(),
+            delete: vi.fn(),
+            count: vi.fn(),
+            capabilities: {} as any // Simplified
+        } as unknown as DriverInterface;
+
+        mockDriver2 = {
+            name: 'mongo',
+            connect: vi.fn().mockResolvedValue(undefined),
+            disconnect: vi.fn().mockResolvedValue(undefined),
+            find: vi.fn().mockResolvedValue([{ id: '2', name: 'Mongo Record' }]),
+            findOne: vi.fn(),
+            create: vi.fn().mockResolvedValue({ id: '2', success: true }),
+            update: vi.fn(),
+            delete: vi.fn(),
+            count: vi.fn(),
+            capabilities: {} as any
+        } as unknown as DriverInterface;
+
+        engine = new ObjectQL();
+    });
+
+    describe('Initialization', () => {
+        it('should initialize with default logger', () => {
+            expect(engine).toBeDefined();
+            expect(engine.getStatus().status).toBe('running');
+        });
+
+        it('should register and connect drivers on init', async () => {
+            engine.registerDriver(mockDriver, true);
+            await engine.init();
+            expect(mockDriver.connect).toHaveBeenCalled();
+        });
+    });
+
+    describe('Metadata Registration', () => {
+        it('should register objects from app manifest', () => {
+            const manifest = {
+                id: 'com.example.app',
+                objects: [
+                    { name: 'task', fields: {} }
+                ]
+            };
+            
+            engine.registerApp(manifest);
+            expect(SchemaRegistry.registerObject).toHaveBeenCalledWith(expect.objectContaining({ name: 'task' }));
+        });
+
+        it('should register kinds from app manifest', () => {
+            const manifest = {
+                id: 'com.example.app',
+                contributes: {
+                    kinds: [{ id: 'test.kind', description: 'Test Kind' }]
+                }
+            };
+            
+            engine.registerApp(manifest);
+            expect(SchemaRegistry.registerKind).toHaveBeenCalledWith(expect.objectContaining({ id: 'test.kind' }));
+        });
+    });
+
+    describe('Driver Routing', () => {
+        beforeEach(async () => {
+            // Setup:
+            // - Default Driver: mockDriver
+            // - Specific Driver: mockDriver2 (named 'mongo')
+            engine.registerDriver(mockDriver, true);
+            engine.registerDriver(mockDriver2);
+            await engine.init();
+        });
+
+        it('should route to default driver when no datasource is specified', async () => {
+            // Mock Schema: Object uses default datasource
+            vi.mocked(SchemaRegistry.getObject).mockReturnValue({ name: 'task', datasource: 'default', fields: {} });
+
+            await engine.find('task', { filters: [] });
+            
+            expect(mockDriver.find).toHaveBeenCalled();
+            expect(mockDriver2.find).not.toHaveBeenCalled();
+        });
+
+        it('should route to specific driver when datasource is specified', async () => {
+            // Mock Schema: Object uses 'mongo' datasource
+            vi.mocked(SchemaRegistry.getObject).mockReturnValue({ name: 'log', datasource: 'mongo', fields: {} });
+
+            await engine.find('log', { filters: [] });
+            
+            expect(mockDriver.find).not.toHaveBeenCalled();
+            expect(mockDriver2.find).toHaveBeenCalled();
+        });
+
+        it('should throw error if datasource is not found', async () => {
+             // Mock Schema: Object uses unknown datasource
+             vi.mocked(SchemaRegistry.getObject).mockReturnValue({ name: 'old_data', datasource: 'legacy_sql', fields: {} });
+
+             await expect(engine.find('old_data', {})).rejects.toThrow("Datasource 'legacy_sql' configured for object 'old_data' is not registered");
+        });
+    });
+
+    describe('CRUD Operations', () => {
+        beforeEach(async () => {
+            engine.registerDriver(mockDriver, true);
+            await engine.init();
+            vi.mocked(SchemaRegistry.getObject).mockReturnValue({ name: 'task', fields: {} });
+        });
+
+        it('should execute insert operation', async () => {
+            const result = await engine.insert('task', { title: 'New Task' });
+            expect(mockDriver.create).toHaveBeenCalledWith('task', { title: 'New Task' }, undefined);
+            expect(result).toEqual({ id: '1', success: true });
+        });
+
+        it('should execute find operation', async () => {
+            const result = await engine.find('task', {});
+            expect(mockDriver.find).toHaveBeenCalled();
+            expect(result).toHaveLength(1);
+        });
+    });
+});

package/src/engine.ts

@@ -8,6 +8,7 @@ import {
   DataEngineCountOptions 
 } from '@objectstack/spec/data';
 import { DriverInterface, IDataEngine, Logger, createLogger } from '@objectstack/core';
+import { CoreServiceName } from '@objectstack/spec/system';
 import { SchemaRegistry } from './registry.js';
 
 export type HookHandler = (context: HookContext) => Promise<void> | void;
@@ -26,6 +27,9 @@ export interface ObjectQLHostContext {
  * ObjectQL Engine
  * 
  * Implements the IDataEngine interface for data persistence.
+ * Acts as the reference implementation for:
+ * - CoreServiceName.data (CRUD)
+ * - CoreServiceName.metadata (Schema Registry)
  */
 export class ObjectQL implements IDataEngine {
   private drivers = new Map<string, DriverInterface>();
@@ -50,6 +54,19 @@ export class ObjectQL implements IDataEngine {
     this.logger.info('ObjectQL Engine Instance Created');
   }
 
+  /**
+   * Service Status Report
+   * Used by Kernel to verify health and capabilities.
+   */
+  getStatus() {
+      return {
+          name: CoreServiceName.enum.data,
+          status: 'running',
+          version: '0.9.0',
+          features: ['crud', 'query', 'aggregate', 'transactions', 'metadata']
+      };
+  }
+
   /**
    * Expose the SchemaRegistry for plugins to register metadata
    */

package/src/plugin.ts

@@ -21,7 +21,7 @@ export class ObjectQLPlugin implements Plugin {
     }
   }
 
-  async init(ctx: PluginContext) {
+  init = async (ctx: PluginContext) => {
     if (!this.ql) {
         this.ql = new ObjectQL(this.hostContext);
     }
@@ -39,7 +39,7 @@ export class ObjectQLPlugin implements Plugin {
     ctx.logger.info('Protocol service registered');
   }
 
-  async start(ctx: PluginContext) {
+  start = async (ctx: PluginContext) => {
     ctx.logger.info('ObjectQL engine initialized');
     
     // Discover features from Kernel Services

package/src/protocol.ts

@@ -36,8 +36,19 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         return {
             version: '1.0',
             apiName: 'ObjectStack API',
-            capabilities: ['metadata', 'data', 'ui'],
-            endpoints: {}
+            capabilities: {
+                graphql: false,
+                search: false,
+                websockets: false,
+                files: true,
+                analytics: false,
+                hub: false
+            },
+            endpoints: {
+                data: '/api/data',
+                metadata: '/api/meta',
+                auth: '/api/auth'
+            }
         };
     }
 
@@ -228,6 +239,30 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         throw new Error('updateManyData not implemented');
     }
 
+    async analyticsQuery(_request: any): Promise<any> {
+        throw new Error('analyticsQuery not implemented');
+    }
+
+    async getAnalyticsMeta(_request: any): Promise<any> {
+        throw new Error('getAnalyticsMeta not implemented');
+    }
+
+    async triggerAutomation(_request: any): Promise<any> {
+        throw new Error('triggerAutomation not implemented');
+    }
+
+    async listSpaces(_request: any): Promise<any> {
+        throw new Error('listSpaces not implemented');
+    }
+
+    async createSpace(_request: any): Promise<any> {
+        throw new Error('createSpace not implemented');
+    }
+
+    async installPlugin(_request: any): Promise<any> {
+        throw new Error('installPlugin not implemented');
+    }
+
     async deleteManyData(request: DeleteManyDataRequest): Promise<any> {
         // This expects deleting by IDs.
         return this.engine.delete(request.object, {
@@ -236,4 +271,15 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         });
     }
 
+    async saveMetaItem(request: { type: string, name: string, item?: any }) {
+        if (!request.item) {
+            throw new Error('Item data is required');
+        }
+        // Default implementation saves to Memory Registry
+        SchemaRegistry.registerItem(request.type, request.item, 'name');
+        return {
+            success: true,
+            message: 'Saved to memory registry'
+        };
+    }
 }

package/src/registry.ts

@@ -1,5 +1,6 @@
-import { ServiceObject } from '@objectstack/spec/data';
-import { ObjectStackManifest } from '@objectstack/spec/system';
+import { ServiceObject, ObjectSchema } from '@objectstack/spec/data';
+import { ObjectStackManifest, ManifestSchema } from '@objectstack/spec/kernel';
+import { AppSchema } from '@objectstack/spec/ui';
 
 /**
  * Global Schema Registry
@@ -22,6 +23,15 @@ export class SchemaRegistry {
     const collection = this.metadata.get(type)!;
     const key = String(item[keyField]);
 
+    // Validation Hook
+    try {
+        this.validate(type, item);
+    } catch (e: any) {
+        console.error(`[Registry] Validation failed for ${type} ${key}: ${e.message}`);
+        // For now, warn but don't crash, allowing partial/legacy loads
+        // throw e; 
+    }
+
     if (collection.has(key)) {
       console.warn(`[Registry] Overwriting ${type}: ${key}`);
     }
@@ -29,6 +39,24 @@ export class SchemaRegistry {
     console.log(`[Registry] Registered ${type}: ${key}`);
   }
 
+  /**
+   * Validate Metadata against Spec Zod Schemas
+   */
+  static validate(type: string, item: any) {
+      if (type === 'object') {
+          return ObjectSchema.parse(item);
+      }
+      if (type === 'app') {
+          // AppSchema might rely on Zod, imported via UI protocol
+          return AppSchema.parse(item);
+      }
+      if (type === 'plugin') {
+          return ManifestSchema.parse(item);
+      }
+      // Add more validations as needed
+      return true;
+  }
+
   /**
    * Universal Unregister Method
    */