@mlagie/sql-connector 3.1.0 → 3.2.0

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/buildQuery.js

@@ -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,7 +36,7 @@ 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);
@@ -64,8 +64,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 +138,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 };

package/src/migration/dialects/PostgreSQLDialect.js

@@ -1,233 +0,0 @@
-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

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