@objectstack/driver-memory 2.0.6 → 3.0.0

package/dist/index.mjs

@@ -1,34 +1,8 @@
 // src/memory-driver.ts
 import { createLogger } from "@objectstack/core";
+import { Query, Aggregator } from "mingo";
 
 // src/memory-matcher.ts
-function match(record, filter) {
-  if (!filter || Object.keys(filter).length === 0) return true;
-  if (Array.isArray(filter.$and)) {
-    if (!filter.$and.every((f) => match(record, f))) {
-      return false;
-    }
-  }
-  if (Array.isArray(filter.$or)) {
-    if (!filter.$or.some((f) => match(record, f))) {
-      return false;
-    }
-  }
-  if (filter.$not) {
-    if (match(record, filter.$not)) {
-      return false;
-    }
-  }
-  for (const key of Object.keys(filter)) {
-    if (key.startsWith("$")) continue;
-    const condition = filter[key];
-    const value = getValueByPath(record, key);
-    if (!checkCondition(value, condition)) {
-      return false;
-    }
-  }
-  return true;
-}
 function getValueByPath(obj, path) {
   if (path === "_id" && obj._id === void 0 && obj.id !== void 0) {
     return obj.id;
@@ -36,89 +10,19 @@ function getValueByPath(obj, path) {
   if (!path.includes(".")) return obj[path];
   return path.split(".").reduce((o, i) => o ? o[i] : void 0, obj);
 }
-function checkCondition(value, condition) {
-  if (typeof condition !== "object" || condition === null || condition instanceof Date || Array.isArray(condition)) {
-    return value == condition;
-  }
-  const keys = Object.keys(condition);
-  const isOperatorObject = keys.some((k) => k.startsWith("$"));
-  if (!isOperatorObject) {
-    return JSON.stringify(value) === JSON.stringify(condition);
-  }
-  for (const op of keys) {
-    const target = condition[op];
-    if (value === void 0 && op !== "$exists" && op !== "$ne") {
-      return false;
-    }
-    switch (op) {
-      case "$eq":
-        if (value != target) return false;
-        break;
-      case "$ne":
-        if (value == target) return false;
-        break;
-      // Numeric / Date
-      case "$gt":
-        if (!(value > target)) return false;
-        break;
-      case "$gte":
-        if (!(value >= target)) return false;
-        break;
-      case "$lt":
-        if (!(value < target)) return false;
-        break;
-      case "$lte":
-        if (!(value <= target)) return false;
-        break;
-      case "$between":
-        if (Array.isArray(target) && (value < target[0] || value > target[1])) return false;
-        break;
-      // Sets
-      case "$in":
-        if (!Array.isArray(target) || !target.includes(value)) return false;
-        break;
-      case "$nin":
-        if (Array.isArray(target) && target.includes(value)) return false;
-        break;
-      // Existence
-      case "$exists":
-        const exists = value !== void 0 && value !== null;
-        if (exists !== !!target) return false;
-        break;
-      // Strings
-      case "$contains":
-        if (typeof value !== "string" || !value.includes(target)) return false;
-        break;
-      case "$startsWith":
-        if (typeof value !== "string" || !value.startsWith(target)) return false;
-        break;
-      case "$endsWith":
-        if (typeof value !== "string" || !value.endsWith(target)) return false;
-        break;
-      case "$regex":
-        try {
-          const re = new RegExp(target, condition.$options || "");
-          if (!re.test(String(value))) return false;
-        } catch (e) {
-          return false;
-        }
-        break;
-      default:
-        break;
-    }
-  }
-  return true;
-}
 
 // src/memory-driver.ts
 var InMemoryDriver = class {
   constructor(config) {
     this.name = "com.objectstack.driver.memory";
     this.type = "driver";
-    this.version = "0.0.1";
+    this.version = "1.0.0";
+    this.idCounters = /* @__PURE__ */ new Map();
+    this.transactions = /* @__PURE__ */ new Map();
     this.supports = {
       // Transaction & Connection Management
-      transactions: false,
+      transactions: true,
+      // Snapshot-based transactions
       // Query Operations
       queryFilters: true,
       // Implemented via memory-matcher
@@ -152,7 +56,7 @@ var InMemoryDriver = class {
     this.db = {};
     this.config = config || {};
     this.logger = config?.logger || createLogger({ level: "info", format: "pretty" });
-    this.logger.debug("InMemory driver instance created", { config: this.config });
+    this.logger.debug("InMemory driver instance created");
   }
   // Duck-typed RuntimePlugin hook
   install(ctx) {
@@ -168,7 +72,20 @@ var InMemoryDriver = class {
   // Lifecycle
   // ===================================
   async connect() {
-    this.logger.info("InMemory Database Connected (Virtual)");
+    if (this.config.initialData) {
+      for (const [objectName, records] of Object.entries(this.config.initialData)) {
+        const table = this.getTable(objectName);
+        for (const record of records) {
+          const id = record.id || this.generateId(objectName);
+          table.push({ ...record, id });
+        }
+      }
+      this.logger.info("InMemory Database Connected with initial data", {
+        tables: Object.keys(this.config.initialData).length
+      });
+    } else {
+      this.logger.info("InMemory Database Connected (Virtual)");
+    }
   }
   async disconnect() {
     const tableCount = Object.keys(this.db).length;
@@ -199,25 +116,20 @@ var InMemoryDriver = class {
   async find(object, query, options) {
     this.logger.debug("Find operation", { object, query });
     const table = this.getTable(object);
-    let results = table;
+    let results = [...table];
     if (query.where) {
-      results = results.filter((record) => match(record, query.where));
+      const mongoQuery = this.convertToMongoQuery(query.where);
+      if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+        const mingoQuery = new Query(mongoQuery);
+        results = mingoQuery.find(results).all();
+      }
     }
     if (query.groupBy || query.aggregations && query.aggregations.length > 0) {
       results = this.performAggregation(results, query);
     }
     if (query.orderBy) {
       const sortFields = Array.isArray(query.orderBy) ? query.orderBy : [query.orderBy];
-      results.sort((a, b) => {
-        for (const { field, order } of sortFields) {
-          const valA = getValueByPath(a, field);
-          const valB = getValueByPath(b, field);
-          if (valA === valB) continue;
-          const comparison = valA > valB ? 1 : -1;
-          return order === "desc" ? -comparison : comparison;
-        }
-        return 0;
-      });
+      results = this.applySort(results, sortFields);
     }
     if (query.offset) {
       results = results.slice(query.offset);
@@ -225,6 +137,9 @@ var InMemoryDriver = class {
     if (query.limit) {
       results = results.slice(0, query.limit);
     }
+    if (query.fields && Array.isArray(query.fields) && query.fields.length > 0) {
+      results = results.map((record) => this.projectFields(record, query.fields));
+    }
     this.logger.debug("Find completed", { object, resultCount: results.length });
     return results;
   }
@@ -246,31 +161,38 @@ var InMemoryDriver = class {
     this.logger.debug("Create operation", { object, hasData: !!data });
     const table = this.getTable(object);
     const newRecord = {
-      id: data.id || this.generateId(),
+      id: data.id || this.generateId(object),
       ...data,
-      created_at: data.created_at || /* @__PURE__ */ new Date(),
-      updated_at: data.updated_at || /* @__PURE__ */ new Date()
+      created_at: data.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+      updated_at: data.updated_at || (/* @__PURE__ */ new Date()).toISOString()
     };
     table.push(newRecord);
     this.logger.debug("Record created", { object, id: newRecord.id, tableSize: table.length });
-    return newRecord;
+    return { ...newRecord };
   }
   async update(object, id, data, options) {
     this.logger.debug("Update operation", { object, id });
     const table = this.getTable(object);
     const index = table.findIndex((r) => r.id == id);
     if (index === -1) {
-      this.logger.warn("Record not found for update", { object, id });
-      throw new Error(`Record with ID ${id} not found in ${object}`);
+      if (this.config.strictMode) {
+        this.logger.warn("Record not found for update", { object, id });
+        throw new Error(`Record with ID ${id} not found in ${object}`);
+      }
+      return null;
     }
     const updatedRecord = {
       ...table[index],
       ...data,
-      updated_at: /* @__PURE__ */ new Date()
+      id: table[index].id,
+      // Preserve original ID
+      created_at: table[index].created_at,
+      // Preserve created_at
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
     };
     table[index] = updatedRecord;
     this.logger.debug("Record updated", { object, id });
-    return updatedRecord;
+    return { ...updatedRecord };
   }
   async upsert(object, data, conflictKeys, options) {
     this.logger.debug("Upsert operation", { object, conflictKeys });
@@ -294,6 +216,9 @@ var InMemoryDriver = class {
     const table = this.getTable(object);
     const index = table.findIndex((r) => r.id == id);
     if (index === -1) {
+      if (this.config.strictMode) {
+        throw new Error(`Record with ID ${id} not found in ${object}`);
+      }
       this.logger.warn("Record not found for deletion", { object, id });
       return false;
     }
@@ -302,11 +227,15 @@ var InMemoryDriver = class {
     return true;
   }
   async count(object, query, options) {
-    let results = this.getTable(object);
+    let records = this.getTable(object);
     if (query?.where) {
-      results = results.filter((record) => match(record, query.where));
+      const mongoQuery = this.convertToMongoQuery(query.where);
+      if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+        const mingoQuery = new Query(mongoQuery);
+        records = mingoQuery.find(records).all();
+      }
     }
-    const count = results.length;
+    const count = records.length;
     this.logger.debug("Count operation", { object, count });
     return count;
   }
@@ -324,7 +253,11 @@ var InMemoryDriver = class {
     const table = this.getTable(object);
     let targetRecords = table;
     if (query && query.where) {
-      targetRecords = targetRecords.filter((r) => match(r, query.where));
+      const mongoQuery = this.convertToMongoQuery(query.where);
+      if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+        const mingoQuery = new Query(mongoQuery);
+        targetRecords = mingoQuery.find(targetRecords).all();
+      }
     }
     const count = targetRecords.length;
     for (const record of targetRecords) {
@@ -333,7 +266,7 @@ var InMemoryDriver = class {
         const updated = {
           ...table[index],
           ...data,
-          updated_at: /* @__PURE__ */ new Date()
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
         };
         table[index] = updated;
       }
@@ -345,13 +278,20 @@ var InMemoryDriver = class {
     this.logger.debug("DeleteMany operation", { object, query });
     const table = this.getTable(object);
     const initialLength = table.length;
-    const remaining = table.filter((r) => {
-      if (!query || !query.where) return false;
-      const matches = match(r, query.where);
-      return !matches;
-    });
-    this.db[object] = remaining;
-    const count = initialLength - remaining.length;
+    if (query && query.where) {
+      const mongoQuery = this.convertToMongoQuery(query.where);
+      if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+        const mingoQuery = new Query(mongoQuery);
+        const matched = mingoQuery.find(table).all();
+        const matchedIds = new Set(matched.map((r) => r.id));
+        this.db[object] = table.filter((r) => !matchedIds.has(r.id));
+      } else {
+        this.db[object] = [];
+      }
+    } else {
+      this.db[object] = [];
+    }
+    const count = initialLength - this.db[object].length;
     this.logger.debug("DeleteMany completed", { object, count });
     return { count };
   }
@@ -368,27 +308,213 @@ var InMemoryDriver = class {
     this.logger.debug("BulkDelete completed", { object, count: ids.length });
   }
   // ===================================
-  // Schema & Transactions
+  // Transaction Management
   // ===================================
-  async syncSchema(object, schema, options) {
-    if (!this.db[object]) {
-      this.db[object] = [];
-      this.logger.info("Created in-memory table", { object });
+  async beginTransaction() {
+    const txId = `tx_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    const snapshot = {};
+    for (const [table, records] of Object.entries(this.db)) {
+      snapshot[table] = records.map((r) => ({ ...r }));
     }
+    const transaction = { id: txId, snapshot };
+    this.transactions.set(txId, transaction);
+    this.logger.debug("Transaction started", { txId });
+    return { id: txId };
   }
-  async dropTable(object, options) {
-    if (this.db[object]) {
-      const recordCount = this.db[object].length;
-      delete this.db[object];
-      this.logger.info("Dropped in-memory table", { object, recordCount });
+  async commit(txHandle) {
+    const txId = txHandle?.id;
+    if (!txId || !this.transactions.has(txId)) {
+      this.logger.warn("Commit called with unknown transaction");
+      return;
     }
+    this.transactions.delete(txId);
+    this.logger.debug("Transaction committed", { txId });
   }
-  async beginTransaction() {
-    throw new Error("Transactions not supported in InMemoryDriver");
+  async rollback(txHandle) {
+    const txId = txHandle?.id;
+    if (!txId || !this.transactions.has(txId)) {
+      this.logger.warn("Rollback called with unknown transaction");
+      return;
+    }
+    const tx = this.transactions.get(txId);
+    this.db = tx.snapshot;
+    this.transactions.delete(txId);
+    this.logger.debug("Transaction rolled back", { txId });
+  }
+  // ===================================
+  // Utility Methods
+  // ===================================
+  /**
+   * Remove all data from the store.
+   */
+  async clear() {
+    this.db = {};
+    this.idCounters.clear();
+    this.logger.debug("All data cleared");
+  }
+  /**
+   * Get total number of records across all tables.
+   */
+  getSize() {
+    return Object.values(this.db).reduce((sum, table) => sum + table.length, 0);
+  }
+  /**
+   * Get distinct values for a field, optionally filtered.
+   */
+  async distinct(object, field, query) {
+    let records = this.getTable(object);
+    if (query?.where) {
+      const mongoQuery = this.convertToMongoQuery(query.where);
+      if (mongoQuery && Object.keys(mongoQuery).length > 0) {
+        const mingoQuery = new Query(mongoQuery);
+        records = mingoQuery.find(records).all();
+      }
+    }
+    const values = /* @__PURE__ */ new Set();
+    for (const record of records) {
+      const value = getValueByPath(record, field);
+      if (value !== void 0 && value !== null) {
+        values.add(value);
+      }
+    }
+    return Array.from(values);
+  }
+  /**
+   * Execute a MongoDB-style aggregation pipeline using Mingo.
+   * 
+   * Supports all standard MongoDB pipeline stages:
+   * - $match, $group, $sort, $project, $unwind, $limit, $skip
+   * - $addFields, $replaceRoot, $lookup (limited), $count
+   * - Accumulator operators: $sum, $avg, $min, $max, $first, $last, $push, $addToSet
+   * 
+   * @example
+   * // Group by status and count
+   * const results = await driver.aggregate('orders', [
+   *   { $match: { status: 'completed' } },
+   *   { $group: { _id: '$customer', totalAmount: { $sum: '$amount' } } }
+   * ]);
+   * 
+   * @example
+   * // Calculate average with filter
+   * const results = await driver.aggregate('products', [
+   *   { $match: { category: 'electronics' } },
+   *   { $group: { _id: null, avgPrice: { $avg: '$price' } } }
+   * ]);
+   */
+  async aggregate(object, pipeline, options) {
+    this.logger.debug("Aggregate operation", { object, stageCount: pipeline.length });
+    const records = this.getTable(object).map((r) => ({ ...r }));
+    const aggregator = new Aggregator(pipeline);
+    const results = aggregator.run(records);
+    this.logger.debug("Aggregate completed", { object, resultCount: results.length });
+    return results;
+  }
+  // ===================================
+  // Query Conversion (ObjectQL → MongoDB)
+  // ===================================
+  /**
+   * Convert ObjectQL filter format to MongoDB query format for Mingo.
+   * 
+   * Supports:
+   * 1. AST Comparison Node: { type: 'comparison', field, operator, value }
+   * 2. AST Logical Node: { type: 'logical', operator: 'and'|'or', conditions: [...] }
+   * 3. Legacy Array Format: [['field', 'op', value], 'and', ['field2', 'op', value2]]
+   * 4. MongoDB Format: { field: value } or { field: { $eq: value } } (passthrough)
+   */
+  convertToMongoQuery(filters) {
+    if (!filters) return {};
+    if (!Array.isArray(filters) && typeof filters === "object") {
+      if (filters.type === "comparison") {
+        return this.convertConditionToMongo(filters.field, filters.operator, filters.value) || {};
+      }
+      if (filters.type === "logical") {
+        const conditions = filters.conditions?.map((c) => this.convertToMongoQuery(c)) || [];
+        if (conditions.length === 0) return {};
+        if (conditions.length === 1) return conditions[0];
+        const op = filters.operator === "or" ? "$or" : "$and";
+        return { [op]: conditions };
+      }
+      return filters;
+    }
+    if (!Array.isArray(filters) || filters.length === 0) return {};
+    const logicGroups = [
+      { logic: "and", conditions: [] }
+    ];
+    let currentLogic = "and";
+    for (const item of filters) {
+      if (typeof item === "string") {
+        const newLogic = item.toLowerCase();
+        if (newLogic !== currentLogic) {
+          currentLogic = newLogic;
+          logicGroups.push({ logic: currentLogic, conditions: [] });
+        }
+      } else if (Array.isArray(item)) {
+        const [field, operator, value] = item;
+        const cond = this.convertConditionToMongo(field, operator, value);
+        if (cond) logicGroups[logicGroups.length - 1].conditions.push(cond);
+      }
+    }
+    const allConditions = [];
+    for (const group of logicGroups) {
+      if (group.conditions.length === 0) continue;
+      if (group.conditions.length === 1) {
+        allConditions.push(group.conditions[0]);
+      } else {
+        const op = group.logic === "or" ? "$or" : "$and";
+        allConditions.push({ [op]: group.conditions });
+      }
+    }
+    if (allConditions.length === 0) return {};
+    if (allConditions.length === 1) return allConditions[0];
+    return { $and: allConditions };
   }
-  async commit() {
+  /**
+   * Convert a single ObjectQL condition to MongoDB operator format.
+   */
+  convertConditionToMongo(field, operator, value) {
+    switch (operator) {
+      case "=":
+      case "==":
+        return { [field]: value };
+      case "!=":
+      case "<>":
+        return { [field]: { $ne: value } };
+      case ">":
+        return { [field]: { $gt: value } };
+      case ">=":
+        return { [field]: { $gte: value } };
+      case "<":
+        return { [field]: { $lt: value } };
+      case "<=":
+        return { [field]: { $lte: value } };
+      case "in":
+        return { [field]: { $in: value } };
+      case "nin":
+      case "not in":
+        return { [field]: { $nin: value } };
+      case "contains":
+      case "like":
+        return { [field]: { $regex: new RegExp(this.escapeRegex(value), "i") } };
+      case "startswith":
+      case "starts_with":
+        return { [field]: { $regex: new RegExp(`^${this.escapeRegex(value)}`, "i") } };
+      case "endswith":
+      case "ends_with":
+        return { [field]: { $regex: new RegExp(`${this.escapeRegex(value)}$`, "i") } };
+      case "between":
+        if (Array.isArray(value) && value.length === 2) {
+          return { [field]: { $gte: value[0], $lte: value[1] } };
+        }
+        return null;
+      default:
+        return null;
+    }
   }
-  async rollback() {
+  /**
+   * Escape special regex characters for safe literal matching.
+   */
+  escapeRegex(str) {
+    return String(str).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
   }
   // ===================================
   // Aggregation Logic
@@ -409,14 +535,10 @@ var InMemoryDriver = class {
         groups.get(key).push(record);
       }
     } else {
-      if (aggregations && aggregations.length > 0) {
-        groups.set("all", records);
-      } else {
-        groups.set("all", records);
-      }
+      groups.set("all", records);
     }
     const resultRows = [];
-    for (const [key, groupRecords] of groups.entries()) {
+    for (const [_key, groupRecords] of groups.entries()) {
       const row = {};
       if (groupBy && groupBy.length > 0) {
         if (groupRecords.length > 0) {
@@ -475,16 +597,475 @@ var InMemoryDriver = class {
     current[parts[parts.length - 1]] = value;
   }
   // ===================================
+  // Schema Management
+  // ===================================
+  async syncSchema(object, schema, options) {
+    if (!this.db[object]) {
+      this.db[object] = [];
+      this.logger.info("Created in-memory table", { object });
+    }
+  }
+  async dropTable(object, options) {
+    if (this.db[object]) {
+      const recordCount = this.db[object].length;
+      delete this.db[object];
+      this.logger.info("Dropped in-memory table", { object, recordCount });
+    }
+  }
+  // ===================================
   // Helpers
   // ===================================
+  /**
+   * Apply manual sorting (Mingo sort has CJS build issues).
+   */
+  applySort(records, sortFields) {
+    const sorted = [...records];
+    for (let i = sortFields.length - 1; i >= 0; i--) {
+      const sortItem = sortFields[i];
+      let field;
+      let direction;
+      if (typeof sortItem === "object" && !Array.isArray(sortItem)) {
+        field = sortItem.field;
+        direction = sortItem.order || sortItem.direction || "asc";
+      } else if (Array.isArray(sortItem)) {
+        [field, direction] = sortItem;
+      } else {
+        continue;
+      }
+      sorted.sort((a, b) => {
+        const aVal = getValueByPath(a, field);
+        const bVal = getValueByPath(b, field);
+        if (aVal == null && bVal == null) return 0;
+        if (aVal == null) return 1;
+        if (bVal == null) return -1;
+        if (aVal < bVal) return direction === "desc" ? 1 : -1;
+        if (aVal > bVal) return direction === "desc" ? -1 : 1;
+        return 0;
+      });
+    }
+    return sorted;
+  }
+  /**
+   * Project specific fields from a record.
+   */
+  projectFields(record, fields) {
+    const result = {};
+    for (const field of fields) {
+      const value = getValueByPath(record, field);
+      if (value !== void 0) {
+        result[field] = value;
+      }
+    }
+    if (!fields.includes("id") && record.id !== void 0) {
+      result.id = record.id;
+    }
+    return result;
+  }
   getTable(name) {
     if (!this.db[name]) {
       this.db[name] = [];
     }
     return this.db[name];
   }
-  generateId() {
-    return Math.random().toString(36).substring(2, 15);
+  generateId(objectName) {
+    const key = objectName || "_global";
+    const counter = (this.idCounters.get(key) || 0) + 1;
+    this.idCounters.set(key, counter);
+    const timestamp = Date.now();
+    return `${key}-${timestamp}-${counter}`;
+  }
+};
+
+// src/memory-analytics.ts
+import { createLogger as createLogger2 } from "@objectstack/core";
+var MemoryAnalyticsService = class {
+  constructor(config) {
+    this.driver = config.driver;
+    this.cubes = new Map(config.cubes.map((c) => [c.name, c]));
+    this.logger = config.logger || createLogger2({ level: "info", format: "pretty" });
+    this.logger.debug("MemoryAnalyticsService initialized", { cubeCount: this.cubes.size });
+  }
+  /**
+   * Execute an analytical query using the memory driver's aggregation pipeline
+   */
+  async query(query) {
+    this.logger.debug("Executing analytics query", { cube: query.cube, measures: query.measures });
+    if (!query.cube) {
+      throw new Error("Cube name is required");
+    }
+    const cube = this.cubes.get(query.cube);
+    if (!cube) {
+      throw new Error(`Cube not found: ${query.cube}`);
+    }
+    const pipeline = [];
+    if (query.filters && query.filters.length > 0) {
+      const matchStage = {};
+      for (const filter of query.filters) {
+        const mongoOp = this.convertOperatorToMongo(filter.operator);
+        const fieldPath = this.resolveFieldPath(cube, filter.member);
+        if (filter.values && filter.values.length > 0) {
+          if (mongoOp === "$in") {
+            matchStage[fieldPath] = { $in: filter.values };
+          } else if (mongoOp === "$nin") {
+            matchStage[fieldPath] = { $nin: filter.values };
+          } else {
+            matchStage[fieldPath] = { [mongoOp]: filter.values[0] };
+          }
+        } else if (mongoOp === "$exists") {
+          matchStage[fieldPath] = { $exists: filter.operator === "set" };
+        }
+      }
+      if (Object.keys(matchStage).length > 0) {
+        pipeline.push({ $match: matchStage });
+      }
+    }
+    if (query.timeDimensions && query.timeDimensions.length > 0) {
+      for (const timeDim of query.timeDimensions) {
+        const fieldPath = this.resolveFieldPath(cube, timeDim.dimension);
+        if (timeDim.dateRange) {
+          const range = Array.isArray(timeDim.dateRange) ? timeDim.dateRange : this.parseDateRangeString(timeDim.dateRange);
+          if (range.length === 2) {
+            pipeline.push({
+              $match: {
+                [fieldPath]: {
+                  $gte: new Date(range[0]),
+                  $lte: new Date(range[1])
+                }
+              }
+            });
+          }
+        }
+      }
+    }
+    const groupStage = { _id: {} };
+    if (query.dimensions && query.dimensions.length > 0) {
+      for (const dim of query.dimensions) {
+        const fieldPath = this.resolveFieldPath(cube, dim);
+        const dimName = this.getShortName(dim);
+        groupStage._id[dimName] = `$${fieldPath}`;
+      }
+    } else {
+      groupStage._id = null;
+    }
+    if (query.measures && query.measures.length > 0) {
+      for (const measure of query.measures) {
+        const measureDef = this.resolveMeasure(cube, measure);
+        const measureName = this.getShortName(measure);
+        if (measureDef) {
+          const aggregator = this.buildAggregator(measureDef);
+          groupStage[measureName] = aggregator;
+        }
+      }
+    }
+    pipeline.push({ $group: groupStage });
+    const projectStage = { _id: 0 };
+    if (query.dimensions && query.dimensions.length > 0) {
+      for (const dim of query.dimensions) {
+        const dimName = this.getShortName(dim);
+        projectStage[dimName] = `$_id.${dimName}`;
+      }
+    }
+    if (query.measures && query.measures.length > 0) {
+      for (const measure of query.measures) {
+        const measureName = this.getShortName(measure);
+        projectStage[measureName] = `$${measureName}`;
+      }
+    }
+    pipeline.push({ $project: projectStage });
+    if (query.order && Object.keys(query.order).length > 0) {
+      const sortStage = {};
+      for (const [field, direction] of Object.entries(query.order)) {
+        const shortName = this.getShortName(field);
+        sortStage[shortName] = direction === "asc" ? 1 : -1;
+      }
+      pipeline.push({ $sort: sortStage });
+    }
+    if (query.offset) {
+      pipeline.push({ $skip: query.offset });
+    }
+    if (query.limit) {
+      pipeline.push({ $limit: query.limit });
+    }
+    const tableName = this.extractTableName(cube.sql);
+    const rawRows = await this.driver.aggregate(tableName, pipeline);
+    const rows = rawRows.map((row) => {
+      const renamedRow = {};
+      if (query.dimensions) {
+        for (const dim of query.dimensions) {
+          const shortName = this.getShortName(dim);
+          if (shortName in row) {
+            renamedRow[dim] = row[shortName];
+          }
+        }
+      }
+      if (query.measures) {
+        for (const measure of query.measures) {
+          const shortName = this.getShortName(measure);
+          if (shortName in row) {
+            renamedRow[measure] = row[shortName];
+          }
+        }
+      }
+      return renamedRow;
+    });
+    const fields = [];
+    if (query.dimensions) {
+      for (const dim of query.dimensions) {
+        const dimension = this.resolveDimension(cube, dim);
+        fields.push({
+          name: dim,
+          type: dimension?.type || "string"
+        });
+      }
+    }
+    if (query.measures) {
+      for (const measure of query.measures) {
+        const measureDef = this.resolveMeasure(cube, measure);
+        fields.push({
+          name: measure,
+          type: this.measureTypeToFieldType(measureDef?.type || "count")
+        });
+      }
+    }
+    this.logger.debug("Analytics query completed", { rowCount: rows.length });
+    return {
+      rows,
+      fields,
+      sql: this.generateSqlFromPipeline(tableName, pipeline)
+      // For debugging
+    };
+  }
+  /**
+   * Get available cube metadata for discovery
+   */
+  async getMeta(cubeName) {
+    const cubes = cubeName ? [this.cubes.get(cubeName)].filter(Boolean) : Array.from(this.cubes.values());
+    return cubes.map((cube) => ({
+      name: cube.name,
+      title: cube.title,
+      measures: Object.entries(cube.measures).map(([key, measure]) => ({
+        name: `${cube.name}.${key}`,
+        type: measure.type,
+        title: measure.label
+      })),
+      dimensions: Object.entries(cube.dimensions).map(([key, dimension]) => ({
+        name: `${cube.name}.${key}`,
+        type: dimension.type,
+        title: dimension.label
+      }))
+    }));
+  }
+  /**
+   * Generate SQL representation for debugging/transparency
+   */
+  async generateSql(query) {
+    if (!query.cube) {
+      throw new Error("Cube name is required");
+    }
+    const cube = this.cubes.get(query.cube);
+    if (!cube) {
+      throw new Error(`Cube not found: ${query.cube}`);
+    }
+    const tableName = this.extractTableName(cube.sql);
+    const selectClauses = [];
+    const groupByClauses = [];
+    if (query.dimensions && query.dimensions.length > 0) {
+      for (const dim of query.dimensions) {
+        const fieldPath = this.resolveFieldPath(cube, dim);
+        selectClauses.push(`${fieldPath} AS "${dim}"`);
+        groupByClauses.push(fieldPath);
+      }
+    }
+    if (query.measures && query.measures.length > 0) {
+      for (const measure of query.measures) {
+        const measureDef = this.resolveMeasure(cube, measure);
+        if (measureDef) {
+          const aggSql = this.measureToSql(measureDef);
+          selectClauses.push(`${aggSql} AS "${measure}"`);
+        }
+      }
+    }
+    const whereClauses = [];
+    if (query.filters && query.filters.length > 0) {
+      for (const filter of query.filters) {
+        const fieldPath = this.resolveFieldPath(cube, filter.member);
+        const sqlOp = this.operatorToSql(filter.operator);
+        if (filter.values && filter.values.length > 0) {
+          whereClauses.push(`${fieldPath} ${sqlOp} '${filter.values[0]}'`);
+        }
+      }
+    }
+    let sql = `SELECT ${selectClauses.join(", ")} FROM ${tableName}`;
+    if (whereClauses.length > 0) {
+      sql += ` WHERE ${whereClauses.join(" AND ")}`;
+    }
+    if (groupByClauses.length > 0) {
+      sql += ` GROUP BY ${groupByClauses.join(", ")}`;
+    }
+    if (query.order) {
+      const orderClauses = Object.entries(query.order).map(
+        ([field, dir]) => `"${field}" ${dir.toUpperCase()}`
+      );
+      sql += ` ORDER BY ${orderClauses.join(", ")}`;
+    }
+    if (query.limit) {
+      sql += ` LIMIT ${query.limit}`;
+    }
+    if (query.offset) {
+      sql += ` OFFSET ${query.offset}`;
+    }
+    return { sql, params: [] };
+  }
+  // ===================================
+  // Helper Methods
+  // ===================================
+  resolveFieldPath(cube, member) {
+    const parts = member.split(".");
+    const fieldName = parts.length > 1 ? parts[1] : parts[0];
+    const dimension = cube.dimensions[fieldName];
+    if (dimension) {
+      return dimension.sql.replace(/^\$/, "");
+    }
+    const measure = cube.measures[fieldName];
+    if (measure) {
+      return measure.sql.replace(/^\$/, "");
+    }
+    return fieldName;
+  }
+  resolveMeasure(cube, measureName) {
+    const parts = measureName.split(".");
+    const fieldName = parts.length > 1 ? parts[1] : parts[0];
+    return cube.measures[fieldName];
+  }
+  resolveDimension(cube, dimensionName) {
+    const parts = dimensionName.split(".");
+    const fieldName = parts.length > 1 ? parts[1] : parts[0];
+    return cube.dimensions[fieldName];
+  }
+  getShortName(fullName) {
+    const parts = fullName.split(".");
+    return parts.length > 1 ? parts[1] : parts[0];
+  }
+  buildAggregator(measure) {
+    const fieldPath = measure.sql.replace(/^\$/, "");
+    switch (measure.type) {
+      case "count":
+        return { $sum: 1 };
+      case "sum":
+        return { $sum: `$${fieldPath}` };
+      case "avg":
+        return { $avg: `$${fieldPath}` };
+      case "min":
+        return { $min: `$${fieldPath}` };
+      case "max":
+        return { $max: `$${fieldPath}` };
+      case "count_distinct":
+        return { $addToSet: `$${fieldPath}` };
+      // Will need post-processing for count
+      default:
+        return { $sum: 1 };
+    }
+  }
+  measureTypeToFieldType(measureType) {
+    switch (measureType) {
+      case "count":
+      case "sum":
+      case "count_distinct":
+        return "number";
+      case "avg":
+      case "min":
+      case "max":
+        return "number";
+      case "string":
+        return "string";
+      case "boolean":
+        return "boolean";
+      default:
+        return "number";
+    }
+  }
+  convertOperatorToMongo(operator) {
+    const opMap = {
+      "equals": "$eq",
+      "notEquals": "$ne",
+      "contains": "$regex",
+      "notContains": "$not",
+      "gt": "$gt",
+      "gte": "$gte",
+      "lt": "$lt",
+      "lte": "$lte",
+      "set": "$exists",
+      "notSet": "$exists",
+      "inDateRange": "$gte"
+      // Will need special handling
+    };
+    return opMap[operator] || "$eq";
+  }
+  operatorToSql(operator) {
+    const opMap = {
+      "equals": "=",
+      "notEquals": "!=",
+      "contains": "LIKE",
+      "notContains": "NOT LIKE",
+      "gt": ">",
+      "gte": ">=",
+      "lt": "<",
+      "lte": "<="
+    };
+    return opMap[operator] || "=";
+  }
+  measureToSql(measure) {
+    const fieldPath = measure.sql.replace(/^\$/, "");
+    switch (measure.type) {
+      case "count":
+        return "COUNT(*)";
+      case "sum":
+        return `SUM(${fieldPath})`;
+      case "avg":
+        return `AVG(${fieldPath})`;
+      case "min":
+        return `MIN(${fieldPath})`;
+      case "max":
+        return `MAX(${fieldPath})`;
+      case "count_distinct":
+        return `COUNT(DISTINCT ${fieldPath})`;
+      default:
+        return "COUNT(*)";
+    }
+  }
+  extractTableName(sql) {
+    return sql.trim();
+  }
+  parseDateRangeString(range) {
+    const now = /* @__PURE__ */ new Date();
+    const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+    if (range === "today") {
+      return [today.toISOString(), new Date(today.getTime() + 864e5).toISOString()];
+    } else if (range.startsWith("last ")) {
+      const parts = range.split(" ");
+      const num = parseInt(parts[1]);
+      const unit = parts[2];
+      const start = new Date(today);
+      if (unit.startsWith("day")) {
+        start.setDate(start.getDate() - num);
+      } else if (unit.startsWith("week")) {
+        start.setDate(start.getDate() - num * 7);
+      } else if (unit.startsWith("month")) {
+        start.setMonth(start.getMonth() - num);
+      } else if (unit.startsWith("year")) {
+        start.setFullYear(start.getFullYear() - num);
+      }
+      return [start.toISOString(), now.toISOString()];
+    }
+    return [range, range];
+  }
+  generateSqlFromPipeline(table, pipeline) {
+    const stages = pipeline.map((stage, idx) => {
+      const op = Object.keys(stage)[0];
+      return `/* Stage ${idx + 1}: ${op} */ ${JSON.stringify(stage[op])}`;
+    }).join("\n");
+    return `-- MongoDB Aggregation Pipeline on table: ${table}
+${stages}`;
   }
 };
 
@@ -506,6 +1087,7 @@ var index_default = {
 };
 export {
   InMemoryDriver,
+  MemoryAnalyticsService,
   index_default as default
 };
 //# sourceMappingURL=index.mjs.map