@mlagie/sql-connector 3.0.3 → 3.1.0

package/src/migration/dialects/MySQLDialect.js

@@ -0,0 +1,205 @@
+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 };

package/src/migration/dialects/PostgreSQLDialect.js

@@ -0,0 +1,233 @@
+const { Dialect } = require("./Dialect");
+const { normalizeType } = require("../utils");
+
+class PostgreSQLDialect extends Dialect {
+    constructor() {
+        super("postgres", {
+            quote: '"',
+            capabilities: {
+                transactionalDDL: true,
+                renameColumn: true,
+                alterColumn: true
+            }
+        });
+    }
+
+    placeholder(index) {
+        return `$${index + 1}`;
+    }
+
+    execute(connection, sql, values = []) {
+        if (typeof connection.query === "function") {
+            return connection.query(sql, values).then(result => result.rows);
+        }
+        throw new Error("PostgreSQL connection does not expose query().");
+    }
+
+    mapType(field) {
+        const rawType = normalizeType(field);
+        const type = String(rawType || "").toUpperCase();
+        const length = field.length || 255;
+
+        switch (type) {
+            case "STRING":
+            case "VARCHAR":
+            case "CHARACTER VARYING":
+                return `VARCHAR(${length})`;
+            case "CHAR":
+            case "BPCHAR":
+            case "CHARACTER":
+                return `CHAR(${length})`;
+            case "TEXT":
+                return "TEXT";
+            case "NUMBER":
+            case "INT":
+            case "INT4":
+            case "INTEGER":
+                return "INTEGER";
+            case "SMALLINT":
+            case "INT2":
+                return "SMALLINT";
+            case "BIGINT":
+            case "INT8":
+                return "BIGINT";
+            case "DECIMAL":
+            case "NUMERIC":
+                return "DECIMAL";
+            case "FLOAT":
+            case "FLOAT4":
+            case "REAL":
+                return "REAL";
+            case "DOUBLE":
+            case "FLOAT8":
+            case "DOUBLE PRECISION":
+                return "DOUBLE PRECISION";
+            case "BOOLEAN":
+            case "BOOL":
+                return "BOOLEAN";
+            case "DATE":
+                return "DATE";
+            case "DATETIME":
+            case "TIMESTAMP":
+            case "NOW":
+            case "CURRENTTIMESTAMP":
+                return "TIMESTAMP";
+            case "TIMESTAMPTZ":
+            case "TIMESTAMP WITH TIME ZONE":
+                return "TIMESTAMPTZ";
+            case "OBJECT":
+            case "JSON":
+            case "JSONB":
+                return "JSONB";
+            case "UUID":
+                return "UUID";
+            default:
+                throw new Error(`Unsupported PostgreSQL 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 ? "TRUE" : "FALSE"}`;
+        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)}`;
+        if (field.unique) sql += " UNIQUE";
+        if (field.primary_key) sql += " PRIMARY KEY";
+        if (field.auto_increment) {
+            // Explicit auto-increment is represented with identity syntax.
+            sql = sql.replace(/\s+(INTEGER|BIGINT|SMALLINT)(?=\s|$)/i, " $1 GENERATED BY DEFAULT AS IDENTITY");
+        }
+        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) {
+        const clauses = [
+            `ALTER COLUMN ${this.escape(name)} TYPE ${this.mapType(field)}`
+        ];
+
+        if (field.required || field.primary_key) {
+            clauses.push(`ALTER COLUMN ${this.escape(name)} SET NOT NULL`);
+        } else {
+            clauses.push(`ALTER COLUMN ${this.escape(name)} DROP NOT NULL`);
+        }
+
+        if (field.default === undefined) {
+            clauses.push(`ALTER COLUMN ${this.escape(name)} DROP DEFAULT`);
+        } else {
+            clauses.push(`ALTER COLUMN ${this.escape(name)} SET ${this.defaultSql(field.default)}`);
+        }
+
+        return `ALTER TABLE ${this.escape(table)} ${clauses.join(", ")};`;
+    }
+
+    introspectionQueries() {
+        return {
+            tables: `
+                SELECT table_name
+                FROM information_schema.tables
+                WHERE table_schema = current_schema()
+                  AND table_type = 'BASE TABLE'
+            `,
+            columns: `
+                SELECT
+                    column_name,
+                    data_type,
+                    udt_name,
+                    is_nullable,
+                    column_default,
+                    character_maximum_length
+                FROM information_schema.columns
+                WHERE table_schema = current_schema()
+                  AND table_name = $1
+                ORDER BY ordinal_position
+            `
+        };
+    }
+
+    normalizeDatabaseColumn(row) {
+        const type = String(row.udt_name || row.data_type || "").toLowerCase();
+        const isSerial = typeof row.column_default === "string" &&
+            row.column_default.includes("nextval(");
+
+        return {
+            type,
+            length: row.character_maximum_length ?? undefined,
+            required: row.is_nullable === "NO",
+            primary_key: false,
+            unique: false,
+            auto_increment: isSerial,
+            default: row.column_default
+        };
+    }
+
+    createMigrationTable() {
+        return `
+            CREATE TABLE IF NOT EXISTS ${this.escape("sql_connector_migrations")} (
+                ${this.escape("id")} VARCHAR(255) NOT NULL PRIMARY KEY,
+                ${this.escape("checksum")} VARCHAR(64) NOT NULL,
+                ${this.escape("applied_at")} TIMESTAMPTZ NOT NULL,
+                ${this.escape("created_at")} TIMESTAMPTZ 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 ($1, $2, $3, $4)
+        `;
+    }
+
+    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")} = $1`;
+    }
+}
+
+module.exports = { PostgreSQLDialect };

package/src/migration/dialects/index.js

@@ -0,0 +1,21 @@
+const { MySQLDialect } = require("./MySQLDialect");
+const { PostgreSQLDialect } = require("./PostgreSQLDialect");
+
+function createDialect(name) {
+    switch (String(name || "mysql").toLowerCase()) {
+        case "mysql":
+        case "mariadb":
+            return new MySQLDialect();
+        case "postgres":
+        case "postgresql":
+                return new PostgreSQLDialect();
+        default:
+            throw new Error(`Unsupported migration dialect: ${name}`);
+    }
+}
+
+module.exports = {
+    createDialect,
+    MySQLDialect,
+    PostgreSQLDialect
+};

package/src/migration/errors.js

@@ -0,0 +1,28 @@
+class MigrationError extends Error {
+    constructor(message, code = "MIGRATION_ERROR", details = undefined) {
+        super(message);
+        this.name = "MigrationError";
+        this.code = code;
+        this.details = details;
+    }
+}
+
+class DestructiveMigrationError extends MigrationError {
+    constructor(message, details) {
+        super(message, "DESTRUCTIVE_MIGRATION", details);
+        this.name = "DestructiveMigrationError";
+    }
+}
+
+class MigrationChecksumError extends MigrationError {
+    constructor(message, details) {
+        super(message, "MIGRATION_CHECKSUM_MISMATCH", details);
+        this.name = "MigrationChecksumError";
+    }
+}
+
+module.exports = {
+    MigrationError,
+    DestructiveMigrationError,
+    MigrationChecksumError
+};

package/src/migration/index.js

@@ -0,0 +1,18 @@
+const { Migration } = require("./Migration");
+const { MigrationPlan } = require("./MigrationPlan");
+const { MigrationStore } = require("./MigrationStore");
+const { MigrationRunner } = require("./MigrationRunner");
+const { SchemaDiffer } = require("./SchemaDiffer");
+const { SchemaInspector } = require("./SchemaInspector");
+const { MySQLDialect, PostgreSQLDialect } = require("./dialects");
+
+module.exports = {
+    Migration,
+    MigrationPlan,
+    MigrationStore,
+    MigrationRunner,
+    SchemaDiffer,
+    SchemaInspector,
+    MySQLDialect,
+    PostgreSQLDialect
+};

package/src/migration/utils.js

@@ -0,0 +1,89 @@
+const crypto = require("crypto");
+const { getSafe } = require("../utils/security/safe");
+
+function assertIdentifier(value, label = "identifier") {
+    if (typeof value !== "string" || !/^[A-Za-z_][A-Za-z0-9_$]*$/.test(value)) {
+        throw new Error(`Invalid ${label}: ${value}`);
+    }
+    return value;
+}
+
+function quoteIdentifier(name, quote) {
+    assertIdentifier(name);
+    return `${quote}${name}${quote}`;
+}
+
+function normalizeType(field) {
+    const type = field && field.type;
+    if (typeof type === "function") return type.name;
+    if (type && typeof type === "object" && typeof type.name === "string") return type.name;
+    if (typeof type === "string") return type;
+    return undefined;
+}
+
+function normalizeDefault(value) {
+    if (value === undefined) return undefined;
+    if (value === null) return null;
+    if (typeof value === "string") return value;
+    if (typeof value === "number" || typeof value === "boolean") return value;
+    return String(value);
+}
+
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+    return `{${Object.keys(value).sort().map(k => `${JSON.stringify(k)}:${getSafe(value, k)}`)}.join(",")}}`;
+}
+
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+
+function migrationId(name = "migration") {
+    const now = new Date();
+    const stamp = now.toISOString()
+        .replace(/[-:TZ.]/g, "")
+        .slice(0, 14);
+    const safeName = String(name)
+        .trim()
+        .replace(/[^A-Za-z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "")
+        .slice(0, 80) || "migration";
+    return `${stamp}_${safeName}`;
+}
+
+function parseDuration(value) {
+    if (value === null || value === false || value === undefined) return null;
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) return value;
+
+    const match = /^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/i.exec(String(value).trim());
+    if (!match) throw new Error(`Invalid retention duration: ${value}`);
+
+    const amount = Number(match[1]);
+    const unit = match[2].toLowerCase();
+    const factors = {
+        ms: 1,
+        s: 1000,
+        m: 60_000,
+        h: 3_600_000,
+        d: 86_400_000,
+        w: 604_800_000
+    };
+    return amount * getSafe(factors, unit);
+}
+
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+
+module.exports = {
+    assertIdentifier,
+    quoteIdentifier,
+    normalizeType,
+    normalizeDefault,
+    stableStringify,
+    sha256,
+    migrationId,
+    parseDuration,
+    clone
+};

package/src/models/Model.js

@@ -5,6 +5,7 @@ const { ModelInstance } = require("./ModelInstance");
 const { buildSelect, buildQueryParts } = require("../utils/buildQuery/buildQuery");
 const { getSafe, setSafe } = require("../utils/security/safe");
 const { getDialect } = require("../db/dialects");
+const LENGTH_TYPES = new Set(["VARCHAR", "CHAR", "BINARY", "VARBINARY"]);
 
 function getFieldType(field) {
     if (typeof field === "object") {
@@ -32,8 +33,12 @@ function getColumnDefinition(fieldName, field) {
     if (Array.isArray(field.enum) && field.enum.length > 0) {
         const enumValues = field.enum.map(v => `'${v.replace(/'/g, "''")}'`).join(", ");
         colDef = `ENUM(${enumValues})`;
+    } else if (type === "DECIMAL") {
+        const precision = field.precision > 0 ? field.precision : 10;
+        const scale = field.scale >= 0 ? field.scale : 0;
+        colDef = `DECIMAL(${precision}, ${scale})`;
     } else {
-        const hasLength = type === "VARCHAR" || (type === "INT" && getDialect().name === "mysql");
+        const hasLength = LENGTH_TYPES.has(type) || (type === "INT" && getDialect().name === "mysql");
         colDef = `${type}${hasLength ? `(${field.length > 0 ? field.length : 255})` : ""}`;
     }
 
@@ -163,7 +168,8 @@ class Model {
             const type = getSafe(sqlTypeMap, fieldType);
 
             if (!type) throw new Error(`Field ${fieldName} has unsupported type ${field}`);
-            if (type == "VARCHAR") return `${getDialect().escape(fieldName)} ${type}(${lengthDefault})`;
+            if (LENGTH_TYPES.has(type)) return `${getDialect().escape(fieldName)} ${type}(${lengthDefault})`;
+            if (type === "DECIMAL") return `${getDialect().escape(fieldName)} ${type}(10, 0)`;
             return `${getDialect().escape(fieldName)} ${type}`;
         });
         return `CREATE TABLE IF NOT EXISTS ${getDialect().escape(this.name)} (${columns.join(', ')}${foreignKey.length > 0 ? ", " + foreignKey.join(', ') : ""}) ${getDialect().tableSuffix};`;

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 }