@mlagie/sql-connector 3.1.0 → 3.3.0

package/src/migration/SchemaDiffer.js

@@ -171,37 +171,13 @@ class SchemaDiffer {
 
             /*
              * Second pass:
-             * detect additions and modifications.
-             */
-            for (const [columnName, field] of Object.entries(desiredColumns)) {
-                const currentField = getSafe(virtualCurrentColumns, columnName);
-
-                if (!currentField) {
-                    operations.push({
-                        type: "addColumn",
-                        table: tableName,
-                        column: columnName,
-                        field
-                    });
-
-                    continue;
-                }
-
-                if (!equivalentField(field, currentField)) {
-                    operations.push({
-                        type: "alterColumn",
-                        table: tableName,
-                        column: columnName,
-                        field,
-                        previous: currentField
-                    });
-                }
-            }
-
-            /*
-             * Third pass:
              * detect removed columns.
              *
+             * Deletions are emitted BEFORE additions/alterations so that a
+             * dropped primary key column (e.g. `uuid`) releases its PRIMARY KEY
+             * before a new one (e.g. `id`) is added; otherwise PostgreSQL fails
+             * with "multiple primary keys for table".
+             *
              * Renamed columns are excluded because their old name
              * intentionally disappears from the desired schema.
              */
@@ -228,6 +204,35 @@ class SchemaDiffer {
                     operations.push(operation);
                 }
             }
+            /*
+             * Third pass:
+             * detect additions and modifications (after the deletions).
+             */
+            for (const [columnName, field] of Object.entries(desiredColumns)) {
+                const currentField = getSafe(virtualCurrentColumns, columnName);
+
+                if (!currentField) {
+                    operations.push({
+                        type: "addColumn",
+                        table: tableName,
+                        column: columnName,
+                        field
+                    });
+
+                    continue;
+                }
+
+                if (!equivalentField(field, currentField)) {
+                    operations.push({
+                        type: "alterColumn",
+                        table: tableName,
+                        column: columnName,
+                        field,
+                        previous: currentField
+                    });
+                }
+            }
+
         }
 
         /*

package/src/migration/SchemaInspector.js

@@ -22,7 +22,7 @@ class SchemaInspector {
 
             const columnRows = await this.query(
                 queries.columns,
-                this.dialect.name === "postgres" ? [tableName] : [tableName]
+                [tableName]
             );
             setSafe(tables, tableName, {
                 columns: Object.fromEntries(

package/src/migration/index.js

@@ -4,7 +4,6 @@ const { MigrationStore } = require("./MigrationStore");
 const { MigrationRunner } = require("./MigrationRunner");
 const { SchemaDiffer } = require("./SchemaDiffer");
 const { SchemaInspector } = require("./SchemaInspector");
-const { MySQLDialect, PostgreSQLDialect } = require("./dialects");
 
 module.exports = {
     Migration,
@@ -13,6 +12,4 @@ module.exports = {
     MigrationRunner,
     SchemaDiffer,
     SchemaInspector,
-    MySQLDialect,
-    PostgreSQLDialect
 };

package/src/models/Model.js

@@ -26,7 +26,7 @@ function getColumnDefinition(fieldName, field) {
     }
 
     const fieldType = getFieldType(field);
-    const type = getSafe(sqlTypeMap, fieldType);
+    const type = getDialect().mapType(fieldType);
     if (!type) throw new Error(`Field ${fieldName} has unsupported type ${fieldType}.`);
 
     let colDef;
@@ -38,8 +38,8 @@ function getColumnDefinition(fieldName, field) {
         const scale = field.scale >= 0 ? field.scale : 0;
         colDef = `DECIMAL(${precision}, ${scale})`;
     } else {
-        const hasLength = LENGTH_TYPES.has(type) || (type === "INT" && getDialect().name === "mysql");
-        colDef = `${type}${hasLength ? `(${field.length > 0 ? field.length : 255})` : ""}`;
+        const hasLength = LENGTH_TYPES.has(type) || type === "INT";
+        colDef = getDialect().columnType(type, hasLength ? (field.length > 0 ? field.length : 255) : undefined);
     }
 
     if (field.required) colDef += ' NOT NULL';
@@ -48,7 +48,7 @@ function getColumnDefinition(fieldName, field) {
 
     if (defaultDefinition !== null) colDef += ` ${defaultDefinition}`;
     if (field.unique) colDef += ' UNIQUE';
-    if (field.auto_increment) colDef += ' AUTO_INCREMENT';
+    if (field.auto_increment) colDef += ` ${getDialect().autoIncrement(fieldType)}`;
     if (field.primary_key) colDef += ' PRIMARY KEY'
     if (typeof field.customize === 'string' && field.customize.length != 0) colDef += ` ${field.customize}`;
     return `${getDialect().escape(fieldName)} ${colDef}`;
@@ -165,7 +165,7 @@ class Model {
                 return `${getDialect().escape(fieldName)} ENUM(${enumValues})`;
             }
 
-            const type = getSafe(sqlTypeMap, fieldType);
+            const type = getDialect().mapType(fieldType);
 
             if (!type) throw new Error(`Field ${fieldName} has unsupported type ${field}`);
             if (LENGTH_TYPES.has(type)) return `${getDialect().escape(fieldName)} ${type}(${lengthDefault})`;
@@ -183,7 +183,7 @@ class Model {
      */
     async save(data) {
         const keys = Object.keys(data);
-        const sql_request = `INSERT INTO ${getDialect().escape(this.name)} (${getDialect().escapeIdentifierList(keys)}) VALUES (${keys.map(() => "?").join(", ")})`;
+        const sql_request = `INSERT INTO ${getDialect().escape(this.name)} (${getDialect().escapeIdentifierList(keys)}) VALUES (${keys.map((_, index) => getDialect().getPlaceholder(index)).join(", ")})`;
 
         try {
             const result = await getDialect().execute(getConnexion(), sql_request, Object.values(data));

package/src/utils/buildQuery/buildAggregationField.js

@@ -0,0 +1,11 @@
+const { getDialect } = require("../../db/dialects");
+
+module.exports = (aggregateType, field) => {
+    if (typeof field === 'string') return `${aggregateType}(${getDialect().escape(field)})`;
+    if (field instanceof Array && field !== null) return field.map(col => `${aggregateType}(${getDialect().escape(col)})`).join(' + ');
+    if (field instanceof Object) {
+        const [key, value] = Object.entries(field)[0];
+        return `${aggregateType}(CASE WHEN ${getDialect().escape(key)} = ${getDialect().escapeValue(value)} THEN 1 END)`;
+    }
+    throw new Error(`Invalid field type for ${aggregateType}. Must be a string, array, or object.`);
+}

package/src/utils/buildQuery/buildQuery.js

@@ -1,6 +1,6 @@
 const { getDialect } = require("../../db/dialects");
 const { escapeOrderDirection } = require("../sql");
-const count = require("./count");
+const buildAggregationField = require("./buildAggregationField");
 
 function buildGroupByItem(group) {
     let sql;
@@ -10,7 +10,7 @@ function buildGroupByItem(group) {
     if (typeof group === 'object') {
         if (group.dateFormat) {
             const [col, format] = group.dateFormat;
-            sql = `DATE_FORMAT(${getDialect().escape(col)}, ${getDialect().escapeValue(format)})`;
+            sql = getDialect().dateFormat(getDialect().escape(col), format);
         }
         if (group.col) {
             sql = getDialect().escape(group.col);
@@ -36,14 +36,16 @@ function buildField(field) {
         sql = `SUM(${getDialect().escape(field.sum)})`;
     else if (field.dateFormat) {
         const [col, format] = field.dateFormat;
-        sql = `DATE_FORMAT(${getDialect().escape(col)}, ${getDialect().escapeValue(format)})`;
+        sql = getDialect().dateFormat(getDialect().escape(col), format);
     }
     else if (field.col)
         sql = getDialect().escape(field.col);
     else if (field.distinct)
         sql = `DISTINCT ${getDialect().escape(field.distinct)}`;
     else if (field.count)
-        sql = count(field.count);
+        sql = buildAggregationField("COUNT", field.count);
+    else if (field.max)
+        sql = buildAggregationField("MAX", field.max);
     if (field.as)
         sql += ` AS ${getDialect().escape(field.as)}`;
     else if (field.sum)
@@ -64,8 +66,7 @@ function buildSelect(select = []) {
 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})`;
+    return dialect.caseInsensitiveLike(dialect.escape(key), placeholder, negate);
 }
 
 function buildWhere(where, values, offset) {
@@ -139,7 +140,7 @@ function buildWhere(where, values, offset) {
                         const negate = operator === "NOT ILIKE";
                         const fallback = buildCaseInsensitiveLike(dialect, key, placeholder, negate);
 
-                        conditions.push(fallback ?? `${dialect.escape(key)} ${operator} ${placeholder}`);
+                        conditions.push(fallback);
                         values.push(operatorValue);
                     } else if (operatorValue === null && (operator === "=" || operator === "!=")) {
                         conditions.push(`${dialect.escape(key)} IS ${operator === "!=" ? "NOT " : ""}NULL`);

package/src/migration/dialects/Dialect.js

@@ -1,112 +0,0 @@
-const { quoteIdentifier } = require("../utils");
-
-class Dialect {
-    constructor(name, options = {}) {
-        this.name = name;
-        this.quote = options.quote;
-        this.capabilities = {
-            transactionalDDL: false,
-            renameColumn: true,
-            alterColumn: true,
-            ...options.capabilities
-        };
-    }
-
-    escape(name) {
-        return quoteIdentifier(name, this.quote);
-    }
-
-    placeholder() {
-        return "?";
-    }
-
-    placeholders(count) {
-        return Array.from({ length: count }, (_, i) => this.placeholder(i)).join(", ");
-    }
-
-    execute() {
-        throw new Error(`${this.name} dialect must implement execute().`);
-    }
-
-    async begin() {}
-    async commit() {}
-    async rollback() {}
-
-    mapType() {
-        throw new Error(`${this.name} dialect must implement mapType().`);
-    }
-
-    columnDefinition() {
-        throw new Error(`${this.name} dialect must implement columnDefinition().`);
-    }
-
-    createTable() {
-        throw new Error(`${this.name} dialect must implement createTable().`);
-    }
-
-    addColumn(table, name, field) {
-        return `ALTER TABLE ${this.escape(table)} ADD COLUMN ${this.columnDefinition(name, field)};`;
-    }
-
-    renameColumn(table, oldName, newName) {
-        return `ALTER TABLE ${this.escape(table)} RENAME COLUMN ${this.escape(oldName)} TO ${this.escape(newName)};`;
-    }
-
-    alterColumn() {
-        throw new Error(`${this.name} does not implement alterColumn().`);
-    }
-
-    dropColumn(table, name) {
-        return `ALTER TABLE ${this.escape(table)} DROP COLUMN ${this.escape(name)};`;
-    }
-
-    dropTable(table) {
-        return `DROP TABLE ${this.escape(table)};`;
-    }
-
-    introspectionQueries() {
-        throw new Error(`${this.name} dialect must implement introspectionQueries().`);
-    }
-
-    normalizeDatabaseColumn(row) {
-        return row;
-    }
-
-    normalizeDatabaseTable(row) {
-        return row;
-    }
-
-    createMigrationTable() {
-        throw new Error(`${this.name} dialect must implement createMigrationTable().`);
-    }
-
-    insertMigration() {
-        throw new Error(`${this.name} dialect must implement insertMigration().`);
-    }
-
-    selectMigrations() {
-        throw new Error(`${this.name} dialect must implement selectMigrations().`);
-    }
-
-    deleteMigration() {
-        throw new Error(`${this.name} dialect must implement deleteMigration().`);
-    }
-
-    async transaction(connection, callback) {
-        if (!this.capabilities.transactionalDDL) return callback();
-
-        await this.begin(connection);
-        try {
-            const result = await callback();
-            await this.commit(connection);
-            return result;
-        } catch (error) {
-            try {
-                await this.rollback(connection);
-            } catch {}
-            throw error;
-        }
-    }
-}
-
-module.exports = { Dialect };

package/src/migration/dialects/MySQLDialect.js

@@ -1,205 +0,0 @@
-const { Dialect } = require("./Dialect");
-const { normalizeType } = require("../utils");
-
-class MySQLDialect extends Dialect {
-    constructor() {
-        super("mysql", {
-            quote: "`",
-            capabilities: {
-                transactionalDDL: false,
-                renameColumn: true,
-                alterColumn: true
-            }
-        });
-    }
-
-    placeholder() {
-        return "?";
-    }
-
-    execute(connection, sql, values = []) {
-        return connection.promise ? connection.promise().query(sql, values).then(([rows]) => rows)
-            : new Promise((resolve, reject) => {
-                connection.query(sql, values, (error, rows) => error ? reject(error) : resolve(rows));
-            });
-    }
-
-    mapType(field) {
-        const rawType = normalizeType(field);
-        const type = String(rawType || "").toUpperCase();
-        const length = field.length || 255;
-
-        switch (type) {
-            case "STRING":
-            case "VARCHAR":
-                return `VARCHAR(${length})`;
-            case "CHAR":
-                return `CHAR(${length})`;
-            case "TEXT":
-                return "TEXT";
-            case "NUMBER":
-            case "INT":
-            case "INTEGER":
-                return "INT";
-            case "SMALLINT":
-                return "SMALLINT";
-            case "MEDIUMINT":
-                return "MEDIUMINT";
-            case "BIGINT":
-                return "BIGINT";
-            case "DECIMAL":
-            case "NUMERIC":
-                return "DECIMAL";
-            case "FLOAT":
-                return "DOUBLE";
-            case "DOUBLE":
-                return "DOUBLE";
-            case "BOOLEAN":
-            case "BOOL":
-            case "TINYINT":
-                return "BOOLEAN";
-            case "DATE":
-                return "DATE";
-            case "DATETIME":
-            case "TIMESTAMP":
-            case "NOW":
-            case "CURRENTTIMESTAMP":
-                return "DATETIME";
-            case "OBJECT":
-            case "JSON":
-                return "JSON";
-            case "BLOB":
-                return "BLOB";
-            case "VARBINARY":
-            case "BINARY":
-                return "VARBINARY";
-            default:
-                throw new Error(`Unsupported MySQL type: ${rawType}`);
-        }
-    }
-
-    defaultSql(value) {
-        if (value === undefined) return "";
-        if (value === null) return "DEFAULT NULL";
-        if (typeof value === "number") return `DEFAULT ${value}`;
-        if (typeof value === "boolean") return `DEFAULT ${value ? 1 : 0}`;
-        if (typeof value === "string") {
-            if (/^(CURRENT_TIMESTAMP|CURRENT_DATE|CURRENT_TIME)\b/i.test(value)) {
-                return `DEFAULT ${value}`;
-            }
-            return `DEFAULT '${value.replace(/'/g, "''")}'`;
-        }
-        return `DEFAULT '${String(value).replace(/'/g, "''")}'`;
-    }
-
-    columnDefinition(name, field) {
-        if (field.primary_key && field.unique) {
-            throw new Error(`Field '${name}' cannot be both PRIMARY KEY and UNIQUE.`);
-        }
-
-        let sql = `${this.escape(name)} ${this.mapType(field)}`;
-
-        if (field.required || field.primary_key) sql += " NOT NULL";
-        if (field.default !== undefined) sql += ` ${this.defaultSql(field.default, field)}`;
-        if (field.unique) sql += " UNIQUE";
-        if (field.auto_increment) sql += " AUTO_INCREMENT";
-        if (field.primary_key) sql += " PRIMARY KEY";
-        if (typeof field.customize === "string" && field.customize.trim()) {
-            sql += ` ${field.customize.trim()}`;
-        }
-
-        return sql;
-    }
-
-    createTable(table, schema) {
-        const columns = [];
-        const foreignKeys = [];
-
-        for (const [name, field] of Object.entries(schema)) {
-            columns.push(this.columnDefinition(name, field));
-
-            if (field.foreignKey) {
-                const match = /^([A-Za-z_][A-Za-z0-9_$]*)(?:\s*\(\s*([A-Za-z_][A-Za-z0-9_$]*)\s*\)|\s*\.\s*([A-Za-z_][A-Za-z0-9_$]*)\s*)$/.exec(field.foreignKey);
-                if (!match) throw new Error(`Invalid foreign key definition for ${name}.`);
-                const refColumn = match[2] || match[3];
-                foreignKeys.push(
-                    `FOREIGN KEY (${this.escape(name)}) REFERENCES ${this.escape(match[1])} (${this.escape(refColumn)})`
-                );
-            }
-        }
-
-        return `CREATE TABLE IF NOT EXISTS ${this.escape(table)} (${columns.concat(foreignKeys).join(", ")});`;
-    }
-
-    alterColumn(table, name, field) {
-        return `ALTER TABLE ${this.escape(table)} MODIFY COLUMN ${this.columnDefinition(name, field)};`;
-    }
-
-    introspectionQueries() {
-        return {
-            tables: `
-                SELECT TABLE_NAME AS table_name
-                FROM information_schema.tables
-                WHERE table_schema = DATABASE()
-                  AND table_type = 'BASE TABLE'
-            `,
-            columns: `
-                SELECT
-                    COLUMN_NAME AS column_name,
-                    DATA_TYPE AS data_type,
-                    COLUMN_TYPE AS column_type,
-                    IS_NULLABLE AS is_nullable,
-                    COLUMN_DEFAULT AS column_default,
-                    COLUMN_KEY AS column_key,
-                    EXTRA AS extra,
-                    CHARACTER_MAXIMUM_LENGTH AS character_maximum_length
-                FROM information_schema.columns
-                WHERE table_schema = DATABASE()
-                  AND table_name = ?
-                ORDER BY ORDINAL_POSITION
-            `
-        };
-    }
-
-    normalizeDatabaseColumn(row) {
-        const type = String(row.data_type || "").toLowerCase();
-        return {
-            type,
-            length: row.character_maximum_length ?? undefined,
-            required: row.is_nullable === "NO",
-            primary_key: row.column_key === "PRI",
-            unique: row.column_key === "UNI",
-            auto_increment: String(row.extra || "").toLowerCase().includes("auto_increment"),
-            default: row.column_default
-        };
-    }
-
-    createMigrationTable() {
-        return `
-            CREATE TABLE IF NOT EXISTS ${this.escape("sql_connector_migrations")} (
-                ${this.escape("id")} VARCHAR(191) NOT NULL PRIMARY KEY,
-                ${this.escape("checksum")} VARCHAR(64) NOT NULL,
-                ${this.escape("applied_at")} DATETIME NOT NULL,
-                ${this.escape("created_at")} DATETIME NOT NULL
-            );
-        `;
-    }
-
-    insertMigration() {
-        return `
-            INSERT INTO ${this.escape("sql_connector_migrations")}
-            (${this.escape("id")}, ${this.escape("checksum")}, ${this.escape("applied_at")}, ${this.escape("created_at")})
-            VALUES (?, ?, ?, ?)
-        `;
-    }
-
-    selectMigrations() {
-        return `SELECT ${this.escape("id")} AS id, ${this.escape("checksum")} AS checksum, ${this.escape("applied_at")} AS applied_at FROM ${this.escape("sql_connector_migrations")} ORDER BY ${this.escape("id")}`;
-    }
-
-    deleteMigration() {
-        return `DELETE FROM ${this.escape("sql_connector_migrations")} WHERE ${this.escape("id")} = ?`;
-    }
-}
-
-module.exports = { MySQLDialect };