@deterministic-code/datasources-postgres 0.0.0-stage → 0.1.0

package/package.json

@@ -1,6 +1,23 @@
 {
   "name": "@deterministic-code/datasources-postgres",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@deterministic-code/datasources": "^0.1.0",
+    "@types/pg": "^8.15.5",
+    "pg": "^8.16.0",
+    "pg-query-stream": "^4.17.0"
+  }
+}

package/src/PostgresBulkUpdateStatementTextRenderer.ts

@@ -0,0 +1,27 @@
+import { BulkUpdateStatementTextRenderer, type Cell } from "@deterministic-code/datasources";
+import { columnTypes } from "./columnTypes.ts";
+import { isBase64 } from "./converters/BinaryConverter.ts";
+import { isIsoDate } from "./converters/DateTimeConverter.ts";
+
+const logical = (value: Cell): string | undefined =>
+  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 {
+  protected override cell = (column: string, index: number, value: Cell): string => {
+    const type = logical(value);
+    const sql = type ? columnTypes[type] : undefined;
+    return sql ? `$${column}__${index}::${sql} AS ${column}` : `$${column}__${index} AS ${column}`;
+  };
+}

package/src/PostgresCreateTableStatementRenderer.ts

@@ -0,0 +1,33 @@
+import {
+  ColumnDefault,
+  CreateTableStatementTextRenderer,
+  type Column,
+} from "@deterministic-code/datasources";
+import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.ts";
+import { columnTypes } from "./columnTypes.ts";
+
+export class PostgresCreateTableStatementRenderer extends CreateTableStatementTextRenderer {
+  protected typeName(column: Column): string {
+    return columnTypes[column.type] ?? column.type;
+  }
+
+  protected columnDefault(column: Column): string {
+    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) });
+  }
+
+  protected identity(column: Column): string {
+    return column.identity ? " GENERATED BY DEFAULT AS IDENTITY" : "";
+  }
+}
+
+function sqlLiteral(column: Column): string | undefined {
+  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/src/PostgresDriver.ts

@@ -0,0 +1,55 @@
+import {
+  DatasourceError,
+  StatementTextRenderer,
+  type Cell,
+  type DatasourceOptions,
+  type ICommand,
+  type IConnection,
+  type IDriver,
+  type Information,
+  type ITransaction,
+  type IsolationLevel,
+  type TypeConverter,
+} from "@deterministic-code/datasources";
+import { PostgresConnection } from "./connection.ts";
+import { PostgresCommand } from "./command.ts";
+import { PostgresTransaction } from "./transaction.ts";
+import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.ts";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.ts";
+import { columnTypes } from "./columnTypes.ts";
+
+export { columnTypes };
+
+const statements = new StatementTextRenderer(t => new PostgresStatementRenderer(t));
+
+export class PostgresDriver implements IDriver {
+  readonly statementRenderer = statements;
+  readonly information: 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)",
+    ],
+    changeLogs: [],
+  };
+  rowTypeConverters: Record<string, TypeConverter<Cell, Cell>> = PostgresRowTypeConverters;
+  columnType = (name: string): string =>
+    columnTypes[name] ??
+    (() => {
+      throw new DatasourceError(`Unknown postgres type "${name}"`);
+    })();
+  connection = (options?: DatasourceOptions): IConnection =>
+    PostgresConnection.from(options);
+  command = (connection: IConnection): ICommand =>
+    new PostgresCommand(connection as PostgresConnection, statements);
+  transaction = (
+    connection: IConnection,
+    isolation: IsolationLevel = "readCommitted",
+  ): ITransaction =>
+    new PostgresTransaction(connection as PostgresConnection, isolation);
+}

package/src/PostgresStatementRenderer.ts

@@ -0,0 +1,34 @@
+import {
+  BulkUpdateStatement,
+  CreateTableStatement,
+  SelectInsertedIdStatement,
+  SelectInsertedIdStatementTextRenderer,
+  StatementRenderer,
+  type StatementTextRenderer,
+} from "@deterministic-code/datasources";
+import { PostgresBulkUpdateStatementTextRenderer } from "./PostgresBulkUpdateStatementTextRenderer.ts";
+import { PostgresCreateTableStatementRenderer } from "./PostgresCreateTableStatementRenderer.ts";
+
+class PostgresSelectInsertedIdStatementTextRenderer extends SelectInsertedIdStatementTextRenderer {
+  override render(statement: SelectInsertedIdStatement): string {
+    return `SELECT lastval() AS ${statement.column}`;
+  }
+}
+
+export class PostgresStatementRenderer extends StatementRenderer {
+  constructor(text: StatementTextRenderer) {
+    super(text);
+  }
+
+  protected override visitSelectInsertedId(inserted: SelectInsertedIdStatement): string {
+    return new PostgresSelectInsertedIdStatementTextRenderer().render(inserted);
+  }
+
+  protected override visitCreateTable(create: CreateTableStatement): string {
+    return new PostgresCreateTableStatementRenderer().render(create);
+  }
+
+  protected override visitBulkUpdate(update: BulkUpdateStatement): string {
+    return new PostgresBulkUpdateStatementTextRenderer().render(update);
+  }
+}

package/src/bind.ts

@@ -0,0 +1,50 @@
+import { parametersToRecord, type Cell, type Parameter } from "@deterministic-code/datasources";
+import { isBase64 } from "./converters/BinaryConverter.ts";
+import { isIsoDate } from "./converters/DateTimeConverter.ts";
+import { reverse } from "./converters/PostgresRowTypeConverters.ts";
+import type { Scalar, Wire } from "./scalar.ts";
+
+const NAME = /\$([A-Za-z_][A-Za-z0-9_]*)/g;
+
+const quoteMixedCase = (sql: string): string =>
+  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: Scalar): Wire =>
+  typeof value !== "string"
+    ? value
+    : isIsoDate(value)
+      ? new Date(value)
+      : isBase64(value)
+        ? Uint8Array.from(Buffer.from(value, "base64"))
+        : value;
+
+export const toPostgres = (
+  sql: string,
+  params?: Record<string, Scalar>,
+): { text: string; values: Wire[] } => {
+  const names: string[] = [];
+  const text = quoteMixedCase(sql).replace(NAME, (_match, name: string) => {
+    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?: Parameter[] | null,
+): Record<string, Scalar> => {
+  const record = parametersToRecord(parameters);
+  const bound: Record<string, Scalar> = {};
+  for (const [name, value] of Object.entries(record))
+    bound[name] = reverse(value as Cell) as Scalar;
+  return bound;
+};

package/src/columnTypes.ts

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

package/src/command.ts

@@ -0,0 +1,129 @@
+import {
+  ArrayReader,
+  CommandMiddlewareHost,
+  FirstResultReader,
+  DatasourceError,
+  Native,
+  ParameterDirection,
+  ReturnStatement,
+  SelectStatement,
+  StatementTextRenderer,
+  Response,
+  splitStatements,
+  statementParameters,
+  statementReader,
+  type Cells,
+  type ICommand,
+  type IReader,
+  type IStatement,
+  type Parameter,
+} from "@deterministic-code/datasources";
+import { bindParameters, toPostgres } from "./bind.ts";
+import type { PostgresConnection } from "./connection.ts";
+import type { PostgresExecuteResult } from "./i-postgres-driver.ts";
+import type { Scalar } from "./scalar.ts";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.ts";
+
+export class PostgresCommand extends CommandMiddlewareHost implements ICommand {
+  private readonly statements: StatementTextRenderer;
+
+  constructor(readonly connection: PostgresConnection, statements?: StatementTextRenderer) {
+    super();
+    this.statements = statements ?? new StatementTextRenderer(t => new PostgresStatementRenderer(t));
+  }
+
+  async executeReaderNative(
+    text: Native,
+    parameters?: Parameter[],
+  ): Promise<IReader<Cells>> {
+    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: IStatement,
+    parameters?: Parameter[],
+  ): Promise<IReader<Cells>> {
+    return this.executeReaderNative(new Native(this.statements.render(statement)), parameters);
+  }
+
+  async executeStatement(statement: IStatement, parameters?: Parameter[]): Promise<Response> {
+    return statement instanceof SelectStatement || statement instanceof ReturnStatement
+      ? this.firstCell(statement, parameters)
+      : this.executeNative(new Native(this.statements.render(statement)), parameters);
+  }
+
+  private async firstCell(statement: IStatement, parameters?: Parameter[]): Promise<Response> {
+    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: Native, parameters?: Parameter[]): Promise<Response> {
+    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: [],
+      };
+    });
+  }
+
+  private async runSql(
+    sql: string,
+    params?: Record<string, Scalar>,
+    parameters?: Parameter[],
+  ): Promise<PostgresExecuteResult> {
+    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 as Record<string, Scalar | object>;
+        const cell = cells[parameter.name] ?? cells[parameter.name.toLowerCase()];
+        if (cell === undefined) return parameter;
+        return { ...parameter, value: cellValue(cell) };
+      }),
+    };
+  }
+
+  private query(sql: string, params?: Record<string, Scalar>): AsyncIterable<Cells> {
+    const { text, values } = toPostgres(sql, params);
+    return this.connection.require().rows(text, values);
+  }
+}
+
+const cellValue = (cell: Scalar | object): Scalar =>
+  cell !== null && typeof cell === "object" ? JSON.stringify(cell) : cell;

package/src/connection-options.ts

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

package/src/connection.ts

@@ -0,0 +1,95 @@
+import {
+  DatasourceError,
+  DatasourceUrlParser,
+  IsolationLevel,
+  StatementTextRenderer,
+  type DatasourceOptions,
+  type ICommand,
+  type IConnection,
+  type IsolationLevelName,
+  type ITransaction,
+} from "@deterministic-code/datasources";
+import { createRequire } from "node:module";
+import { PostgresCommand } from "./command.ts";
+import type { PostgresConnectionOptions } from "./connection-options.ts";
+import { pgClient, type IPgClient, type PgClientCtor, type PgModule } from "./i-postgres-driver.ts";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.ts";
+import { PostgresTransaction } from "./transaction.ts";
+
+const require = createRequire(import.meta.url);
+
+const isoSql = (isolation: IsolationLevelName): string =>
+  isolation === IsolationLevel.ReadUncommitted
+    ? "READ UNCOMMITTED"
+    : isolation === IsolationLevel.ReadCommitted
+      ? "READ COMMITTED"
+      : isolation === IsolationLevel.RepeatableRead
+        ? "REPEATABLE READ"
+        : "SERIALIZABLE";
+
+export class PostgresConnection implements IConnection {
+  readonly provider = "postgres";
+  url: string;
+  schema?: string;
+  isOpen = false;
+  private client?: IPgClient;
+  private readonly Client?: PgClientCtor;
+
+  static from = (options?: DatasourceOptions): PostgresConnection => {
+    const url = options?.DATASOURCE_URL ?? "";
+    return new PostgresConnection({
+      url,
+      schema: DatasourceUrlParser.parse(url)?.schema,
+      Client: pgClient(require("pg") as PgModule),
+    });
+  };
+
+  constructor(options: PostgresConnectionOptions = {}) {
+    this.url = options.url ?? "";
+    this.schema = options.schema;
+    this.Client = options.Client;
+  }
+
+  createCommand = (): ICommand =>
+    new PostgresCommand(this, new StatementTextRenderer(t => new PostgresStatementRenderer(t)));
+
+  async open(): Promise<void> {
+    if (this.isOpen) throw new DatasourceError("Connection is already open");
+    if (!this.client) {
+      if (!this.Client) throw new DatasourceError("Postgres driver is required");
+      this.client = new this.Client({ connectionString: this.url });
+    }
+    await this.client.connect();
+    if (this.schema) await this.client.query(`SET search_path TO ${this.schema}`);
+    this.isOpen = true;
+  }
+
+  async close(): Promise<void> {
+    await this.client?.end();
+    this.client = undefined;
+    this.isOpen = false;
+  }
+
+  [Symbol.asyncDispose] = (): Promise<void> => this.close();
+
+  async startTransaction(
+    isolation: IsolationLevelName = IsolationLevel.ReadCommitted,
+  ): Promise<ITransaction> {
+    this.ensureOpen();
+    await this.exec(`BEGIN ISOLATION LEVEL ${isoSql(isolation)}`);
+    return new PostgresTransaction(this, isolation);
+  }
+
+  ensureOpen(): void {
+    if (!this.isOpen) throw new DatasourceError("Connection is not open");
+  }
+
+  require(): IPgClient {
+    if (!this.client) throw new DatasourceError("Connection is not open");
+    return this.client;
+  }
+
+  async exec(sql: string): Promise<void> {
+    await this.require().query(sql);
+  }
+}

package/src/converters/BinaryConverter.ts

@@ -0,0 +1,20 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+
+export const isBase64 = (value: string): boolean => {
+  const text = value.trim();
+  return (
+    text.length >= 4 &&
+    text.length % 4 === 0 &&
+    text.includes("=") &&
+    /^[A-Za-z0-9+/]+=*$/.test(text) &&
+    Buffer.from(text, "base64").toString("base64") === text
+  );
+};
+
+const bytes = (value: Cell): Cell =>
+  typeof value === "string" ? Uint8Array.from(Buffer.from(value, "base64")) : value;
+
+export class BinaryConverter extends TypeConverter<Cell, Cell> {
+  convert = (from: Cell): Cell => bytes(from);
+  reverseConvert = (to: Cell): Cell => bytes(to);
+}

package/src/converters/BoolConverter.ts

@@ -0,0 +1,6 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+
+export class BoolConverter extends TypeConverter<Cell, Cell> {
+  convert = (from: Cell): Cell => (typeof from === "number" ? from !== 0 : from);
+  reverseConvert = (to: Cell): Cell => to;
+}

package/src/converters/DateTimeConverter.ts

@@ -0,0 +1,11 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+
+export const isIsoDate = (value: string): boolean =>
+  /^\d{4}-\d{2}-\d{2}T/.test(value) && !Number.isNaN(Date.parse(value));
+
+export class DateTimeConverter extends TypeConverter<Cell, Cell> {
+  convert = (from: Cell): Cell =>
+    typeof from === "string" ? new Date(from) : from;
+  reverseConvert = (to: Cell): Cell =>
+    to instanceof Date ? to.toISOString() : to;
+}

package/src/converters/DecimalConverter.ts

@@ -0,0 +1,7 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+
+export class DecimalConverter extends TypeConverter<Cell, Cell> {
+  convert = (from: Cell): Cell => from;
+  reverseConvert = (to: Cell): Cell =>
+    typeof to === "number" ? String(to) : to;
+}

package/src/converters/PostgresRowTypeConverters.ts

@@ -0,0 +1,24 @@
+import { type Cell, type TypeConverter } from "@deterministic-code/datasources";
+import { BinaryConverter } from "./BinaryConverter.ts";
+import { BoolConverter } from "./BoolConverter.ts";
+import { DateTimeConverter } from "./DateTimeConverter.ts";
+import { DecimalConverter } from "./DecimalConverter.ts";
+import { UuidConverter } from "./UuidConverter.ts";
+
+export const PostgresRowTypeConverters: Record<string, TypeConverter<Cell, Cell>> = {
+  bool: new BoolConverter(),
+  datetime: new DateTimeConverter(),
+  uuid: new UuidConverter(),
+  decimal: new DecimalConverter(),
+  binary: new BinaryConverter(),
+};
+
+export const reverse = (value: Cell): Cell =>
+  typeof value === "boolean"
+    ? PostgresRowTypeConverters.bool.reverseConvert(value)
+    : value instanceof Date
+      ? PostgresRowTypeConverters.datetime.reverseConvert(value)
+      : value instanceof Uint8Array
+        ? PostgresRowTypeConverters.binary.reverseConvert(value)
+        : value;
+

package/src/converters/UuidConverter.ts

@@ -0,0 +1,6 @@
+import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+
+export class UuidConverter extends TypeConverter<Cell, Cell> {
+  convert = (from: Cell): Cell => from;
+  reverseConvert = (to: Cell): Cell => to;
+}

package/src/i-postgres-driver.ts

@@ -0,0 +1,61 @@
+import type { Parameter } from "@deterministic-code/datasources";
+import QueryStream from "pg-query-stream";
+import type { Cells, Scalar, Wire } from "./scalar.ts";
+
+export interface PostgresExecuteResult {
+  rowsAffected: number;
+  result?: Scalar;
+  parameters?: Parameter[];
+}
+
+export interface PgQueryResult {
+  rowCount: number | null;
+  rows: Cells[];
+}
+
+export interface IPgClient {
+  connect(): Promise<void>;
+  query(text: string, values?: Wire[]): Promise<PgQueryResult>;
+  rows(text: string, values?: Wire[]): AsyncIterable<Cells>;
+  end(): Promise<void>;
+}
+
+interface PgNativeClient {
+  connect(): Promise<void>;
+  query(text: string, values?: Wire[]): Promise<PgQueryResult>;
+  query(query: QueryStream): AsyncIterable<Cells>;
+  end(): Promise<void>;
+}
+
+export type PgClientCtor = new (options: {
+  connectionString: string;
+}) => IPgClient;
+
+type PgNativeCtor = new (options: { connectionString: string }) => PgNativeClient;
+
+export type PgModule = {
+  Client: PgNativeCtor;
+  default?: { Client: PgNativeCtor };
+};
+
+export const pgClient = (imported: PgModule): PgClientCtor => {
+  const Client = imported.default?.Client ?? imported.Client;
+  return class implements IPgClient {
+    private readonly inner: PgNativeClient;
+    constructor(options: { connectionString: string }) {
+      this.inner = new Client(options);
+    }
+    connect(): Promise<void> {
+      return this.inner.connect();
+    }
+    query(text: string, values?: Wire[]): Promise<PgQueryResult> {
+      return this.inner.query(text, values);
+    }
+    rows(text: string, values?: Wire[]): AsyncIterable<Cells> {
+      return this.inner.query(new QueryStream(text, values ?? []));
+    }
+    end(): Promise<void> {
+      return this.inner.end();
+    }
+  };
+};

package/src/index.ts

@@ -0,0 +1 @@
+export { PostgresDriver } from "./PostgresDriver.ts";

package/src/scalar.ts

@@ -0,0 +1,3 @@
+export type Scalar = string | number | boolean | bigint | null;
+export type Wire = Scalar | Date | Uint8Array;
+export type Cells = Record<string, Scalar>;

package/src/transaction.ts

@@ -0,0 +1,21 @@
+import {
+  IsolationLevel,
+  type ITransaction,
+  type IsolationLevelName,
+} from "@deterministic-code/datasources";
+import type { PostgresConnection } from "./connection.ts";
+
+export class PostgresTransaction implements ITransaction {
+  constructor(
+    readonly connection: PostgresConnection,
+    readonly isolation: IsolationLevelName = IsolationLevel.ReadCommitted,
+  ) {}
+
+  async commit(): Promise<void> {
+    await this.connection.exec("COMMIT");
+  }
+
+  async abort(): Promise<void> {
+    await this.connection.exec("ROLLBACK");
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.