@objectstack/objectql 1.1.0 → 2.0.1

package/src/engine.ts

@@ -1,3 +1,5 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
 import { QueryAST, HookContext } from '@objectstack/spec/data';
 import { 
   DataEngineQueryOptions, 
@@ -219,8 +221,20 @@ export class ObjectQL implements IDataEngine {
 
       // 5. Register all other metadata types generically
       const metadataArrayKeys = [
-        'actions', 'dashboards', 'reports', 'flows', 'agents',
-        'apis', 'ragPipelines', 'profiles', 'sharingRules'
+        // UI Protocol
+        'actions', 'views', 'pages', 'dashboards', 'reports', 'themes',
+        // Automation Protocol
+        'flows', 'workflows', 'approvals', 'webhooks',
+        // Security Protocol
+        'roles', 'permissions', 'profiles', 'sharingRules', 'policies',
+        // AI Protocol
+        'agents', 'ragPipelines',
+        // API Protocol
+        'apis',
+        // Data Extensions
+        'hooks', 'mappings', 'analyticsCubes',
+        // Integration Protocol
+        'connectors',
       ];
       for (const key of metadataArrayKeys) {
           const items = (manifest as any)[key];
@@ -425,13 +439,13 @@ export class ObjectQL implements IDataEngine {
     await this.triggerHooks('beforeFind', hookContext);
 
     try {
-        const result = await driver.find(object, hookContext.input.ast, hookContext.input.options);
+        const result = await driver.find(object, hookContext.input.ast as QueryAST, hookContext.input.options as any);
         
         hookContext.event = 'afterFind';
         hookContext.result = result;
         await this.triggerHooks('afterFind', hookContext);
         
-        return hookContext.result;
+        return hookContext.result as any[];
     } catch (e) {
         this.logger.error('Find operation failed', e as Error, { object });
         throw e;
@@ -468,13 +482,13 @@ export class ObjectQL implements IDataEngine {
       if (Array.isArray(hookContext.input.data)) {
         // Bulk Create
         if (driver.bulkCreate) {
-             result = await driver.bulkCreate(object, hookContext.input.data, hookContext.input.options);
+             result = await driver.bulkCreate(object, hookContext.input.data as any[], hookContext.input.options as any);
         } else {
              // Fallback loop
-             result = await Promise.all(hookContext.input.data.map((item: any) => driver.create(object, item, hookContext.input.options)));
+             result = await Promise.all((hookContext.input.data as any[]).map((item: any) => driver.create(object, item, hookContext.input.options as any)));
         }
       } else {
-        result = await driver.create(object, hookContext.input.data, hookContext.input.options);
+        result = await driver.create(object, hookContext.input.data, hookContext.input.options as any);
       }
 
       hookContext.event = 'afterInsert';
@@ -517,11 +531,11 @@ export class ObjectQL implements IDataEngine {
          let result;
          if (hookContext.input.id) {
              // Single update by ID
-             result = await driver.update(object, hookContext.input.id, hookContext.input.data, hookContext.input.options);
+             result = await driver.update(object, hookContext.input.id as string, hookContext.input.data, hookContext.input.options as any);
          } else if (options?.multi && driver.updateMany) {
              // Bulk update by Query
              const ast = this.toQueryAST(object, { filter: options.filter });
-             result = await driver.updateMany(object, ast, hookContext.input.data, hookContext.input.options);
+             result = await driver.updateMany(object, ast, hookContext.input.data, hookContext.input.options as any);
          } else {
              throw new Error('Update requires an ID or options.multi=true');
          }
@@ -560,10 +574,10 @@ export class ObjectQL implements IDataEngine {
     try {
         let result;
         if (hookContext.input.id) {
-            result = await driver.delete(object, hookContext.input.id, hookContext.input.options);
+            result = await driver.delete(object, hookContext.input.id as string, hookContext.input.options as any);
         } else if (options?.multi && driver.deleteMany) {
              const ast = this.toQueryAST(object, { filter: options.filter });
-             result = await driver.deleteMany(object, ast, hookContext.input.options);
+             result = await driver.deleteMany(object, ast, hookContext.input.options as any);
         } else {
              throw new Error('Delete requires an ID or options.multi=true');
         }
@@ -594,10 +608,22 @@ export class ObjectQL implements IDataEngine {
       object = this.resolveObjectName(object);
       const driver = this.getDriver(object);
       this.logger.debug(`Aggregate on ${object} using ${driver.name}`, query);
-      // Driver needs support for raw aggregation or mapped aggregation
-      // For now, if driver supports 'execute', we might pass it down, or we need to add 'aggregate' to DriverInterface
-      // In this version, we'll assume driver might handle it via special 'find' or throw not implemented
-      throw new Error('Aggregate not yet fully implemented in ObjectQL->Driver mapping');
+
+      // Build a QueryAST with groupBy and aggregations, delegate to driver.find()
+      // Drivers that support aggregation (e.g. InMemoryDriver) handle groupBy/aggregations
+      // in their find() implementation via performAggregation().
+      const ast: QueryAST = {
+          object,
+          where: query.filter,
+          groupBy: query.groupBy,
+          aggregations: query.aggregations?.map(agg => ({
+              function: agg.method,
+              field: agg.field,
+              alias: agg.alias || `${agg.method}_${agg.field || 'all'}`,
+          })),
+      };
+
+      return driver.find(object, ast);
   }
   
   async execute(command: any, options?: Record<string, any>): Promise<any> {

package/src/index.ts

@@ -1,3 +1,5 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
 // Export Registry
 export { 
   SchemaRegistry,

package/src/plugin.ts

@@ -1,3 +1,5 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
 import { ObjectQL } from './engine.js';
 import { ObjectStackProtocolImplementation } from './protocol.js';
 import { Plugin, PluginContext } from '@objectstack/core';

package/src/protocol.ts

@@ -1,3 +1,5 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
 import { ObjectStackProtocol } from '@objectstack/spec/api';
 import { IDataEngine } from '@objectstack/core';
 import type { 
@@ -32,7 +34,7 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         this.engine = engine;
     }
 
-    async getDiscovery(_request: {}) {
+    async getDiscovery() {
         return {
             version: '1.0',
             apiName: 'ObjectStack API',
@@ -40,36 +42,74 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
                 graphql: false,
                 search: false,
                 websockets: false,
-                files: true,
-                analytics: false,
-                hub: false
+                files: false,
+                analytics: true,
+                ai: false,
+                workflow: false,
+                notifications: false,
+                i18n: false,
             },
             endpoints: {
                 data: '/api/data',
                 metadata: '/api/meta',
-                auth: '/api/auth'
-            }
+                analytics: '/api/analytics',
+            },
+            services: {
+                // --- Kernel-provided (objectql is an example kernel implementation) ---
+                metadata:  { enabled: true, status: 'degraded' as const, route: '/api/meta', provider: 'objectql', message: 'In-memory registry only; DB persistence not yet implemented' },
+                data:      { enabled: true, status: 'available' as const, route: '/api/data', provider: 'objectql' },
+                analytics: { enabled: true, status: 'available' as const, route: '/api/analytics', provider: 'objectql' },
+                // --- Plugin-provided (kernel does NOT handle these) ---
+                auth:         { enabled: false, status: 'unavailable' as const, message: 'Install an auth plugin (e.g. plugin-auth) to enable' },
+                automation:   { enabled: false, status: 'unavailable' as const, message: 'Install an automation plugin (e.g. plugin-automation) to enable' },
+                // --- Core infrastructure (plugin-provided) ---
+                cache:        { enabled: false, status: 'unavailable' as const, message: 'Install a cache plugin (e.g. plugin-redis) to enable' },
+                queue:        { enabled: false, status: 'unavailable' as const, message: 'Install a queue plugin (e.g. plugin-bullmq) to enable' },
+                job:          { enabled: false, status: 'unavailable' as const, message: 'Install a job scheduler plugin to enable' },
+                // --- Optional services (all plugin-provided) ---
+                ui:             { enabled: false, status: 'unavailable' as const, message: 'Install a UI plugin to enable' },
+                workflow:       { enabled: false, status: 'unavailable' as const, message: 'Install a workflow plugin to enable' },
+                realtime:       { enabled: false, status: 'unavailable' as const, message: 'Install a realtime plugin to enable' },
+                notification:   { enabled: false, status: 'unavailable' as const, message: 'Install a notification plugin to enable' },
+                ai:             { enabled: false, status: 'unavailable' as const, message: 'Install an AI plugin to enable' },
+                i18n:           { enabled: false, status: 'unavailable' as const, message: 'Install an i18n plugin to enable' },
+                graphql:        { enabled: false, status: 'unavailable' as const, message: 'Install a GraphQL plugin to enable' },
+                'file-storage': { enabled: false, status: 'unavailable' as const, message: 'Install a file-storage plugin to enable' },
+                search:         { enabled: false, status: 'unavailable' as const, message: 'Install a search plugin to enable' },
+            },
         };
     }
 
-    async getMetaTypes(_request: {}) {
+    async getMetaTypes() {
         return {
             types: SchemaRegistry.getRegisteredTypes()
         };
     }
 
-    async getMetaItems(request: { type: string; packageId?: string }) {
+    async getMetaItems(request: { type: string }) {
+        let items = SchemaRegistry.listItems(request.type);
+        // Normalize singular/plural: REST uses singular ('app') but registry may store as plural ('apps')
+        if (items.length === 0) {
+            const alt = request.type.endsWith('s') ? request.type.slice(0, -1) : request.type + 's';
+            items = SchemaRegistry.listItems(alt);
+        }
         return {
             type: request.type,
-            items: SchemaRegistry.listItems(request.type, request.packageId)
+            items
         };
     }
 
     async getMetaItem(request: { type: string, name: string }) {
+        let item = SchemaRegistry.getItem(request.type, request.name);
+        // Normalize singular/plural
+        if (item === undefined) {
+            const alt = request.type.endsWith('s') ? request.type.slice(0, -1) : request.type + 's';
+            item = SchemaRegistry.getItem(alt, request.name);
+        }
         return {
             type: request.type,
             name: request.name,
-            item: SchemaRegistry.getItem(request.type, request.name)
+            item
         };
     }
 
@@ -258,12 +298,84 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
     // Batch Operations
     // ==========================================
 
-    async batchData(_request: { object: string, request: BatchUpdateRequest }): Promise<BatchUpdateResponse> {
-        // Map high-level batch request to DataEngine batch if available
-        // Or implement loop here.
-        // For now, let's just fail or implement basic loop to satisfying interface
-        // since full batch mapping requires careful type handling.
-        throw new Error('Batch operations not yet fully implemented in protocol adapter');
+    async batchData(request: { object: string, request: BatchUpdateRequest }): Promise<BatchUpdateResponse> {
+        const { object, request: batchReq } = request;
+        const { operation, records, options } = batchReq;
+        const results: Array<{ id?: string; success: boolean; error?: string; record?: any }> = [];
+        let succeeded = 0;
+        let failed = 0;
+
+        for (const record of records) {
+            try {
+                switch (operation) {
+                    case 'create': {
+                        const created = await this.engine.insert(object, record.data || record);
+                        results.push({ id: created._id || created.id, success: true, record: created });
+                        succeeded++;
+                        break;
+                    }
+                    case 'update': {
+                        if (!record.id) throw new Error('Record id is required for update');
+                        const updated = await this.engine.update(object, record.data || {}, { filter: { _id: record.id } });
+                        results.push({ id: record.id, success: true, record: updated });
+                        succeeded++;
+                        break;
+                    }
+                    case 'upsert': {
+                        // Try update first, then create if not found
+                        if (record.id) {
+                            try {
+                                const existing = await this.engine.findOne(object, { filter: { _id: record.id } });
+                                if (existing) {
+                                    const updated = await this.engine.update(object, record.data || {}, { filter: { _id: record.id } });
+                                    results.push({ id: record.id, success: true, record: updated });
+                                } else {
+                                    const created = await this.engine.insert(object, { _id: record.id, ...(record.data || {}) });
+                                    results.push({ id: created._id || created.id, success: true, record: created });
+                                }
+                            } catch {
+                                const created = await this.engine.insert(object, { _id: record.id, ...(record.data || {}) });
+                                results.push({ id: created._id || created.id, success: true, record: created });
+                            }
+                        } else {
+                            const created = await this.engine.insert(object, record.data || record);
+                            results.push({ id: created._id || created.id, success: true, record: created });
+                        }
+                        succeeded++;
+                        break;
+                    }
+                    case 'delete': {
+                        if (!record.id) throw new Error('Record id is required for delete');
+                        await this.engine.delete(object, { filter: { _id: record.id } });
+                        results.push({ id: record.id, success: true });
+                        succeeded++;
+                        break;
+                    }
+                    default:
+                        results.push({ id: record.id, success: false, error: `Unknown operation: ${operation}` });
+                        failed++;
+                }
+            } catch (err: any) {
+                results.push({ id: record.id, success: false, error: err.message });
+                failed++;
+                if (options?.atomic) {
+                    // Abort remaining operations on first failure in atomic mode
+                    break;
+                }
+                if (!options?.continueOnError) {
+                    break;
+                }
+            }
+        }
+
+        return {
+            success: failed === 0,
+            operation,
+            total: records.length,
+            succeeded,
+            failed,
+            results: options?.returnRecords !== false ? results : results.map(r => ({ id: r.id, success: r.success, error: r.error })),
+        } as BatchUpdateResponse;
     }
     
     async createManyData(request: { object: string, records: any[] }): Promise<any> {
@@ -275,33 +387,211 @@ export class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         };
     }
     
-    async updateManyData(_request: UpdateManyDataRequest): Promise<any> {
-        // TODO: Implement proper updateMany in DataEngine
-        throw new Error('updateManyData not implemented');
-    }
+    async updateManyData(request: UpdateManyDataRequest): Promise<BatchUpdateResponse> {
+        const { object, records, options } = request;
+        const results: Array<{ id?: string; success: boolean; error?: string; record?: any }> = [];
+        let succeeded = 0;
+        let failed = 0;
+
+        for (const record of records) {
+            try {
+                const updated = await this.engine.update(object, record.data, { filter: { _id: record.id } });
+                results.push({ id: record.id, success: true, record: updated });
+                succeeded++;
+            } catch (err: any) {
+                results.push({ id: record.id, success: false, error: err.message });
+                failed++;
+                if (!options?.continueOnError) {
+                    break;
+                }
+            }
+        }
 
-    async analyticsQuery(_request: any): Promise<any> {
-        throw new Error('analyticsQuery not implemented');
+        return {
+            success: failed === 0,
+            operation: 'update',
+            total: records.length,
+            succeeded,
+            failed,
+            results,
+        } as BatchUpdateResponse;
     }
 
-    async getAnalyticsMeta(_request: any): Promise<any> {
-        throw new Error('getAnalyticsMeta not implemented');
-    }
+    async analyticsQuery(request: any): Promise<any> {
+        // Map AnalyticsQuery (cube-style) to engine aggregation.
+        // cube name maps to object name; measures → aggregations; dimensions → groupBy.
+        const { query, cube } = request;
+        const object = cube;
+
+        // Build groupBy from dimensions
+        const groupBy = query.dimensions || [];
+
+        // Build aggregations from measures
+        // Measures can be simple field names like "count" or "field_name.sum"
+        // Or cube-defined measure names. We support: field.function or just function(field).
+        const aggregations: Array<{ field: string; method: string; alias: string }> = [];
+        if (query.measures) {
+            for (const measure of query.measures) {
+                // Support formats: "count", "amount.sum", "revenue.avg"
+                if (measure === 'count' || measure === 'count_all') {
+                    aggregations.push({ field: '*', method: 'count', alias: 'count' });
+                } else if (measure.includes('.')) {
+                    const [field, method] = measure.split('.');
+                    aggregations.push({ field, method, alias: `${field}_${method}` });
+                } else {
+                    // Treat as count of the field
+                    aggregations.push({ field: measure, method: 'sum', alias: measure });
+                }
+            }
+        }
 
-    async triggerAutomation(_request: any): Promise<any> {
-        throw new Error('triggerAutomation not implemented');
+        // Build filter from analytics filters
+        let filter: any = undefined;
+        if (query.filters && query.filters.length > 0) {
+            const conditions: any[] = query.filters.map((f: any) => {
+                const op = this.mapAnalyticsOperator(f.operator);
+                if (f.values && f.values.length === 1) {
+                    return { [f.member]: { [op]: f.values[0] } };
+                } else if (f.values && f.values.length > 1) {
+                    return { [f.member]: { $in: f.values } };
+                }
+                return { [f.member]: { [op]: true } };
+            });
+            filter = conditions.length === 1 ? conditions[0] : { $and: conditions };
+        }
+
+        // Execute via engine.aggregate (which delegates to driver.find with groupBy/aggregations)
+        const rows = await this.engine.aggregate(object, {
+            filter,
+            groupBy: groupBy.length > 0 ? groupBy : undefined,
+            aggregations: aggregations.length > 0
+                ? aggregations.map(a => ({ field: a.field, method: a.method as any, alias: a.alias }))
+                : [{ field: '*', method: 'count' as any, alias: 'count' }],
+        });
+
+        // Build field metadata
+        const fields = [
+            ...groupBy.map((d: string) => ({ name: d, type: 'string' })),
+            ...aggregations.map(a => ({ name: a.alias, type: 'number' })),
+        ];
+
+        return {
+            success: true,
+            data: {
+                rows,
+                fields,
+            },
+        };
     }
 
-    async listSpaces(_request: any): Promise<any> {
-        throw new Error('listSpaces not implemented');
+    async getAnalyticsMeta(request: any): Promise<any> {
+        // Auto-generate cube metadata from registered objects in SchemaRegistry.
+        // Each object becomes a cube; number fields → measures; other fields → dimensions.
+        const objects = SchemaRegistry.listItems('object');
+        const cubeFilter = request?.cube;
+
+        const cubes: any[] = [];
+        for (const obj of objects) {
+            const schema = obj as any;
+            if (cubeFilter && schema.name !== cubeFilter) continue;
+
+            const measures: Record<string, any> = {};
+            const dimensions: Record<string, any> = {};
+            const fields = schema.fields || {};
+
+            // Always add a count measure
+            measures['count'] = {
+                name: 'count',
+                label: 'Count',
+                type: 'count',
+                sql: '*',
+            };
+
+            for (const [fieldName, fieldDef] of Object.entries(fields)) {
+                const fd = fieldDef as any;
+                const fieldType = fd.type || 'text';
+
+                if (['number', 'currency', 'percent'].includes(fieldType)) {
+                    // Numeric fields become both measures and dimensions
+                    measures[`${fieldName}_sum`] = {
+                        name: `${fieldName}_sum`,
+                        label: `${fd.label || fieldName} (Sum)`,
+                        type: 'sum',
+                        sql: fieldName,
+                    };
+                    measures[`${fieldName}_avg`] = {
+                        name: `${fieldName}_avg`,
+                        label: `${fd.label || fieldName} (Avg)`,
+                        type: 'avg',
+                        sql: fieldName,
+                    };
+                    dimensions[fieldName] = {
+                        name: fieldName,
+                        label: fd.label || fieldName,
+                        type: 'number',
+                        sql: fieldName,
+                    };
+                } else if (['date', 'datetime'].includes(fieldType)) {
+                    dimensions[fieldName] = {
+                        name: fieldName,
+                        label: fd.label || fieldName,
+                        type: 'time',
+                        sql: fieldName,
+                        granularities: ['day', 'week', 'month', 'quarter', 'year'],
+                    };
+                } else if (['boolean'].includes(fieldType)) {
+                    dimensions[fieldName] = {
+                        name: fieldName,
+                        label: fd.label || fieldName,
+                        type: 'boolean',
+                        sql: fieldName,
+                    };
+                } else {
+                    // text, select, lookup, etc. → dimension
+                    dimensions[fieldName] = {
+                        name: fieldName,
+                        label: fd.label || fieldName,
+                        type: 'string',
+                        sql: fieldName,
+                    };
+                }
+            }
+
+            cubes.push({
+                name: schema.name,
+                title: schema.label || schema.name,
+                description: schema.description,
+                sql: schema.name,
+                measures,
+                dimensions,
+                public: true,
+            });
+        }
+
+        return {
+            success: true,
+            data: { cubes },
+        };
     }
 
-    async createSpace(_request: any): Promise<any> {
-        throw new Error('createSpace not implemented');
+    private mapAnalyticsOperator(op: string): string {
+        const map: Record<string, string> = {
+            equals: '$eq',
+            notEquals: '$ne',
+            contains: '$contains',
+            notContains: '$notContains',
+            gt: '$gt',
+            gte: '$gte',
+            lt: '$lt',
+            lte: '$lte',
+            set: '$ne',
+            notSet: '$eq',
+        };
+        return map[op] || '$eq';
     }
 
-    async installPlugin(_request: any): Promise<any> {
-        throw new Error('installPlugin not implemented');
+    async triggerAutomation(_request: any): Promise<any> {
+        throw new Error('triggerAutomation requires plugin-automation service. Install and register a plugin that provides the "automation" service.');
     }
 
     async deleteManyData(request: DeleteManyDataRequest): Promise<any> {

package/src/registry.ts

@@ -1,3 +1,5 @@
+// Copyright (c) 2025 ObjectStack. Licensed under the Apache-2.0 license.
+
 import { ServiceObject, ObjectSchema, ObjectOwnership } from '@objectstack/spec/data';
 import { ObjectStackManifest, ManifestSchema, InstalledPackage, InstalledPackageSchema } from '@objectstack/spec/kernel';
 import { AppSchema } from '@objectstack/spec/ui';