@mlagie/sql-connector 3.1.0 → 3.3.0

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
-};

package/src/utils/buildQuery/count.js

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