@objectstack/objectql 1.1.0 → 2.0.1

package/dist/index.mjs

@@ -504,7 +504,7 @@ var ObjectStackProtocolImplementation = class {
   constructor(engine) {
     this.engine = engine;
   }
-  async getDiscovery(_request) {
+  async getDiscovery() {
     return {
       version: "1.0",
       apiName: "ObjectStack API",
@@ -512,33 +512,69 @@ 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,
+        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", 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" }
       }
     };
   }
-  async getMetaTypes(_request) {
+  async getMetaTypes() {
     return {
       types: SchemaRegistry.getRegisteredTypes()
     };
   }
   async getMetaItems(request) {
+    let items = SchemaRegistry.listItems(request.type);
+    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) {
+    let item = SchemaRegistry.getItem(request.type, request.name);
+    if (item === void 0) {
+      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
     };
   }
   async getUiView(request) {
@@ -688,8 +724,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);
@@ -699,26 +807,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, {
@@ -898,15 +1154,35 @@ var ObjectQL = class {
       this.logger.debug("Registered manifest-as-app", { app: manifest.name, from: id });
     }
     const metadataArrayKeys = [
+      // UI Protocol
       "actions",
+      "views",
+      "pages",
       "dashboards",
       "reports",
+      "themes",
+      // Automation Protocol
       "flows",
+      "workflows",
+      "approvals",
+      "webhooks",
+      // Security Protocol
+      "roles",
+      "permissions",
+      "profiles",
+      "sharingRules",
+      "policies",
+      // AI Protocol
       "agents",
-      "apis",
       "ragPipelines",
-      "profiles",
-      "sharingRules"
+      // API Protocol
+      "apis",
+      // Data Extensions
+      "hooks",
+      "mappings",
+      "analyticsCubes",
+      // Integration Protocol
+      "connectors"
     ];
     for (const key of metadataArrayKeys) {
       const items = manifest[key];
@@ -1209,7 +1485,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) {