@remix-run/data-table-postgres 0.0.0 → 0.2.0

package/dist/lib/adapter.js

@@ -0,0 +1,735 @@
+import { getTablePrimaryKey } from '@remix-run/data-table';
+import { isDataManipulationOperation as isDataManipulationOperationHelper, quoteLiteral as quoteLiteralHelper, quoteTableRef as quoteTableRefHelper, } from '@remix-run/data-table/sql-helpers';
+import { compilePostgresOperation } from "./sql-compiler.js";
+/**
+ * `DatabaseAdapter` implementation for postgres-compatible clients.
+ */
+export class PostgresDatabaseAdapter {
+    /**
+     * The SQL dialect identifier reported by this adapter.
+     */
+    dialect = 'postgres';
+    /**
+     * Feature flags describing the postgres behaviors supported by this adapter.
+     */
+    capabilities;
+    #client;
+    #transactions = new Map();
+    #transactionCounter = 0;
+    constructor(client, options) {
+        this.#client = client;
+        this.capabilities = {
+            returning: options?.capabilities?.returning ?? true,
+            savepoints: options?.capabilities?.savepoints ?? true,
+            upsert: options?.capabilities?.upsert ?? true,
+            transactionalDdl: options?.capabilities?.transactionalDdl ?? true,
+            migrationLock: options?.capabilities?.migrationLock ?? true,
+        };
+    }
+    /**
+     * Compiles a data or migration operation to postgres SQL statements.
+     * @param operation Operation to compile.
+     * @returns Compiled SQL statements.
+     */
+    compileSql(operation) {
+        if (isDataManipulationOperation(operation)) {
+            let compiled = compilePostgresOperation(operation);
+            return [{ text: compiled.text, values: compiled.values }];
+        }
+        return compilePostgresMigrationOperations(operation);
+    }
+    /**
+     * Executes a postgres data-manipulation request.
+     * @param request Request to execute.
+     * @returns Execution result.
+     */
+    async execute(request) {
+        if (request.operation.kind === 'insertMany' && request.operation.values.length === 0) {
+            return {
+                affectedRows: 0,
+                insertId: undefined,
+                rows: request.operation.returning ? [] : undefined,
+            };
+        }
+        let statement = compilePostgresOperation(request.operation);
+        let client = this.#resolveClient(request.transaction);
+        let result = await client.query(statement.text, statement.values);
+        let rows = normalizeRows(result.rows);
+        if (request.operation.kind === 'count' || request.operation.kind === 'exists') {
+            rows = normalizeCountRows(rows);
+        }
+        return {
+            rows,
+            affectedRows: normalizeAffectedRows(request.operation.kind, result.rowCount, rows),
+            insertId: normalizeInsertId(request.operation.kind, request.operation, rows),
+        };
+    }
+    /**
+     * Executes postgres migration operations.
+     * @param request Migration request to execute.
+     * @returns Migration result.
+     */
+    async migrate(request) {
+        let statements = this.compileSql(request.operation);
+        let client = this.#resolveClient(request.transaction);
+        for (let statement of statements) {
+            await client.query(statement.text, statement.values);
+        }
+        return {
+            affectedOperations: statements.length,
+        };
+    }
+    /**
+     * Checks whether a table exists in postgres.
+     * @param table Table reference to inspect.
+     * @param transaction Optional transaction token.
+     * @returns `true` when the table exists.
+     */
+    async hasTable(table, transaction) {
+        let relation = toPostgresRelationName(table);
+        let client = this.#resolveClient(transaction);
+        let result = await client.query('select to_regclass($1) is not null as "exists"', [relation]);
+        let row = result.rows[0];
+        return toBooleanExists(row?.exists);
+    }
+    /**
+     * Checks whether a column exists in postgres.
+     * @param table Table reference to inspect.
+     * @param column Column name to look up.
+     * @param transaction Optional transaction token.
+     * @returns `true` when the column exists.
+     */
+    async hasColumn(table, column, transaction) {
+        let relation = toPostgresRelationName(table);
+        let client = this.#resolveClient(transaction);
+        let result = await client.query('select exists (select 1 from pg_attribute where attrelid = to_regclass($1) and attname = $2 and attnum > 0 and not attisdropped) as "exists"', [relation, column]);
+        let row = result.rows[0];
+        return toBooleanExists(row?.exists);
+    }
+    /**
+     * Starts a postgres transaction.
+     * @param options Transaction options.
+     * @returns Transaction token.
+     */
+    async beginTransaction(options) {
+        let releaseOnClose = false;
+        let transactionClient;
+        if (isPostgresPool(this.#client)) {
+            transactionClient = await this.#client.connect();
+            releaseOnClose = true;
+        }
+        else {
+            transactionClient = this.#client;
+        }
+        await transactionClient.query('begin');
+        if (options?.isolationLevel || options?.readOnly !== undefined) {
+            await transactionClient.query(buildSetTransactionStatement(options));
+        }
+        this.#transactionCounter += 1;
+        let token = { id: 'tx_' + String(this.#transactionCounter) };
+        this.#transactions.set(token.id, {
+            client: transactionClient,
+            releaseOnClose,
+        });
+        return token;
+    }
+    /**
+     * Commits an open postgres transaction.
+     * @param token Transaction token to commit.
+     * @returns A promise that resolves when the transaction is committed.
+     */
+    async commitTransaction(token) {
+        let transaction = this.#transactions.get(token.id);
+        if (!transaction) {
+            throw new Error('Unknown transaction token: ' + token.id);
+        }
+        try {
+            await transaction.client.query('commit');
+        }
+        finally {
+            this.#transactions.delete(token.id);
+            if (transaction.releaseOnClose) {
+                releasePostgresClient(transaction.client);
+            }
+        }
+    }
+    /**
+     * Rolls back an open postgres transaction.
+     * @param token Transaction token to roll back.
+     * @returns A promise that resolves when the transaction is rolled back.
+     */
+    async rollbackTransaction(token) {
+        let transaction = this.#transactions.get(token.id);
+        if (!transaction) {
+            throw new Error('Unknown transaction token: ' + token.id);
+        }
+        try {
+            await transaction.client.query('rollback');
+        }
+        finally {
+            this.#transactions.delete(token.id);
+            if (transaction.releaseOnClose) {
+                releasePostgresClient(transaction.client);
+            }
+        }
+    }
+    /**
+     * Creates a savepoint in an open postgres transaction.
+     * @param token Transaction token to use.
+     * @param name Savepoint name.
+     * @returns A promise that resolves when the savepoint is created.
+     */
+    async createSavepoint(token, name) {
+        let client = this.#transactionClient(token);
+        await client.query('savepoint ' + quoteIdentifier(name));
+    }
+    /**
+     * Rolls back to a savepoint in an open postgres transaction.
+     * @param token Transaction token to use.
+     * @param name Savepoint name.
+     * @returns A promise that resolves when the rollback completes.
+     */
+    async rollbackToSavepoint(token, name) {
+        let client = this.#transactionClient(token);
+        await client.query('rollback to savepoint ' + quoteIdentifier(name));
+    }
+    /**
+     * Releases a savepoint in an open postgres transaction.
+     * @param token Transaction token to use.
+     * @param name Savepoint name.
+     * @returns A promise that resolves when the savepoint is released.
+     */
+    async releaseSavepoint(token, name) {
+        let client = this.#transactionClient(token);
+        await client.query('release savepoint ' + quoteIdentifier(name));
+    }
+    /**
+     * Acquires the postgres migration lock.
+     * @returns A promise that resolves when the lock is acquired.
+     */
+    async acquireMigrationLock() {
+        await this.#client.query('select pg_advisory_lock(hashtext($1))', ['data_table_migrations']);
+    }
+    /**
+     * Releases the postgres migration lock.
+     * @returns A promise that resolves when the lock is released.
+     */
+    async releaseMigrationLock() {
+        await this.#client.query('select pg_advisory_unlock(hashtext($1))', ['data_table_migrations']);
+    }
+    #resolveClient(token) {
+        if (!token) {
+            return this.#client;
+        }
+        return this.#transactionClient(token);
+    }
+    #transactionClient(token) {
+        let transaction = this.#transactions.get(token.id);
+        if (!transaction) {
+            throw new Error('Unknown transaction token: ' + token.id);
+        }
+        return transaction.client;
+    }
+}
+/**
+ * Creates a postgres `DatabaseAdapter`.
+ * @param client `pg` pool or pool client.
+ * @param options Optional adapter capability overrides.
+ * @returns A configured postgres adapter.
+ * @example
+ * ```ts
+ * import { Pool } from 'pg'
+ * import { createDatabase } from 'remix/data-table'
+ * import { createPostgresDatabaseAdapter } from 'remix/data-table-postgres'
+ *
+ * let pool = new Pool({ connectionString: process.env.DATABASE_URL })
+ * let adapter = createPostgresDatabaseAdapter(pool)
+ * let db = createDatabase(adapter)
+ * ```
+ */
+export function createPostgresDatabaseAdapter(client, options) {
+    return new PostgresDatabaseAdapter(client, options);
+}
+function isPostgresPool(client) {
+    return 'connect' in client && typeof client.connect === 'function';
+}
+function releasePostgresClient(client) {
+    let release = client.release;
+    release?.();
+}
+function buildSetTransactionStatement(options) {
+    let parts = ['set transaction'];
+    if (options.isolationLevel) {
+        parts.push('isolation level ' + options.isolationLevel);
+    }
+    if (options.readOnly !== undefined) {
+        parts.push(options.readOnly ? 'read only' : 'read write');
+    }
+    return parts.join(' ');
+}
+function normalizeRows(rows) {
+    return rows.map((row) => {
+        if (typeof row !== 'object' || row === null) {
+            return {};
+        }
+        return { ...row };
+    });
+}
+function normalizeCountRows(rows) {
+    return rows.map((row) => {
+        let count = row.count;
+        if (typeof count === 'string') {
+            let numeric = Number(count);
+            if (!Number.isNaN(numeric)) {
+                return {
+                    ...row,
+                    count: numeric,
+                };
+            }
+        }
+        if (typeof count === 'bigint') {
+            return {
+                ...row,
+                count: Number(count),
+            };
+        }
+        return row;
+    });
+}
+function normalizeAffectedRows(kind, rowCount, rows) {
+    if (kind === 'select' || kind === 'count' || kind === 'exists') {
+        return undefined;
+    }
+    if (rowCount !== null) {
+        return rowCount;
+    }
+    if (kind === 'raw') {
+        return undefined;
+    }
+    return rows.length;
+}
+function normalizeInsertId(kind, operation, rows) {
+    if (!isInsertOperationKind(kind) || !isInsertOperation(operation)) {
+        return undefined;
+    }
+    let primaryKey = getTablePrimaryKey(operation.table);
+    if (primaryKey.length !== 1) {
+        return undefined;
+    }
+    let key = primaryKey[0];
+    let row = rows[rows.length - 1];
+    return row ? row[key] : undefined;
+}
+function quoteIdentifier(value) {
+    return '"' + value.replace(/"/g, '""') + '"';
+}
+function toPostgresRelationName(table) {
+    if (table.schema) {
+        return quoteIdentifier(table.schema) + '.' + quoteIdentifier(table.name);
+    }
+    return quoteIdentifier(table.name);
+}
+function toBooleanExists(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'number') {
+        return value > 0;
+    }
+    if (typeof value === 'string') {
+        return value === 't' || value === 'true' || value === '1';
+    }
+    return false;
+}
+function isInsertOperationKind(kind) {
+    return kind === 'insert' || kind === 'insertMany' || kind === 'upsert';
+}
+function isInsertOperation(operation) {
+    return (operation.kind === 'insert' || operation.kind === 'insertMany' || operation.kind === 'upsert');
+}
+function isDataManipulationOperation(operation) {
+    return isDataManipulationOperationHelper(operation);
+}
+function compilePostgresMigrationOperations(operation) {
+    if (operation.kind === 'raw') {
+        return [{ text: operation.sql.text, values: [...operation.sql.values] }];
+    }
+    if (operation.kind === 'createTable') {
+        let columns = Object.keys(operation.columns).map((columnName) => quoteIdentifier(columnName) + ' ' + compilePostgresColumn(operation.columns[columnName]));
+        let tableConstraints = [];
+        if (operation.primaryKey) {
+            tableConstraints.push('constraint ' +
+                quoteIdentifier(operation.primaryKey.name) +
+                ' primary key (' +
+                operation.primaryKey.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                ')');
+        }
+        for (let unique of operation.uniques ?? []) {
+            tableConstraints.push('constraint ' +
+                quoteIdentifier(unique.name) +
+                ' ' +
+                'unique (' +
+                unique.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                ')');
+        }
+        for (let check of operation.checks ?? []) {
+            tableConstraints.push('constraint ' + quoteIdentifier(check.name) + ' ' + 'check (' + check.expression + ')');
+        }
+        for (let foreignKey of operation.foreignKeys ?? []) {
+            let clause = 'constraint ' +
+                quoteIdentifier(foreignKey.name) +
+                ' ' +
+                'foreign key (' +
+                foreignKey.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                ') references ' +
+                quoteTableRef(foreignKey.references.table) +
+                ' (' +
+                foreignKey.references.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                ')';
+            if (foreignKey.onDelete) {
+                clause += ' on delete ' + foreignKey.onDelete;
+            }
+            if (foreignKey.onUpdate) {
+                clause += ' on update ' + foreignKey.onUpdate;
+            }
+            tableConstraints.push(clause);
+        }
+        let sql = 'create table ' +
+            (operation.ifNotExists ? 'if not exists ' : '') +
+            quoteTableRef(operation.table) +
+            ' (' +
+            [...columns, ...tableConstraints].join(', ') +
+            ')';
+        let statements = [{ text: sql, values: [] }];
+        if (operation.comment) {
+            statements.push({
+                text: 'comment on table ' +
+                    quoteTableRef(operation.table) +
+                    ' is ' +
+                    quoteLiteral(operation.comment),
+                values: [],
+            });
+        }
+        return statements;
+    }
+    if (operation.kind === 'alterTable') {
+        let sqlStatements = [];
+        for (let change of operation.changes) {
+            let sql = 'alter table ' + quoteTableRef(operation.table) + ' ';
+            if (change.kind === 'addColumn') {
+                sql +=
+                    'add column ' +
+                        quoteIdentifier(change.column) +
+                        ' ' +
+                        compilePostgresColumn(change.definition);
+            }
+            else if (change.kind === 'changeColumn') {
+                let typeSql = compilePostgresColumnType(change.definition);
+                sql += 'alter column ' + quoteIdentifier(change.column) + ' type ' + typeSql;
+            }
+            else if (change.kind === 'renameColumn') {
+                sql += 'rename column ' + quoteIdentifier(change.from) + ' to ' + quoteIdentifier(change.to);
+            }
+            else if (change.kind === 'dropColumn') {
+                sql +=
+                    'drop column ' + (change.ifExists ? 'if exists ' : '') + quoteIdentifier(change.column);
+            }
+            else if (change.kind === 'addPrimaryKey') {
+                sql +=
+                    'add ' +
+                        'constraint ' +
+                        quoteIdentifier(change.constraint.name) +
+                        ' ' +
+                        'primary key (' +
+                        change.constraint.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                        ')';
+            }
+            else if (change.kind === 'dropPrimaryKey') {
+                sql += 'drop constraint ' + quoteIdentifier(change.name);
+            }
+            else if (change.kind === 'addUnique') {
+                sql +=
+                    'add ' +
+                        'constraint ' +
+                        quoteIdentifier(change.constraint.name) +
+                        ' ' +
+                        'unique (' +
+                        change.constraint.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                        ')';
+            }
+            else if (change.kind === 'dropUnique') {
+                sql += 'drop constraint ' + quoteIdentifier(change.name);
+            }
+            else if (change.kind === 'addForeignKey') {
+                sql +=
+                    'add ' +
+                        'constraint ' +
+                        quoteIdentifier(change.constraint.name) +
+                        ' ' +
+                        'foreign key (' +
+                        change.constraint.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                        ') references ' +
+                        quoteTableRef(change.constraint.references.table) +
+                        ' (' +
+                        change.constraint.references.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                        ')';
+            }
+            else if (change.kind === 'dropForeignKey') {
+                sql += 'drop constraint ' + quoteIdentifier(change.name);
+            }
+            else if (change.kind === 'addCheck') {
+                sql +=
+                    'add ' +
+                        'constraint ' +
+                        quoteIdentifier(change.constraint.name) +
+                        ' ' +
+                        'check (' +
+                        change.constraint.expression +
+                        ')';
+            }
+            else if (change.kind === 'dropCheck') {
+                sql += 'drop constraint ' + quoteIdentifier(change.name);
+            }
+            else if (change.kind === 'setTableComment') {
+                sqlStatements.push({
+                    text: 'comment on table ' +
+                        quoteTableRef(operation.table) +
+                        ' is ' +
+                        quoteLiteral(change.comment),
+                    values: [],
+                });
+                continue;
+            }
+            else {
+                continue;
+            }
+            sqlStatements.push({ text: sql, values: [] });
+        }
+        return sqlStatements;
+    }
+    if (operation.kind === 'renameTable') {
+        return [
+            {
+                text: 'alter table ' +
+                    quoteTableRef(operation.from) +
+                    ' rename to ' +
+                    quoteIdentifier(operation.to.name),
+                values: [],
+            },
+        ];
+    }
+    if (operation.kind === 'dropTable') {
+        return [
+            {
+                text: 'drop table ' +
+                    (operation.ifExists ? 'if exists ' : '') +
+                    quoteTableRef(operation.table) +
+                    (operation.cascade ? ' cascade' : ''),
+                values: [],
+            },
+        ];
+    }
+    if (operation.kind === 'createIndex') {
+        return [
+            {
+                text: 'create ' +
+                    (operation.index.unique ? 'unique ' : '') +
+                    'index ' +
+                    (operation.ifNotExists ? 'if not exists ' : '') +
+                    quoteIdentifier(operation.index.name) +
+                    ' on ' +
+                    quoteTableRef(operation.index.table) +
+                    (operation.index.using ? ' using ' + operation.index.using : '') +
+                    ' (' +
+                    operation.index.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                    ')' +
+                    (operation.index.where ? ' where ' + operation.index.where : ''),
+                values: [],
+            },
+        ];
+    }
+    if (operation.kind === 'dropIndex') {
+        return [
+            {
+                text: 'drop index ' +
+                    (operation.ifExists ? 'if exists ' : '') +
+                    quoteIdentifier(operation.name),
+                values: [],
+            },
+        ];
+    }
+    if (operation.kind === 'renameIndex') {
+        return [
+            {
+                text: 'alter index ' +
+                    quoteIdentifier(operation.from) +
+                    ' rename to ' +
+                    quoteIdentifier(operation.to),
+                values: [],
+            },
+        ];
+    }
+    if (operation.kind === 'addForeignKey') {
+        return [
+            {
+                text: 'alter table ' +
+                    quoteTableRef(operation.table) +
+                    ' add ' +
+                    'constraint ' +
+                    quoteIdentifier(operation.constraint.name) +
+                    ' ' +
+                    'foreign key (' +
+                    operation.constraint.columns.map((column) => quoteIdentifier(column)).join(', ') +
+                    ') references ' +
+                    quoteTableRef(operation.constraint.references.table) +
+                    ' (' +
+                    operation.constraint.references.columns
+                        .map((column) => quoteIdentifier(column))
+                        .join(', ') +
+                    ')' +
+                    (operation.constraint.onDelete ? ' on delete ' + operation.constraint.onDelete : '') +
+                    (operation.constraint.onUpdate ? ' on update ' + operation.constraint.onUpdate : ''),
+                values: [],
+            },
+        ];
+    }
+    if (operation.kind === 'dropForeignKey') {
+        return [
+            {
+                text: 'alter table ' +
+                    quoteTableRef(operation.table) +
+                    ' drop constraint ' +
+                    quoteIdentifier(operation.name),
+                values: [],
+            },
+        ];
+    }
+    if (operation.kind === 'addCheck') {
+        return [
+            {
+                text: 'alter table ' +
+                    quoteTableRef(operation.table) +
+                    ' add ' +
+                    'constraint ' +
+                    quoteIdentifier(operation.constraint.name) +
+                    ' ' +
+                    'check (' +
+                    operation.constraint.expression +
+                    ')',
+                values: [],
+            },
+        ];
+    }
+    if (operation.kind === 'dropCheck') {
+        return [
+            {
+                text: 'alter table ' +
+                    quoteTableRef(operation.table) +
+                    ' drop constraint ' +
+                    quoteIdentifier(operation.name),
+                values: [],
+            },
+        ];
+    }
+    throw new Error('Unsupported data migration operation kind');
+}
+function compilePostgresColumn(definition) {
+    let parts = [compilePostgresColumnType(definition)];
+    if (definition.nullable === false) {
+        parts.push('not null');
+    }
+    if (definition.default) {
+        if (definition.default.kind === 'now') {
+            parts.push('default now()');
+        }
+        else if (definition.default.kind === 'sql') {
+            parts.push('default ' + definition.default.expression);
+        }
+        else {
+            parts.push('default ' + quoteLiteral(definition.default.value));
+        }
+    }
+    if (definition.primaryKey) {
+        parts.push('primary key');
+    }
+    if (definition.unique) {
+        parts.push('unique');
+    }
+    if (definition.computed) {
+        if (!definition.computed.stored) {
+            throw new Error('Postgres only supports stored computed/generated columns');
+        }
+        parts.push('generated always as (' + definition.computed.expression + ') stored');
+    }
+    if (definition.references) {
+        let clause = 'references ' +
+            quoteTableRef(definition.references.table) +
+            ' (' +
+            definition.references.columns.map((column) => quoteIdentifier(column)).join(', ') +
+            ')';
+        if (definition.references.onDelete) {
+            clause += ' on delete ' + definition.references.onDelete;
+        }
+        if (definition.references.onUpdate) {
+            clause += ' on update ' + definition.references.onUpdate;
+        }
+        parts.push(clause);
+    }
+    if (definition.checks && definition.checks.length > 0) {
+        for (let check of definition.checks) {
+            parts.push('check (' + check.expression + ')');
+        }
+    }
+    return parts.join(' ');
+}
+function compilePostgresColumnType(definition) {
+    if (definition.type === 'varchar') {
+        return 'varchar(' + String(definition.length ?? 255) + ')';
+    }
+    if (definition.type === 'text') {
+        return 'text';
+    }
+    if (definition.type === 'integer') {
+        return 'integer';
+    }
+    if (definition.type === 'bigint') {
+        return 'bigint';
+    }
+    if (definition.type === 'decimal') {
+        if (definition.precision !== undefined && definition.scale !== undefined) {
+            return 'decimal(' + String(definition.precision) + ', ' + String(definition.scale) + ')';
+        }
+        return 'decimal';
+    }
+    if (definition.type === 'boolean') {
+        return 'boolean';
+    }
+    if (definition.type === 'uuid') {
+        return 'uuid';
+    }
+    if (definition.type === 'date') {
+        return 'date';
+    }
+    if (definition.type === 'time') {
+        return definition.withTimezone ? 'time with time zone' : 'time without time zone';
+    }
+    if (definition.type === 'timestamp') {
+        return definition.withTimezone ? 'timestamp with time zone' : 'timestamp without time zone';
+    }
+    if (definition.type === 'json') {
+        return 'jsonb';
+    }
+    if (definition.type === 'binary') {
+        return 'bytea';
+    }
+    if (definition.type === 'enum') {
+        return 'text';
+    }
+    return 'text';
+}
+function quoteTableRef(table) {
+    return quoteTableRefHelper(table, quoteIdentifier);
+}
+function quoteLiteral(value) {
+    return quoteLiteralHelper(value);
+}