@objectstack/objectql 2.0.0 → 2.0.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @objectstack/objectql@2.0.0 build /home/runner/work/spec/spec/packages/objectql
+> @objectstack/objectql@2.0.1 build /home/runner/work/spec/spec/packages/objectql
 > tsup --config ../../tsup.config.ts
 
 CLI Building entry: src/index.ts
@@ -10,13 +10,13 @@
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.js     44.79 KB
-CJS dist/index.js.map 89.92 KB
-CJS ⚡️ Build success in 83ms
-ESM dist/index.mjs     43.37 KB
-ESM dist/index.mjs.map 89.20 KB
-ESM ⚡️ Build success in 84ms
+ESM dist/index.mjs     53.23 KB
+ESM dist/index.mjs.map 109.67 KB
+ESM ⚡️ Build success in 79ms
+CJS dist/index.js     54.65 KB
+CJS dist/index.js.map 110.38 KB
+CJS ⚡️ Build success in 79ms
 DTS Build start
-DTS ⚡️ Build success in 10718ms
-DTS dist/index.d.mts 68.87 KB
-DTS dist/index.d.ts  68.87 KB
+DTS ⚡️ Build success in 11177ms
+DTS dist/index.d.mts 71.29 KB
+DTS dist/index.d.ts  71.29 KB

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @objectstack/objectql
 
+## 2.0.1
+
+### Patch Changes
+
+- Patch release for maintenance and stability improvements
+- Updated dependencies
+  - @objectstack/spec@2.0.1
+  - @objectstack/core@2.0.1
+  - @objectstack/types@2.0.1
+
 ## 2.0.0
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1203,7 +1203,6 @@ declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
             websockets: boolean;
             files: boolean;
             analytics: boolean;
-            hub: boolean;
             ai: boolean;
             workflow: boolean;
             notifications: boolean;
@@ -1212,7 +1211,98 @@ declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         endpoints: {
             data: string;
             metadata: string;
-            auth: string;
+            analytics: string;
+        };
+        services: {
+            metadata: {
+                enabled: boolean;
+                status: "degraded";
+                route: string;
+                provider: string;
+                message: string;
+            };
+            data: {
+                enabled: boolean;
+                status: "available";
+                route: string;
+                provider: string;
+            };
+            analytics: {
+                enabled: boolean;
+                status: "available";
+                route: string;
+                provider: string;
+            };
+            auth: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            automation: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            cache: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            queue: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            job: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            ui: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            workflow: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            realtime: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            notification: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            ai: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            i18n: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            graphql: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            'file-storage': {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            search: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
         };
     }>;
     getMetaTypes(): Promise<{
@@ -1319,7 +1409,7 @@ declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         name: string;
         cacheRequest?: MetadataCacheRequest;
     }): Promise<MetadataCacheResponse>;
-    batchData(_request: {
+    batchData(request: {
         object: string;
         request: BatchUpdateRequest;
     }): Promise<BatchUpdateResponse>;
@@ -1327,13 +1417,11 @@ declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         object: string;
         records: any[];
     }): Promise<any>;
-    updateManyData(_request: UpdateManyDataRequest): Promise<any>;
-    analyticsQuery(_request: any): Promise<any>;
-    getAnalyticsMeta(_request: any): Promise<any>;
+    updateManyData(request: UpdateManyDataRequest): Promise<BatchUpdateResponse>;
+    analyticsQuery(request: any): Promise<any>;
+    getAnalyticsMeta(request: any): Promise<any>;
+    private mapAnalyticsOperator;
     triggerAutomation(_request: any): Promise<any>;
-    listSpaces(_request: any): Promise<any>;
-    createSpace(_request: any): Promise<any>;
-    installPlugin(_request: any): Promise<any>;
     deleteManyData(request: DeleteManyDataRequest): Promise<any>;
     saveMetaItem(request: {
         type: string;

package/dist/index.d.ts

@@ -1203,7 +1203,6 @@ declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
             websockets: boolean;
             files: boolean;
             analytics: boolean;
-            hub: boolean;
             ai: boolean;
             workflow: boolean;
             notifications: boolean;
@@ -1212,7 +1211,98 @@ declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         endpoints: {
             data: string;
             metadata: string;
-            auth: string;
+            analytics: string;
+        };
+        services: {
+            metadata: {
+                enabled: boolean;
+                status: "degraded";
+                route: string;
+                provider: string;
+                message: string;
+            };
+            data: {
+                enabled: boolean;
+                status: "available";
+                route: string;
+                provider: string;
+            };
+            analytics: {
+                enabled: boolean;
+                status: "available";
+                route: string;
+                provider: string;
+            };
+            auth: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            automation: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            cache: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            queue: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            job: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            ui: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            workflow: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            realtime: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            notification: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            ai: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            i18n: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            graphql: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            'file-storage': {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
+            search: {
+                enabled: boolean;
+                status: "unavailable";
+                message: string;
+            };
         };
     }>;
     getMetaTypes(): Promise<{
@@ -1319,7 +1409,7 @@ declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         name: string;
         cacheRequest?: MetadataCacheRequest;
     }): Promise<MetadataCacheResponse>;
-    batchData(_request: {
+    batchData(request: {
         object: string;
         request: BatchUpdateRequest;
     }): Promise<BatchUpdateResponse>;
@@ -1327,13 +1417,11 @@ declare class ObjectStackProtocolImplementation implements ObjectStackProtocol {
         object: string;
         records: any[];
     }): Promise<any>;
-    updateManyData(_request: UpdateManyDataRequest): Promise<any>;
-    analyticsQuery(_request: any): Promise<any>;
-    getAnalyticsMeta(_request: any): Promise<any>;
+    updateManyData(request: UpdateManyDataRequest): Promise<BatchUpdateResponse>;
+    analyticsQuery(request: any): Promise<any>;
+    getAnalyticsMeta(request: any): Promise<any>;
+    private mapAnalyticsOperator;
     triggerAutomation(_request: any): Promise<any>;
-    listSpaces(_request: any): Promise<any>;
-    createSpace(_request: any): Promise<any>;
-    installPlugin(_request: any): Promise<any>;
     deleteManyData(request: DeleteManyDataRequest): Promise<any>;
     saveMetaItem(request: {
         type: string;

package/dist/index.js

@@ -546,9 +546,8 @@ var ObjectStackProtocolImplementation = class {
         graphql: false,
         search: false,
         websockets: false,
-        files: true,
-        analytics: false,
-        hub: false,
+        files: false,
+        analytics: true,
         ai: false,
         workflow: false,
         notifications: false,
@@ -557,7 +556,30 @@ var ObjectStackProtocolImplementation = class {
       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", route: "/api/meta", provider: "objectql", message: "In-memory registry only; DB persistence not yet implemented" },
+        data: { enabled: true, status: "available", route: "/api/data", provider: "objectql" },
+        analytics: { enabled: true, status: "available", route: "/api/analytics", provider: "objectql" },
+        // --- Plugin-provided (kernel does NOT handle these) ---
+        auth: { enabled: false, status: "unavailable", message: "Install an auth plugin (e.g. plugin-auth) to enable" },
+        automation: { enabled: false, status: "unavailable", message: "Install an automation plugin (e.g. plugin-automation) to enable" },
+        // --- Core infrastructure (plugin-provided) ---
+        cache: { enabled: false, status: "unavailable", message: "Install a cache plugin (e.g. plugin-redis) to enable" },
+        queue: { enabled: false, status: "unavailable", message: "Install a queue plugin (e.g. plugin-bullmq) to enable" },
+        job: { enabled: false, status: "unavailable", message: "Install a job scheduler plugin to enable" },
+        // --- Optional services (all plugin-provided) ---
+        ui: { enabled: false, status: "unavailable", message: "Install a UI plugin to enable" },
+        workflow: { enabled: false, status: "unavailable", message: "Install a workflow plugin to enable" },
+        realtime: { enabled: false, status: "unavailable", message: "Install a realtime plugin to enable" },
+        notification: { enabled: false, status: "unavailable", message: "Install a notification plugin to enable" },
+        ai: { enabled: false, status: "unavailable", message: "Install an AI plugin to enable" },
+        i18n: { enabled: false, status: "unavailable", message: "Install an i18n plugin to enable" },
+        graphql: { enabled: false, status: "unavailable", message: "Install a GraphQL plugin to enable" },
+        "file-storage": { enabled: false, status: "unavailable", message: "Install a file-storage plugin to enable" },
+        search: { enabled: false, status: "unavailable", message: "Install a search plugin to enable" }
       }
     };
   }
@@ -736,8 +758,80 @@ var ObjectStackProtocolImplementation = class {
   // ==========================================
   // Batch Operations
   // ==========================================
-  async batchData(_request) {
-    throw new Error("Batch operations not yet fully implemented in protocol adapter");
+  async batchData(request) {
+    const { object, request: batchReq } = request;
+    const { operation, records, options } = batchReq;
+    const results = [];
+    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": {
+            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) {
+        results.push({ id: record.id, success: false, error: err.message });
+        failed++;
+        if (options?.atomic) {
+          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 }))
+    };
   }
   async createManyData(request) {
     const records = await this.engine.insert(request.object, request.records);
@@ -747,26 +841,174 @@ var ObjectStackProtocolImplementation = class {
       count: records.length
     };
   }
-  async updateManyData(_request) {
-    throw new Error("updateManyData not implemented");
-  }
-  async analyticsQuery(_request) {
-    throw new Error("analyticsQuery not implemented");
-  }
-  async getAnalyticsMeta(_request) {
-    throw new Error("getAnalyticsMeta not implemented");
+  async updateManyData(request) {
+    const { object, records, options } = request;
+    const results = [];
+    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) {
+        results.push({ id: record.id, success: false, error: err.message });
+        failed++;
+        if (!options?.continueOnError) {
+          break;
+        }
+      }
+    }
+    return {
+      success: failed === 0,
+      operation: "update",
+      total: records.length,
+      succeeded,
+      failed,
+      results
+    };
   }
-  async triggerAutomation(_request) {
-    throw new Error("triggerAutomation not implemented");
+  async analyticsQuery(request) {
+    const { query, cube } = request;
+    const object = cube;
+    const groupBy = query.dimensions || [];
+    const aggregations = [];
+    if (query.measures) {
+      for (const measure of query.measures) {
+        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 {
+          aggregations.push({ field: measure, method: "sum", alias: measure });
+        }
+      }
+    }
+    let filter = void 0;
+    if (query.filters && query.filters.length > 0) {
+      const conditions = query.filters.map((f) => {
+        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 };
+    }
+    const rows = await this.engine.aggregate(object, {
+      filter,
+      groupBy: groupBy.length > 0 ? groupBy : void 0,
+      aggregations: aggregations.length > 0 ? aggregations.map((a) => ({ field: a.field, method: a.method, alias: a.alias })) : [{ field: "*", method: "count", alias: "count" }]
+    });
+    const fields = [
+      ...groupBy.map((d) => ({ name: d, type: "string" })),
+      ...aggregations.map((a) => ({ name: a.alias, type: "number" }))
+    ];
+    return {
+      success: true,
+      data: {
+        rows,
+        fields
+      }
+    };
   }
-  async listSpaces(_request) {
-    throw new Error("listSpaces not implemented");
+  async getAnalyticsMeta(request) {
+    const objects = SchemaRegistry.listItems("object");
+    const cubeFilter = request?.cube;
+    const cubes = [];
+    for (const obj of objects) {
+      const schema = obj;
+      if (cubeFilter && schema.name !== cubeFilter) continue;
+      const measures = {};
+      const dimensions = {};
+      const fields = schema.fields || {};
+      measures["count"] = {
+        name: "count",
+        label: "Count",
+        type: "count",
+        sql: "*"
+      };
+      for (const [fieldName, fieldDef] of Object.entries(fields)) {
+        const fd = fieldDef;
+        const fieldType = fd.type || "text";
+        if (["number", "currency", "percent"].includes(fieldType)) {
+          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 {
+          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) {
-    throw new Error("createSpace not implemented");
+  mapAnalyticsOperator(op) {
+    const map = {
+      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) {
-    throw new Error("installPlugin not implemented");
+  async triggerAutomation(_request) {
+    throw new Error('triggerAutomation requires plugin-automation service. Install and register a plugin that provides the "automation" service.');
   }
   async deleteManyData(request) {
     return this.engine.delete(request.object, {
@@ -1277,7 +1519,17 @@ var ObjectQL = class {
     object = this.resolveObjectName(object);
     const driver = this.getDriver(object);
     this.logger.debug(`Aggregate on ${object} using ${driver.name}`, query);
-    throw new Error("Aggregate not yet fully implemented in ObjectQL->Driver mapping");
+    const ast = {
+      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, options) {
     if (options?.object) {