@deterministic-code/datasources-postgres 0.1.0 → 0.1.2

package/dist/connection-options.js

@@ -0,0 +1 @@
+export {};

package/dist/connection.d.ts

@@ -0,0 +1,21 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction } from "@deterministic-code/datasources";
+import type { PostgresConnectionOptions } from "./connection-options.js";
+import { type IPgClient } from "./i-postgres-driver.js";
+export declare class PostgresConnection implements IConnection {
+    readonly provider = "postgres";
+    url: string;
+    schema?: string;
+    isOpen: boolean;
+    private client?;
+    private readonly Client?;
+    static from: (options?: DatasourceOptions) => PostgresConnection;
+    constructor(options?: PostgresConnectionOptions);
+    createCommand: () => ICommand;
+    open(): Promise<void>;
+    close(): Promise<void>;
+    [Symbol.asyncDispose]: () => Promise<void>;
+    startTransaction(isolation?: IsolationLevelName): Promise<ITransaction>;
+    ensureOpen(): void;
+    require(): IPgClient;
+    exec(sql: string): Promise<void>;
+}

package/dist/connection.js

@@ -0,0 +1,72 @@
+import { DatasourceError, DatasourceUrlParser, IsolationLevel, StatementTextRenderer, } from "@deterministic-code/datasources";
+import { createRequire } from "node:module";
+import { PostgresCommand } from "./command.js";
+import { pgClient } from "./i-postgres-driver.js";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.js";
+import { PostgresTransaction } from "./transaction.js";
+const require = createRequire(import.meta.url);
+const isoSql = (isolation) => isolation === IsolationLevel.ReadUncommitted
+    ? "READ UNCOMMITTED"
+    : isolation === IsolationLevel.ReadCommitted
+        ? "READ COMMITTED"
+        : isolation === IsolationLevel.RepeatableRead
+            ? "REPEATABLE READ"
+            : "SERIALIZABLE";
+export class PostgresConnection {
+    provider = "postgres";
+    url;
+    schema;
+    isOpen = false;
+    client;
+    Client;
+    static from = (options) => {
+        const url = options?.DATASOURCE_URL ?? "";
+        return new PostgresConnection({
+            url,
+            schema: DatasourceUrlParser.parse(url)?.schema,
+            Client: pgClient(require("pg")),
+        });
+    };
+    constructor(options = {}) {
+        this.url = options.url ?? "";
+        this.schema = options.schema;
+        this.Client = options.Client;
+    }
+    createCommand = () => new PostgresCommand(this, new StatementTextRenderer(t => new PostgresStatementRenderer(t)));
+    async open() {
+        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() {
+        await this.client?.end();
+        this.client = undefined;
+        this.isOpen = false;
+    }
+    [Symbol.asyncDispose] = () => this.close();
+    async startTransaction(isolation = IsolationLevel.Serializable) {
+        this.ensureOpen();
+        await this.exec(`BEGIN ISOLATION LEVEL ${isoSql(isolation)}`);
+        return new PostgresTransaction(this, isolation);
+    }
+    ensureOpen() {
+        if (!this.isOpen)
+            throw new DatasourceError("Connection is not open");
+    }
+    require() {
+        if (!this.client)
+            throw new DatasourceError("Connection is not open");
+        return this.client;
+    }
+    async exec(sql) {
+        await this.require().query(sql);
+    }
+}

package/dist/converters/BinaryConverter.d.ts

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

package/dist/converters/BinaryConverter.js

@@ -0,0 +1,14 @@
+import { TypeConverter } from "@deterministic-code/datasources";
+export const isBase64 = (value) => {
+    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) => typeof value === "string" ? Uint8Array.from(Buffer.from(value, "base64")) : value;
+export class BinaryConverter extends TypeConverter {
+    convert = (from) => bytes(from);
+    reverseConvert = (to) => bytes(to);
+}

package/dist/converters/BoolConverter.d.ts

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

package/dist/converters/BoolConverter.js

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

package/dist/converters/DateTimeConverter.d.ts

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

package/dist/converters/DateTimeConverter.js

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

package/dist/converters/DecimalConverter.d.ts

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

package/dist/converters/DecimalConverter.js

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

package/dist/converters/PostgresRowTypeConverters.d.ts

@@ -0,0 +1,3 @@
+import { type Cell, type TypeConverter } from "@deterministic-code/datasources";
+export declare const PostgresRowTypeConverters: Record<string, TypeConverter<Cell, Cell>>;
+export declare const reverse: (value: Cell) => Cell;

package/dist/converters/PostgresRowTypeConverters.js

@@ -0,0 +1,19 @@
+import { BinaryConverter } from "./BinaryConverter.js";
+import { BoolConverter } from "./BoolConverter.js";
+import { DateTimeConverter } from "./DateTimeConverter.js";
+import { DecimalConverter } from "./DecimalConverter.js";
+import { UuidConverter } from "./UuidConverter.js";
+export const PostgresRowTypeConverters = {
+    bool: new BoolConverter(),
+    datetime: new DateTimeConverter(),
+    uuid: new UuidConverter(),
+    decimal: new DecimalConverter(),
+    binary: new BinaryConverter(),
+};
+export const reverse = (value) => typeof value === "boolean"
+    ? PostgresRowTypeConverters.bool.reverseConvert(value)
+    : value instanceof Date
+        ? PostgresRowTypeConverters.datetime.reverseConvert(value)
+        : value instanceof Uint8Array
+            ? PostgresRowTypeConverters.binary.reverseConvert(value)
+            : value;

package/dist/converters/UuidConverter.d.ts

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

package/dist/converters/UuidConverter.js

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

package/dist/i-postgres-driver.d.ts

@@ -0,0 +1,38 @@
+import type { Parameter } from "@deterministic-code/datasources";
+import QueryStream from "pg-query-stream";
+import type { Cells, Scalar, Wire } from "./scalar.js";
+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 declare const pgClient: (imported: PgModule) => PgClientCtor;
+export {};

package/dist/i-postgres-driver.js

@@ -0,0 +1,22 @@
+import QueryStream from "pg-query-stream";
+export const pgClient = (imported) => {
+    const Client = imported.default?.Client ?? imported.Client;
+    return class {
+        inner;
+        constructor(options) {
+            this.inner = new Client(options);
+        }
+        connect() {
+            return this.inner.connect();
+        }
+        query(text, values) {
+            return this.inner.query(text, values);
+        }
+        rows(text, values) {
+            return this.inner.query(new QueryStream(text, values ?? []));
+        }
+        end() {
+            return this.inner.end();
+        }
+    };
+};

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/scalar.js

@@ -0,0 +1 @@
+export {};

package/dist/transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITransaction, type IsolationLevelName } from "@deterministic-code/datasources";
+import type { PostgresConnection } from "./connection.js";
+export declare class PostgresTransaction implements ITransaction {
+    readonly connection: PostgresConnection;
+    readonly isolation: IsolationLevelName;
+    constructor(connection: PostgresConnection, isolation?: IsolationLevelName);
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}

package/dist/transaction.js

@@ -0,0 +1,15 @@
+import { IsolationLevel, } from "@deterministic-code/datasources";
+export class PostgresTransaction {
+    connection;
+    isolation;
+    constructor(connection, isolation = IsolationLevel.ReadCommitted) {
+        this.connection = connection;
+        this.isolation = isolation;
+    }
+    async commit() {
+        await this.connection.exec("COMMIT");
+    }
+    async abort() {
+        await this.connection.exec("ROLLBACK");
+    }
+}

package/package.json

@@ -1,21 +1,24 @@
 {
   "name": "@deterministic-code/datasources-postgres",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.js",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
   },
   "files": [
-    "src"
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "license": "MIT",
   "dependencies": {
-    "@deterministic-code/datasources": "^0.1.0",
+    "@deterministic-code/datasources": "^0.1.2",
     "@types/pg": "^8.15.5",
     "pg": "^8.16.0",
     "pg-query-stream": "^4.17.0"

package/src/PostgresBulkUpdateStatementTextRenderer.ts

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

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

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

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

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

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