@deterministic-code/datasources-postgres 0.1.0 → 0.1.2

package/dist/PostgresAlterTableStatementRenderer.d.ts

@@ -0,0 +1,6 @@
+import { AlterTableStatementTextRenderer, type AlterAction, type Column } from "@deterministic-code/datasources";
+export declare class PostgresAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    protected typeName(column: Column): string;
+    protected actionSql(action: AlterAction): string;
+    private postgresAlter;
+}

package/dist/PostgresAlterTableStatementRenderer.js

@@ -0,0 +1,20 @@
+import { AlterTableStatementTextRenderer, } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.js";
+export class PostgresAlterTableStatementRenderer extends AlterTableStatementTextRenderer {
+    typeName(column) {
+        return columnTypes[column.type] ?? column.type;
+    }
+    actionSql(action) {
+        return action.kind === "alterColumn" ? this.postgresAlter(action.column) : super.actionSql(action);
+    }
+    postgresAlter(column) {
+        const name = this.quote(column.name);
+        const defaultSql = column.default == null
+            ? `ALTER COLUMN ${name} DROP DEFAULT`
+            : `ALTER COLUMN ${name} SET DEFAULT ${column.default.value}`;
+        const nullSql = column.notNull == null
+            ? `ALTER COLUMN ${name} DROP NOT NULL`
+            : `ALTER COLUMN ${name} SET NOT NULL`;
+        return `ALTER COLUMN ${name} TYPE ${this.typeName(column)}, ${defaultSql}, ${nullSql}`;
+    }
+}

package/dist/PostgresBulkUpdateStatementTextRenderer.d.ts

@@ -0,0 +1,4 @@
+import { BulkUpdateStatementTextRenderer, type Cell } from "@deterministic-code/datasources";
+export declare class PostgresBulkUpdateStatementTextRenderer extends BulkUpdateStatementTextRenderer {
+    protected cell: (column: string, index: number, value: Cell) => string;
+}

package/dist/PostgresBulkUpdateStatementTextRenderer.js

@@ -0,0 +1,24 @@
+import { BulkUpdateStatementTextRenderer } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.js";
+import { isBase64 } from "./converters/BinaryConverter.js";
+import { isIsoDate } from "./converters/DateTimeConverter.js";
+const logical = (value) => value === null
+    ? undefined
+    : typeof value === "boolean"
+        ? "bool"
+        : typeof value === "bigint" || (typeof value === "number" && Number.isInteger(value))
+            ? "int"
+            : typeof value === "number"
+                ? "float"
+                : value instanceof Date || (typeof value === "string" && isIsoDate(value))
+                    ? "datetime"
+                    : value instanceof Uint8Array || (typeof value === "string" && isBase64(value))
+                        ? "binary"
+                        : "string";
+export class PostgresBulkUpdateStatementTextRenderer extends BulkUpdateStatementTextRenderer {
+    cell = (column, index, value) => {
+        const type = logical(value);
+        const sql = type ? columnTypes[type] : undefined;
+        return sql ? `$${column}__${index}::${sql} AS ${column}` : `$${column}__${index} AS ${column}`;
+    };
+}

package/dist/PostgresCreateRoutineStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { CreateRoutineStatementTextRenderer, type CreateRoutineStatement } from "@datasources/core";
+export declare class PostgresCreateRoutineStatementRenderer extends CreateRoutineStatementTextRenderer {
+    render(statement: CreateRoutineStatement): string;
+}

package/dist/PostgresCreateTableStatementRenderer.d.ts

@@ -0,0 +1,6 @@
+import { CreateTableStatementTextRenderer, type Column } from "@deterministic-code/datasources";
+export declare class PostgresCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    protected typeName(column: Column): string;
+    protected columnDefault(column: Column): string;
+    protected identity(column: Column): string;
+}

package/dist/PostgresCreateTableStatementRenderer.js

@@ -0,0 +1,26 @@
+import { ColumnDefault, CreateTableStatementTextRenderer, } from "@deterministic-code/datasources";
+import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.js";
+import { columnTypes } from "./columnTypes.js";
+export class PostgresCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+    typeName(column) {
+        return columnTypes[column.type] ?? column.type;
+    }
+    columnDefault(column) {
+        const literal = sqlLiteral(column);
+        const value = column.default;
+        return value == null || literal == null
+            ? super.columnDefault(column)
+            : super.columnDefault({ ...column, default: new ColumnDefault(literal, value.name) });
+    }
+    identity(column) {
+        return column.identity ? " GENERATED BY DEFAULT AS IDENTITY" : "";
+    }
+}
+function sqlLiteral(column) {
+    const raw = column.default?.value;
+    const converter = PostgresRowTypeConverters[column.type];
+    if (raw == null || !converter || !/^-?\d+$/.test(raw))
+        return undefined;
+    const converted = converter.convert(Number(raw));
+    return converted === true ? "TRUE" : converted === false ? "FALSE" : undefined;
+}

package/dist/PostgresCreateTriggerStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { CreateTriggerStatementTextRenderer, type CreateTriggerStatement } from "@deterministic-code/datasources";
+export declare class PostgresCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
+    render(statement: CreateTriggerStatement): string;
+}

package/dist/PostgresCreateTriggerStatementRenderer.js

@@ -0,0 +1,13 @@
+import { CreateTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+export class PostgresCreateTriggerStatementRenderer extends CreateTriggerStatementTextRenderer {
+    render(statement) {
+        return `-- Shared updated_at function
+CREATE OR REPLACE FUNCTION set_updated_at() RETURNS TRIGGER AS $$
+BEGIN
+  NEW.${statement.updatedColumn} = NOW() AT TIME ZONE 'UTC';
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+CREATE TRIGGER ${statement.name} BEFORE UPDATE ON ${statement.table} FOR EACH ROW EXECUTE FUNCTION set_updated_at()`;
+    }
+}

package/dist/PostgresDriver.d.ts

@@ -0,0 +1,16 @@
+import { DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.js";
+export { columnTypes };
+export declare class PostgresDriver implements IDriver {
+    readonly statementRenderer: StatementTextRenderer;
+    readonly information: Information;
+    rowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+    readonly quoteLeft = "\"";
+    readonly quoteRight = "\"";
+    readonly typeConverter: DeterministicTypeConverter;
+    readonly defaultValueConverter: DefaultValueConverter;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/PostgresDriver.js

@@ -0,0 +1,75 @@
+import { DatasourceError, DefaultValueConverter, DeterministicTypeConverter, StatementTextRenderer, } from "@deterministic-code/datasources";
+import { PostgresConnection } from "./connection.js";
+import { PostgresCommand } from "./command.js";
+import { PostgresTransaction } from "./transaction.js";
+import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.js";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.js";
+import { columnTypes } from "./columnTypes.js";
+export { columnTypes };
+const statements = new StatementTextRenderer(t => new PostgresStatementRenderer(t));
+export class PostgresDriver {
+    statementRenderer = statements;
+    information = {
+        descriptions: [
+            "PostgreSQL server driver.",
+            "Full connection, command, transaction, and repository support.",
+        ],
+        overrides: [
+            "Overrides SelectInsertedIdStatement to SELECT lastval() AS {column}",
+            "Overrides CreateTableStatement identity to GENERATED BY DEFAULT AS IDENTITY",
+            "Overrides CreateTableStatement boolean defaults (0/1 → TRUE/FALSE)",
+            "Overrides CreateTableStatement type mapping (int→INTEGER, uuid→UUID, string→TEXT, bool→BOOLEAN, decimal→NUMERIC, float→DOUBLE PRECISION, datetime→TIMESTAMPTZ, binary→BYTEA)",
+            "Overrides CreateCreateStoredProcedureStatement to PROCEDURE Create{Plural}",
+            "Overrides CreateReadStoredProcedureStatement to PROCEDURE Read{Plural}By{Properties}",
+            "Overrides CreateUpdateStoredProcedureStatement to PROCEDURE Update{Plural}By{Properties}",
+            "Overrides CreateDeleteStoredProcedureStatement to PROCEDURE Delete{Plural}By{Properties}",
+            "Overrides CreateBulkCreateStoredProcedureStatement to PROCEDURE BulkCreate{Plural}",
+            "Overrides CreateBulkUpdateStoredProcedureStatement to PROCEDURE BulkUpdate{Plural}",
+            "Overrides CreateBulkDeleteStoredProcedureStatement to PROCEDURE BulkDelete{Plural}",
+        ],
+        changeLogs: [],
+    };
+    rowTypeConverters = PostgresRowTypeConverters;
+    quoteLeft = '"';
+    quoteRight = '"';
+    typeConverter = new DeterministicTypeConverter({
+        string: "TEXT",
+        character: "CHAR(1)",
+        number: "INTEGER",
+        integer: "INTEGER",
+        unsignedinteger: "BIGINT",
+        smallinteger: "SMALLINT",
+        unsignedsmallinteger: "INTEGER",
+        biginteger: "BIGINT",
+        unsignedbiginteger: "NUMERIC(20)",
+        float: "DOUBLE PRECISION",
+        decimal: "NUMERIC",
+        boolean: "BOOLEAN",
+        datetime: "TIMESTAMPTZ",
+        binary: "BYTEA",
+        uuid: "UUID",
+        reference: "INTEGER",
+    }, {
+        dialectName: "postgres",
+        stringUnlimited: "TEXT",
+        stringSized: (n) => `VARCHAR(${n})`,
+        character: "CHAR",
+        decimal: { kind: "optional", type: "NUMERIC", fallback: "NUMERIC" },
+    });
+    defaultValueConverter = new DefaultValueConverter({
+        newId: () => "gen_random_uuid()",
+        now: () => "LOCALTIMESTAMP",
+        utcNow: () => `(NOW() AT TIME ZONE 'UTC')`,
+        booleanOn: "TRUE",
+        booleanOff: "FALSE",
+        hex: (arg) => `'\\x${arg}'`,
+        hexReverse: /^'\\x(.*)'$/,
+    });
+    columnType = (name) => columnTypes[name] ??
+        (() => {
+            throw new DatasourceError(`Unknown postgres type "${name}"`);
+        })();
+    connection = (options) => PostgresConnection.from(options);
+    command = (connection) => new PostgresCommand(connection, statements);
+    transaction = (connection, isolation = "readCommitted") => new PostgresTransaction(connection, isolation);
+}

package/dist/PostgresDropRoutineStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { DropRoutineStatementTextRenderer, type DropRoutineStatement } from "@deterministic-code/datasources";
+export declare class PostgresDropRoutineStatementRenderer extends DropRoutineStatementTextRenderer {
+    render(statement: DropRoutineStatement): string;
+}

package/dist/PostgresDropRoutineStatementRenderer.js

@@ -0,0 +1,6 @@
+import { DropRoutineStatementTextRenderer } from "@deterministic-code/datasources";
+export class PostgresDropRoutineStatementRenderer extends DropRoutineStatementTextRenderer {
+    render(statement) {
+        return `DROP FUNCTION IF EXISTS ${statement.name}`;
+    }
+}

package/dist/PostgresDropTriggerStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { DropTriggerStatementTextRenderer, type DropTriggerStatement } from "@deterministic-code/datasources";
+export declare class PostgresDropTriggerStatementRenderer extends DropTriggerStatementTextRenderer {
+    render(statement: DropTriggerStatement): string;
+}

package/dist/PostgresDropTriggerStatementRenderer.js

@@ -0,0 +1,6 @@
+import { DropTriggerStatementTextRenderer } from "@deterministic-code/datasources";
+export class PostgresDropTriggerStatementRenderer extends DropTriggerStatementTextRenderer {
+    render(statement) {
+        return `DROP TRIGGER IF EXISTS ${statement.name} ON ${statement.table}`;
+    }
+}

package/dist/PostgresIdentityInsertStatementRenderer.d.ts

@@ -0,0 +1,4 @@
+import { IdentityInsertStatementTextRenderer, type IdentityInsertStatement } from "@deterministic-code/datasources";
+export declare class PostgresIdentityInsertStatementRenderer extends IdentityInsertStatementTextRenderer {
+    render(statement: IdentityInsertStatement): string;
+}

package/dist/PostgresIdentityInsertStatementRenderer.js

@@ -0,0 +1,11 @@
+import { IdentityInsertStatementTextRenderer, } from "@deterministic-code/datasources";
+export class PostgresIdentityInsertStatementRenderer extends IdentityInsertStatementTextRenderer {
+    render(statement) {
+        const inserts = super.render(statement);
+        if (!statement.identity || statement.inserts.length === 0)
+            return inserts;
+        const quoted = statement.inserts[0].table;
+        return `${inserts}
+SELECT setval(pg_get_serial_sequence('${statement.table}', '${statement.idColumn}'), (SELECT MAX("${statement.idColumn}") FROM ${quoted}))`;
+    }
+}

package/dist/PostgresStatementRenderer.d.ts

@@ -0,0 +1,19 @@
+import { AlterTableStatement, BulkUpdateStatement, CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateTableStatement, CreateTriggerStatement, CreateUpdateStoredProcedureStatement, DropRoutineStatement, DropTriggerStatement, IdentityInsertStatement, SelectInsertedIdStatement, StatementRenderer, type StatementTextRenderer } from "@deterministic-code/datasources";
+export declare class PostgresStatementRenderer extends StatementRenderer {
+    constructor(text: StatementTextRenderer);
+    protected visitSelectInsertedId(inserted: SelectInsertedIdStatement): string;
+    protected visitCreateTable(create: CreateTableStatement): string;
+    protected visitAlterTable(alter: AlterTableStatement): string;
+    protected visitDropTrigger(trigger: DropTriggerStatement): string;
+    protected visitBulkUpdate(update: BulkUpdateStatement): string;
+    protected visitCreateTrigger(trigger: CreateTriggerStatement): string;
+    protected visitIdentityInsert(insert: IdentityInsertStatement): string;
+    protected visitDropRoutine(routine: DropRoutineStatement): string;
+    protected visitCreateCreateStoredProcedureStatement(statement: CreateCreateStoredProcedureStatement): string;
+    protected visitCreateReadStoredProcedureStatement(statement: CreateReadStoredProcedureStatement): string;
+    protected visitCreateUpdateStoredProcedureStatement(statement: CreateUpdateStoredProcedureStatement): string;
+    protected visitCreateDeleteStoredProcedureStatement(statement: CreateDeleteStoredProcedureStatement): string;
+    protected visitCreateBulkCreateStoredProcedureStatement(statement: CreateBulkCreateStoredProcedureStatement): string;
+    protected visitCreateBulkUpdateStoredProcedureStatement(statement: CreateBulkUpdateStoredProcedureStatement): string;
+    protected visitCreateBulkDeleteStoredProcedureStatement(statement: CreateBulkDeleteStoredProcedureStatement): string;
+}

package/dist/PostgresStatementRenderer.js

@@ -0,0 +1,64 @@
+import { SelectInsertedIdStatementTextRenderer, StatementRenderer, } from "@deterministic-code/datasources";
+import { PostgresAlterTableStatementRenderer } from "./PostgresAlterTableStatementRenderer.js";
+import { PostgresBulkUpdateStatementTextRenderer } from "./PostgresBulkUpdateStatementTextRenderer.js";
+import { PostgresCreateTableStatementRenderer } from "./PostgresCreateTableStatementRenderer.js";
+import { PostgresCreateTriggerStatementRenderer } from "./PostgresCreateTriggerStatementRenderer.js";
+import { PostgresDropRoutineStatementRenderer } from "./PostgresDropRoutineStatementRenderer.js";
+import { PostgresStoredProcedureStatementRenderer } from "./PostgresStoredProcedureStatementRenderer.js";
+import { PostgresDropTriggerStatementRenderer } from "./PostgresDropTriggerStatementRenderer.js";
+import { PostgresIdentityInsertStatementRenderer } from "./PostgresIdentityInsertStatementRenderer.js";
+class PostgresSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
+    render(statement) {
+        return `SELECT lastval() AS ${statement.column}`;
+    }
+}
+export class PostgresStatementRenderer extends StatementRenderer {
+    constructor(text) {
+        super(text);
+    }
+    visitSelectInsertedId(inserted) {
+        return new PostgresSelectInsertedIdStatementTextRenderer().render(inserted);
+    }
+    visitCreateTable(create) {
+        return new PostgresCreateTableStatementRenderer().render(create);
+    }
+    visitAlterTable(alter) {
+        return new PostgresAlterTableStatementRenderer().renderAlter(alter);
+    }
+    visitDropTrigger(trigger) {
+        return new PostgresDropTriggerStatementRenderer().render(trigger);
+    }
+    visitBulkUpdate(update) {
+        return new PostgresBulkUpdateStatementTextRenderer().render(update);
+    }
+    visitCreateTrigger(trigger) {
+        return new PostgresCreateTriggerStatementRenderer().render(trigger);
+    }
+    visitIdentityInsert(insert) {
+        return new PostgresIdentityInsertStatementRenderer().render(insert);
+    }
+    visitDropRoutine(routine) {
+        return new PostgresDropRoutineStatementRenderer().render(routine);
+    }
+    visitCreateCreateStoredProcedureStatement(statement) {
+        return new PostgresStoredProcedureStatementRenderer().renderCreate(statement);
+    }
+    visitCreateReadStoredProcedureStatement(statement) {
+        return new PostgresStoredProcedureStatementRenderer().renderRead(statement);
+    }
+    visitCreateUpdateStoredProcedureStatement(statement) {
+        return new PostgresStoredProcedureStatementRenderer().renderUpdate(statement);
+    }
+    visitCreateDeleteStoredProcedureStatement(statement) {
+        return new PostgresStoredProcedureStatementRenderer().renderDelete(statement);
+    }
+    visitCreateBulkCreateStoredProcedureStatement(statement) {
+        return new PostgresStoredProcedureStatementRenderer().renderBulkCreate(statement);
+    }
+    visitCreateBulkUpdateStoredProcedureStatement(statement) {
+        return new PostgresStoredProcedureStatementRenderer().renderBulkUpdate(statement);
+    }
+    visitCreateBulkDeleteStoredProcedureStatement(statement) {
+        return new PostgresStoredProcedureStatementRenderer().renderBulkDelete(statement);
+    }
+}

package/dist/PostgresStoredProcedureStatementRenderer.d.ts

@@ -0,0 +1,10 @@
+import type { CreateBulkCreateStoredProcedureStatement, CreateBulkDeleteStoredProcedureStatement, CreateBulkUpdateStoredProcedureStatement, CreateCreateStoredProcedureStatement, CreateDeleteStoredProcedureStatement, CreateReadStoredProcedureStatement, CreateUpdateStoredProcedureStatement } from "@deterministic-code/datasources";
+export declare class PostgresStoredProcedureStatementRenderer {
+    renderCreate(statement: CreateCreateStoredProcedureStatement): string;
+    renderRead(statement: CreateReadStoredProcedureStatement): string;
+    renderUpdate(statement: CreateUpdateStoredProcedureStatement): string;
+    renderDelete(statement: CreateDeleteStoredProcedureStatement): string;
+    renderBulkCreate(statement: CreateBulkCreateStoredProcedureStatement): string;
+    renderBulkUpdate(statement: CreateBulkUpdateStoredProcedureStatement): string;
+    renderBulkDelete(statement: CreateBulkDeleteStoredProcedureStatement): string;
+}

package/dist/PostgresStoredProcedureStatementRenderer.js

@@ -0,0 +1,111 @@
+const params = (list) => list.map((p) => `  ${p.name} ${p.type}`).join(",\n");
+const recordset = (columns) => columns.map((c) => `${c.name} ${c.type}`).join(", ");
+export class PostgresStoredProcedureStatementRenderer {
+    renderCreate(statement) {
+        return `CREATE OR REPLACE FUNCTION ${statement.name}(
+${params(statement.parameters)}
+) RETURNS ${statement.keyType} LANGUAGE plpgsql AS $$
+DECLARE
+  new_id ${statement.keyType};
+BEGIN
+  INSERT INTO ${statement.table} (${statement.parameters.map((p) => p.name).join(", ")})
+  VALUES (${statement.parameters.map((p) => p.name).join(", ")})
+  RETURNING ${statement.key} INTO new_id;
+  RETURN new_id;
+END;
+$$`;
+    }
+    renderRead(statement) {
+        const aliased = statement.columns.map((c) => `t.${c}`).join(", ");
+        if (statement.byProperties.length === 0) {
+            return `CREATE OR REPLACE FUNCTION ${statement.name}() RETURNS SETOF ${statement.table}
+LANGUAGE sql AS $$ SELECT ${aliased} FROM ${statement.table} t ORDER BY t.${statement.key}; $$`;
+        }
+        const signature = statement.byProperties
+            .map((c) => `${c} ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .join(", ");
+        const pred = statement.byProperties
+            .map((c) => `t.${c} = ${statement.name}.${c}`)
+            .join(" AND ");
+        return `CREATE OR REPLACE FUNCTION ${statement.name}(${signature}) RETURNS SETOF ${statement.table}
+LANGUAGE sql AS $$ SELECT ${aliased} FROM ${statement.table} t WHERE ${pred}; $$`;
+    }
+    renderUpdate(statement) {
+        const sets = statement.writable.map((c) => `    ${c} = ${statement.name}.${c}`);
+        if (statement.auditUpdated !== undefined) {
+            const auditParam = statement.parameters.find((p) => p.name.includes("new_updated"));
+            if (auditParam)
+                sets.push(`    ${statement.auditUpdated} = ${statement.name}.${auditParam.name}`);
+        }
+        const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
+        const pred = by.map((c) => `t.${c} = ${statement.name}.${c}`).join(" AND ");
+        return `CREATE OR REPLACE FUNCTION ${statement.name}(
+${params(statement.parameters)}
+) RETURNS INT LANGUAGE plpgsql AS $$
+DECLARE
+  affected INT;
+BEGIN
+  UPDATE ${statement.table} t
+  SET
+${sets.join(",\n")}
+  WHERE ${pred};
+  GET DIAGNOSTICS affected = ROW_COUNT;
+  RETURN affected;
+END;
+$$`;
+    }
+    renderDelete(statement) {
+        const by = statement.byProperties.length > 0 ? statement.byProperties : [statement.key];
+        const signature = by
+            .map((c) => `${c} ${statement.parameters.find((p) => p.name === c)?.type ?? statement.keyType}`)
+            .join(", ");
+        const pred = by.map((c) => `t.${c} = ${statement.name}.${c}`).join(" AND ");
+        return `CREATE OR REPLACE FUNCTION ${statement.name}(${signature}) RETURNS INT LANGUAGE plpgsql AS $$
+DECLARE
+  affected INT;
+BEGIN
+  DELETE FROM ${statement.table} t WHERE ${pred};
+  GET DIAGNOSTICS affected = ROW_COUNT;
+  RETURN affected;
+END;
+$$`;
+    }
+    renderBulkCreate(statement) {
+        const cols = statement.columns.map((c) => c.name).join(", ");
+        return `CREATE OR REPLACE PROCEDURE ${statement.name}(${statement.payload.name} jsonb, INOUT ids jsonb DEFAULT NULL)
+LANGUAGE plpgsql AS $$
+BEGIN
+  WITH inserted AS (
+    INSERT INTO ${statement.table} (${cols})
+    SELECT ${cols}
+    FROM jsonb_to_recordset(${statement.payload.name}) AS x(${recordset(statement.columns)})
+    RETURNING ${statement.key}
+  )
+  SELECT COALESCE(jsonb_agg(${statement.key}), '[]'::jsonb) INTO ids FROM inserted;
+END;
+$$`;
+    }
+    renderBulkUpdate(statement) {
+        const sets = statement.columns
+            .filter((c) => c.name !== statement.key)
+            .map((c) => `${c.name} = x.${c.name}`)
+            .join(", ");
+        return `CREATE OR REPLACE PROCEDURE ${statement.name}(${statement.payload.name} jsonb)
+LANGUAGE plpgsql AS $$
+BEGIN
+  UPDATE ${statement.table} t SET
+    ${sets}
+  FROM jsonb_to_recordset(${statement.payload.name}) AS x(${recordset(statement.columns)})
+  WHERE t.${statement.key} = x.${statement.key};
+END;
+$$`;
+    }
+    renderBulkDelete(statement) {
+        return `CREATE OR REPLACE PROCEDURE ${statement.name}(${statement.payload.name} jsonb)
+LANGUAGE plpgsql AS $$
+BEGIN
+  DELETE FROM ${statement.table} WHERE ${statement.key} IN (SELECT ${statement.key} FROM jsonb_to_recordset(${statement.payload.name}) AS x(${statement.key} ${statement.keyType}));
+END;
+$$`;
+    }
+}

package/dist/bind.d.ts

@@ -0,0 +1,7 @@
+import { type Parameter } from "@deterministic-code/datasources";
+import type { Scalar, Wire } from "./scalar.js";
+export declare const toPostgres: (sql: string, params?: Record<string, Scalar>) => {
+    text: string;
+    values: Wire[];
+};
+export declare const bindParameters: (parameters?: Parameter[] | null) => Record<string, Scalar>;

package/dist/bind.js

@@ -0,0 +1,35 @@
+import { parametersToRecord } from "@deterministic-code/datasources";
+import { isBase64 } from "./converters/BinaryConverter.js";
+import { isIsoDate } from "./converters/DateTimeConverter.js";
+import { reverse } from "./converters/PostgresRowTypeConverters.js";
+const NAME = /\$([A-Za-z_][A-Za-z0-9_]*)/g;
+const quoteMixedCase = (sql) => sql.replace(/\$[A-Za-z_][A-Za-z0-9_]*|'[^']*'|"[^"]*"|`[^`]*`|\b[A-Za-z_][A-Za-z0-9_]*\b/g, (token) => token.startsWith("$") || token.startsWith("'") || token.startsWith("\"") || token.startsWith("`")
+    || !/[A-Z]/.test(token) || !/[a-z]/.test(token)
+    ? token
+    : `"${token}"`);
+const wire = (value) => typeof value !== "string"
+    ? value
+    : isIsoDate(value)
+        ? new Date(value)
+        : isBase64(value)
+            ? Uint8Array.from(Buffer.from(value, "base64"))
+            : value;
+export const toPostgres = (sql, params) => {
+    const names = [];
+    const text = quoteMixedCase(sql).replace(NAME, (_match, name) => {
+        let index = names.indexOf(name);
+        if (index < 0) {
+            names.push(name);
+            index = names.length - 1;
+        }
+        return `$${index + 1}`;
+    });
+    return { text, values: names.map((name) => wire(params?.[name] ?? null)) };
+};
+export const bindParameters = (parameters) => {
+    const record = parametersToRecord(parameters);
+    const bound = {};
+    for (const [name, value] of Object.entries(record))
+        bound[name] = reverse(value);
+    return bound;
+};

package/dist/columnTypes.d.ts

@@ -0,0 +1 @@
+export declare const columnTypes: Record<string, string>;

package/dist/columnTypes.js

@@ -0,0 +1,10 @@
+export const columnTypes = {
+    int: "INTEGER",
+    uuid: "UUID",
+    string: "TEXT",
+    bool: "BOOLEAN",
+    decimal: "NUMERIC",
+    float: "DOUBLE PRECISION",
+    datetime: "TIMESTAMPTZ",
+    binary: "BYTEA",
+};

package/dist/command.d.ts

@@ -0,0 +1,14 @@
+import { CommandMiddlewareHost, Native, StatementTextRenderer, Response, type Cells, type ICommand, type IReader, type IStatement, type Parameter } from "@deterministic-code/datasources";
+import type { PostgresConnection } from "./connection.js";
+export declare class PostgresCommand extends CommandMiddlewareHost implements ICommand {
+    readonly connection: PostgresConnection;
+    private readonly statements;
+    constructor(connection: PostgresConnection, statements?: StatementTextRenderer);
+    executeReaderNative(text: Native, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeReaderStatement(statement: IStatement, parameters?: Parameter[]): Promise<IReader<Cells>>;
+    executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response>;
+    private firstCell;
+    executeNative(text: Native, parameters?: Parameter[]): Promise<Response>;
+    private runSql;
+    private query;
+}

package/dist/command.js

@@ -0,0 +1,92 @@
+import { ArrayReader, CommandMiddlewareHost, FirstResultReader, DatasourceError, Native, ParameterDirection, ReturnStatement, SelectStatement, StatementTextRenderer, Response, splitStatements, statementParameters, statementReader, } from "@deterministic-code/datasources";
+import { bindParameters, toPostgres } from "./bind.js";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.js";
+export class PostgresCommand extends CommandMiddlewareHost {
+    connection;
+    statements;
+    constructor(connection, statements) {
+        super();
+        this.connection = connection;
+        this.statements = statements ?? new StatementTextRenderer(t => new PostgresStatementRenderer(t));
+    }
+    async executeReaderNative(text, parameters) {
+        return this.run(text.text, parameters, async (query, params) => {
+            if (!query.trim())
+                return { value: new ArrayReader([]), rows: [] };
+            this.connection.ensureOpen();
+            const statements = splitStatements(query);
+            if (statements.length === 0)
+                return { value: new ArrayReader([]), rows: [] };
+            const bound = bindParameters(params);
+            return FirstResultReader.capture(statementReader(statements, (sql) => this.query(sql, bound)));
+        });
+    }
+    async executeReaderStatement(statement, parameters) {
+        return this.executeReaderNative(new Native(this.statements.render(statement)), parameters);
+    }
+    async executeStatement(statement, parameters) {
+        return statement instanceof SelectStatement || statement instanceof ReturnStatement
+            ? this.firstCell(statement, parameters)
+            : this.executeNative(new Native(this.statements.render(statement)), parameters);
+    }
+    async firstCell(statement, parameters) {
+        const reader = await this.executeReaderStatement(statement, parameters);
+        try {
+            if (!(await reader.next()))
+                return new Response(null, 0, parameters);
+            const row = reader.current;
+            /* v8 ignore next */
+            if (!row)
+                throw new DatasourceError("Reader current must be a row");
+            const values = Object.values(row);
+            return new Response(values.length === 0 ? null : values[0], 1, parameters);
+        }
+        finally {
+            await reader.dispose();
+        }
+    }
+    async executeNative(text, parameters) {
+        return this.run(text.text, parameters, async (query, params) => {
+            if (!query.trim())
+                return { value: new Response(undefined, 0, params), rows: [] };
+            this.connection.ensureOpen();
+            const named = bindParameters(params);
+            let rowsAffected = 0;
+            let parameters = params;
+            for (const part of splitStatements(query)) {
+                const names = new Set(statementParameters(part));
+                const used = Object.fromEntries(Object.entries(named).filter(([name]) => names.has(name.replace(/^[$:@]/, ""))));
+                const result = await this.runSql(part, used, params);
+                rowsAffected += result.rowsAffected;
+                parameters = result.parameters ?? params;
+            }
+            return {
+                value: new Response(null, rowsAffected, parameters),
+                rows: [],
+            };
+        });
+    }
+    async runSql(sql, params, parameters) {
+        const { text, values } = toPostgres(sql, params);
+        const queried = await this.connection.require().query(text, values);
+        const row = queried.rows[0];
+        return {
+            rowsAffected: queried.rowCount ?? queried.rows.length,
+            result: null,
+            parameters: parameters?.map((parameter) => {
+                if (!parameter.direction || parameter.direction === ParameterDirection.Input || !row)
+                    return parameter;
+                const cells = row;
+                const cell = cells[parameter.name] ?? cells[parameter.name.toLowerCase()];
+                if (cell === undefined)
+                    return parameter;
+                return { ...parameter, value: cellValue(cell) };
+            }),
+        };
+    }
+    query(sql, params) {
+        const { text, values } = toPostgres(sql, params);
+        return this.connection.require().rows(text, values);
+    }
+}
+const cellValue = (cell) => cell !== null && typeof cell === "object" ? JSON.stringify(cell) : cell;

package/dist/connection-options.d.ts

@@ -0,0 +1,6 @@
+import type { PgClientCtor } from "./i-postgres-driver.js";
+export interface PostgresConnectionOptions {
+    url?: string;
+    schema?: string;
+    Client?: PgClientCtor;
+}