@mlagie/sql-connector 3.0.2 → 3.1.0

package/src/models/Schema.js

@@ -1,22 +1,22 @@
-/**
- * Represents a database schema.
- * 
- * @example
- * const transferSchema = new Schema({
- *     token: {
- *         type: String,
- *         length: 50
- *     },
- *     mdp: {
- *         type: String,
- *         length: 15
- *     }
- * });
- */
-class Schema {
-    constructor(schemaDict) {
-        this.schemaDict = schemaDict;
+    /**
+     * Represents a database schema.
+     * 
+     * @example
+     * const transferSchema = new Schema({
+     *     token: {
+     *         type: String,
+     *         length: 50
+     *     },
+     *     mdp: {
+     *         type: String,
+     *         length: 15
+     *     }
+     * });
+     */
+    class Schema {
+        constructor(schemaDict) {
+            this.schemaDict = schemaDict;
+        }
     }
-}
 
-module.exports = { Schema }
+    module.exports = { Schema }

package/src/utils/buildQuery/buildQuery.js

@@ -61,7 +61,14 @@ function buildSelect(select = []) {
         .join(',\n');
 }
 
-function buildWhere(where, values) {
+const COMPARISON_OPERATORS = ["=", "!=", ">", "<", ">=", "<=", "LIKE", "NOT LIKE", "ILIKE", "NOT ILIKE", "IN", "NOT IN", "BETWEEN", "NOT BETWEEN"];
+
+function buildCaseInsensitiveLike(dialect, key, placeholder, negate) {
+    if (dialect.name === "postgres") return null;
+    return `${negate ? "NOT " : ""}LOWER(${dialect.escape(key)}) LIKE LOWER(${placeholder})`;
+}
+
+function buildWhere(where, values, offset) {
     const conditions = [];
 
     for (const [key, value] of Object.entries(where)) {
@@ -70,7 +77,7 @@ function buildWhere(where, values) {
                 throw new Error("OR conditions cannot be empty");
             }
             const clauses = value
-                .map((item) => buildWhere(item, values))
+                .map((item) => buildWhere(item, values, offset))
                 .filter(Boolean);
 
             if (clauses.length) {
@@ -85,7 +92,7 @@ function buildWhere(where, values) {
                 throw new Error("AND conditions cannot be empty");
             }
             const clauses = value
-                .map((item) => buildWhere(item, values))
+                .map((item) => buildWhere(item, values, offset))
                 .filter(Boolean);
 
             if (clauses.length) {
@@ -95,28 +102,49 @@ function buildWhere(where, values) {
             continue;
         }
 
+        if (key === "NOT") {
+            if (!value || typeof value !== "object" || Array.isArray(value)) {
+                throw new Error("NOT condition must be an object");
+            }
+            const clause = buildWhere(value, values, offset);
+            if (clause) conditions.push(`NOT (${clause})`);
+            continue;
+        }
+
         if (value && typeof value === "object" && !Array.isArray(value)) {
             const operators = Object.keys(value);
 
-            const isOperatorObject = operators.some((op) =>
-                ["=", "!=", ">", "<", ">=", "<=", "LIKE", "IN", "NOT IN"].includes(op)
-            );
+            const isOperatorObject = operators.some((op) => COMPARISON_OPERATORS.includes(op));
 
             if (isOperatorObject) {
+                const dialect = getDialect();
+
                 for (const [operator, operatorValue] of Object.entries(value)) {
                     if (operator === "IN" || operator === "NOT IN") {
                         const placeholders = operatorValue
-                            .map((_, i) => getDialect().getPlaceholder(values.length + i))
+                            .map((_, i) => dialect.getPlaceholder(offset + values.length + i))
                             .join(",");
 
-                        conditions.push(
-                            `${getDialect().escape(key)} ${operator} (${placeholders})`
-                        );
+                        conditions.push(`${dialect.escape(key)} ${operator} (${placeholders})`);
                         values.push(...operatorValue);
+                    } else if (operator === "BETWEEN" || operator === "NOT BETWEEN") {
+                        const [min, max] = operatorValue;
+                        const lowPlaceholder = dialect.getPlaceholder(offset + values.length);
+                        const highPlaceholder = dialect.getPlaceholder(offset + values.length + 1);
+
+                        conditions.push(`${dialect.escape(key)} ${operator} ${lowPlaceholder} AND ${highPlaceholder}`);
+                        values.push(min, max);
+                    } else if (operator === "ILIKE" || operator === "NOT ILIKE") {
+                        const placeholder = dialect.getPlaceholder(offset + values.length);
+                        const negate = operator === "NOT ILIKE";
+                        const fallback = buildCaseInsensitiveLike(dialect, key, placeholder, negate);
+
+                        conditions.push(fallback ?? `${dialect.escape(key)} ${operator} ${placeholder}`);
+                        values.push(operatorValue);
                     } else if (operatorValue === null && (operator === "=" || operator === "!=")) {
-                        conditions.push(`${getDialect().escape(key)} IS ${operator === "!=" ? "NOT " : ""}NULL`);
+                        conditions.push(`${dialect.escape(key)} IS ${operator === "!=" ? "NOT " : ""}NULL`);
                     } else {
-                        conditions.push(`${getDialect().escape(key)} ${operator} ${getDialect().getPlaceholder(values.length)}`);
+                        conditions.push(`${dialect.escape(key)} ${operator} ${dialect.getPlaceholder(offset + values.length)}`);
                         values.push(operatorValue);
                     }
                 }
@@ -129,7 +157,7 @@ function buildWhere(where, values) {
             continue;
         }
 
-        conditions.push(`${getDialect().escape(key)} = ${getDialect().getPlaceholder(values.length)}`);
+        conditions.push(`${getDialect().escape(key)} = ${getDialect().getPlaceholder(offset + values.length)}`);
         values.push(value);
     }
 
@@ -139,9 +167,10 @@ function buildWhere(where, values) {
 /**
  * Construit les parties de la requête et extrait les valeurs sécurisées
  * @param {Object} options Options de filtrage, tri et pagination
+ * @param {number} [valueOffset=0] Décalage d'index pour les placeholders (utile quand des valeurs ont déjà été liées avant le WHERE, ex: SET d'un UPDATE)
  * @returns {Object} Un objet contenant la chaîne SQL générée et le tableau des valeurs { sql, values }
  */
-function buildQueryParts(options) {
+function buildQueryParts(options, valueOffset = 0) {
     const parts = [];
     const values = [];
 
@@ -152,7 +181,7 @@ function buildQueryParts(options) {
         if (typeof options.where !== 'object' || Array.isArray(options.where)) {
             throw new Error("Raw string WHERE clauses are not allowed. Use a structured filter instead.");
         }
-        parts.push(`WHERE ${buildWhere(options.where, values)}`);
+        parts.push(`WHERE ${buildWhere(options.where, values, valueOffset)}`);
     }
 
     if (options.groupBy) {
@@ -160,7 +189,10 @@ function buildQueryParts(options) {
     }
 
     if (options.having) {
-        throw new Error("Raw string HAVING clauses are not allowed. Use a structured filter instead.");
+        if (typeof options.having !== 'object' || Array.isArray(options.having)) {
+            throw new Error("Raw string HAVING clauses are not allowed. Use a structured filter instead.");
+        }
+        parts.push(`HAVING ${buildWhere(options.having, values, valueOffset)}`);
     }
 
     if (options.orderBy) {
@@ -177,10 +209,19 @@ function buildQueryParts(options) {
             throw new Error("Invalid LIMIT value");
         }
 
-        parts.push(`LIMIT ?`);
+        parts.push(`LIMIT ${getDialect().getPlaceholder(valueOffset + values.length)}`);
         values.push(options.limit);
     }
 
+    if (options.offset !== undefined) {
+        if (!Number.isInteger(options.offset) || options.offset < 0) {
+            throw new Error("Invalid OFFSET value");
+        }
+
+        parts.push(`OFFSET ${getDialect().getPlaceholder(valueOffset + values.length)}`);
+        values.push(options.offset);
+    }
+
     return {
         sql: parts.join('\n\n'),
         values: values

package/src/utils/sqlTypeMap.js

@@ -1,13 +1,21 @@
 const sqlTypeMap = {
     String: 'VARCHAR',
+    Char: 'CHAR',
     Number: 'INT',
+    SmallInt: 'SMALLINT',
+    BigInt: 'BIGINT',
+    Decimal: 'DECIMAL',
     Boolean: 'BOOLEAN',
     Date: 'DATETIME',
     Object: 'JSON',
     Array: 'VARCHAR',
     Now: 'NOW()',
     Float: 'FLOAT',
+    Double: 'DOUBLE',
     Text: 'TEXT',
+    Blob: 'BLOB',
+    Binary: 'VARBINARY',
+    Uuid: 'CHAR',
     DateTime: "DATETIME",
     Timestamp: "TIMESTAMP",
     CurrentTimestamp: "CURRENT_TIMESTAMP"