@objectstack/driver-memory 2.0.5 → 2.0.7

package/dist/index.js

@@ -27,35 +27,9 @@ module.exports = __toCommonJS(index_exports);
 
 // src/memory-driver.ts
 var import_core = require("@objectstack/core");
+var import_mingo = require("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;
@@ -63,89 +37,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
@@ -179,7 +83,7 @@ var InMemoryDriver = class {
     this.db = {};
     this.config = config || {};
     this.logger = config?.logger || (0, import_core.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) {
@@ -195,7 +99,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;
@@ -226,25 +143,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 import_mingo.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);
@@ -252,6 +164,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;
   }
@@ -273,31 +188,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 });
@@ -321,6 +243,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;
     }
@@ -329,11 +254,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 import_mingo.Query(mongoQuery);
+        records = mingoQuery.find(records).all();
+      }
     }
-    const count = results.length;
+    const count = records.length;
     this.logger.debug("Count operation", { object, count });
     return count;
   }
@@ -351,7 +280,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 import_mingo.Query(mongoQuery);
+        targetRecords = mingoQuery.find(targetRecords).all();
+      }
     }
     const count = targetRecords.length;
     for (const record of targetRecords) {
@@ -360,7 +293,7 @@ var InMemoryDriver = class {
         const updated = {
           ...table[index],
           ...data,
-          updated_at: /* @__PURE__ */ new Date()
+          updated_at: (/* @__PURE__ */ new Date()).toISOString()
         };
         table[index] = updated;
       }
@@ -372,13 +305,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 import_mingo.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 };
   }
@@ -395,27 +335,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 }));
     }
-  }
-  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 });
+    const transaction = { id: txId, snapshot };
+    this.transactions.set(txId, transaction);
+    this.logger.debug("Transaction started", { txId });
+    return { id: txId };
+  }
+  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 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 });
   }
-  async beginTransaction() {
-    throw new Error("Transactions not supported in InMemoryDriver");
+  // ===================================
+  // 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 import_mingo.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 import_mingo.Aggregator(pipeline);
+    const results = aggregator.run(records);
+    this.logger.debug("Aggregate completed", { object, resultCount: results.length });
+    return results;
   }
-  async commit() {
+  // ===================================
+  // 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 };
+  }
+  /**
+   * 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
@@ -436,14 +562,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) {
@@ -502,16 +624,82 @@ 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}`;
   }
 };