@promakeai/orm 1.0.0

package/src/utils/whereBuilder.ts

@@ -0,0 +1,154 @@
+/**
+ * MongoDB-style Where Clause Builder
+ *
+ * Converts MongoDB/Mongoose-style query objects into SQL WHERE clauses
+ * with parameterized values.
+ *
+ * Supported operators:
+ * - Comparison: $eq, $ne, $gt, $gte, $lt, $lte
+ * - Array: $in, $nin
+ * - String: $like, $notLike
+ * - Range: $between
+ * - Null: $isNull
+ * - Negation: $not (field-level)
+ * - Logical: $and, $or, $nor
+ */
+
+export interface WhereResult {
+  sql: string;
+  params: unknown[];
+}
+
+const COMPARISON_OPERATORS: Record<string, string> = {
+  $eq: "=",
+  $ne: "!=",
+  $gt: ">",
+  $gte: ">=",
+  $lt: "<",
+  $lte: "<=",
+};
+
+const LOGICAL_OPERATORS = new Set(["$and", "$or", "$nor"]);
+
+function processFieldOperators(
+  field: string,
+  operators: Record<string, unknown>
+): WhereResult {
+  const parts: string[] = [];
+  const params: unknown[] = [];
+
+  for (const [op, value] of Object.entries(operators)) {
+    if (op in COMPARISON_OPERATORS) {
+      parts.push(`${field} ${COMPARISON_OPERATORS[op]} ?`);
+      params.push(value);
+    } else if (op === "$in" || op === "$nin") {
+      if (!Array.isArray(value)) {
+        throw new Error(`${op} operator requires an array value`);
+      }
+      if (value.length === 0) {
+        // $in with empty array = always false, $nin with empty array = always true
+        parts.push(op === "$in" ? "0 = 1" : "1 = 1");
+      } else {
+        const placeholders = value.map(() => "?").join(", ");
+        const keyword = op === "$in" ? "IN" : "NOT IN";
+        parts.push(`${field} ${keyword} (${placeholders})`);
+        params.push(...value);
+      }
+    } else if (op === "$like") {
+      parts.push(`${field} LIKE ?`);
+      params.push(value);
+    } else if (op === "$notLike") {
+      parts.push(`${field} NOT LIKE ?`);
+      params.push(value);
+    } else if (op === "$between") {
+      if (!Array.isArray(value) || value.length !== 2) {
+        throw new Error("$between operator requires an array of exactly 2 values");
+      }
+      parts.push(`${field} BETWEEN ? AND ?`);
+      params.push(value[0], value[1]);
+    } else if (op === "$isNull") {
+      parts.push(value ? `${field} IS NULL` : `${field} IS NOT NULL`);
+    } else if (op === "$not") {
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new Error("$not operator requires an object with operators");
+      }
+      const inner = processFieldOperators(field, value as Record<string, unknown>);
+      parts.push(`NOT (${inner.sql})`);
+      params.push(...inner.params);
+    } else {
+      throw new Error(`Unknown operator: ${op}`);
+    }
+  }
+
+  const sql = parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
+  return { sql, params };
+}
+
+function processFieldCondition(field: string, value: unknown): WhereResult {
+  if (value === null) {
+    return { sql: `${field} IS NULL`, params: [] };
+  }
+
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return { sql: `${field} = ?`, params: [value] };
+  }
+
+  // Object with operators
+  return processFieldOperators(field, value as Record<string, unknown>);
+}
+
+function processCondition(where: Record<string, unknown>): WhereResult {
+  const parts: string[] = [];
+  const params: unknown[] = [];
+
+  for (const [key, value] of Object.entries(where)) {
+    if (LOGICAL_OPERATORS.has(key)) {
+      if (!Array.isArray(value)) {
+        throw new Error(`${key} operator requires an array of conditions`);
+      }
+
+      const subResults = value.map((sub: Record<string, unknown>) =>
+        processCondition(sub)
+      );
+      const joiner = key === "$and" ? " AND " : " OR ";
+      const combined = subResults.map((r) => r.sql).join(joiner);
+
+      if (combined) {
+        const wrappedSql = key === "$nor" ? `NOT (${combined})` : `(${combined})`;
+        parts.push(wrappedSql);
+        subResults.forEach((r) => params.push(...r.params));
+      }
+    } else {
+      const result = processFieldCondition(key, value);
+      parts.push(result.sql);
+      params.push(...result.params);
+    }
+  }
+
+  return { sql: parts.join(" AND "), params };
+}
+
+/**
+ * Build a SQL WHERE clause from a MongoDB-style query object.
+ *
+ * @example
+ * // Simple equality
+ * buildWhereClause({ active: 1 })
+ * // => { sql: "active = ?", params: [1] }
+ *
+ * @example
+ * // Comparison operators
+ * buildWhereClause({ age: { $gte: 18, $lt: 65 } })
+ * // => { sql: "(age >= ? AND age < ?)", params: [18, 65] }
+ *
+ * @example
+ * // Logical operators
+ * buildWhereClause({ $or: [{ active: 1 }, { role: "admin" }] })
+ * // => { sql: "(active = ? OR role = ?)", params: [1, "admin"] }
+ */
+export function buildWhereClause(where?: Record<string, unknown>): WhereResult {
+  if (!where || Object.keys(where).length === 0) {
+    return { sql: "", params: [] };
+  }
+  return processCondition(where);
+}