@deterministic-code/datasources-postgres 0.1.0 → 0.1.1

package/dist/PostgresBulkUpdateStatementTextRenderer.d.ts

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

package/dist/PostgresCreateTableStatementRenderer.d.ts

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

package/dist/PostgresDriver.d.ts

@@ -0,0 +1,12 @@
+import { StatementTextRenderer, type Cell, type DatasourceOptions, type ICommand, type IConnection, type IDriver, type Information, type ITransaction, type IsolationLevel, type TypeConverter } from "@datasources/core";
+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>>;
+    columnType: (name: string) => string;
+    connection: (options?: DatasourceOptions) => IConnection;
+    command: (connection: IConnection) => ICommand;
+    transaction: (connection: IConnection, isolation?: IsolationLevel) => ITransaction;
+}

package/dist/PostgresStatementRenderer.d.ts

@@ -0,0 +1,7 @@
+import { BulkUpdateStatement, CreateTableStatement, SelectInsertedIdStatement, StatementRenderer, type StatementTextRenderer } from "@datasources/core";
+export declare class PostgresStatementRenderer extends StatementRenderer {
+    constructor(text: StatementTextRenderer);
+    protected visitSelectInsertedId(inserted: SelectInsertedIdStatement): string;
+    protected visitCreateTable(create: CreateTableStatement): string;
+    protected visitBulkUpdate(update: BulkUpdateStatement): string;
+}

package/dist/bind.d.ts

@@ -0,0 +1,7 @@
+import { type Parameter } from "@datasources/core";
+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/columnTypes.d.ts

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

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 "@datasources/core";
+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/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;
+}

package/dist/connection.d.ts

@@ -0,0 +1,21 @@
+import { type DatasourceOptions, type ICommand, type IConnection, type IsolationLevelName, type ITransaction } from "@datasources/core";
+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/converters/BinaryConverter.d.ts

@@ -0,0 +1,6 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+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/BoolConverter.d.ts

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

package/dist/converters/DateTimeConverter.d.ts

@@ -0,0 +1,6 @@
+import { TypeConverter, type Cell } from "@datasources/core";
+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/DecimalConverter.d.ts

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

package/dist/converters/PostgresRowTypeConverters.d.ts

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

package/dist/converters/UuidConverter.d.ts

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

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

@@ -0,0 +1,38 @@
+import type { Parameter } from "@datasources/core";
+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/index.d.ts

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

package/dist/scalar.d.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/dist/transaction.d.ts

@@ -0,0 +1,9 @@
+import { type ITransaction, type IsolationLevelName } from "@datasources/core";
+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/package.json

@@ -1,23 +1,27 @@
 {
   "name": "@deterministic-code/datasources-postgres",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
   "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
   },
   "files": [
+    "dist",
     "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"
+    "pg-query-stream": "^4.17.0",
+    "@deterministic-code/datasources": "^0.1.1"
   }
 }

package/src/PostgresBulkUpdateStatementTextRenderer.ts

@@ -1,4 +1,4 @@
-import { BulkUpdateStatementTextRenderer, type Cell } from "@deterministic-code/datasources";
+import { BulkUpdateStatementTextRenderer, type Cell } from "@datasources/core";
 import { columnTypes } from "./columnTypes.ts";
 import { isBase64 } from "./converters/BinaryConverter.ts";
 import { isIsoDate } from "./converters/DateTimeConverter.ts";

package/src/PostgresCreateTableStatementRenderer.ts

@@ -2,7 +2,7 @@ import {
   ColumnDefault,
   CreateTableStatementTextRenderer,
   type Column,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.ts";
 import { columnTypes } from "./columnTypes.ts";
 

package/src/PostgresDriver.ts

@@ -10,7 +10,7 @@ import {
   type ITransaction,
   type IsolationLevel,
   type TypeConverter,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { PostgresConnection } from "./connection.ts";
 import { PostgresCommand } from "./command.ts";
 import { PostgresTransaction } from "./transaction.ts";

package/src/PostgresStatementRenderer.test.ts

@@ -0,0 +1,105 @@
+import {
+  BulkUpdateStatement,
+  type Cell,
+  ColumnDefault,
+  CreateTableStatement,
+  DefaultStatementTextRenderer,
+  ForeignKey,
+  SelectInsertedIdStatement,
+  NotNull,
+  PrimaryKey,
+  ReferentialAction,
+  SelectStatement,
+  StatementTextRenderer,
+} from "@datasources/core";
+import { describe, expect, it } from "vitest";
+import { PostgresCreateTableStatementRenderer } from "./PostgresCreateTableStatementRenderer.ts";
+import { PostgresStatementRenderer } from "./PostgresStatementRenderer.ts";
+
+describe("PostgresStatementRenderer", () => {
+  const renderer = new StatementTextRenderer(t => new PostgresStatementRenderer(t));
+
+  it("renders inserted id and create table", () => {
+    expect(renderer.render(new SelectInsertedIdStatement("users", "id"))).toBe(
+      "SELECT lastval() AS id",
+    );
+
+    const create = new CreateTableStatement(
+      "orders",
+      [
+        { name: "id", type: "INTEGER", default: new ColumnDefault("0", "df_id"), notNull: new NotNull("nn_id") },
+        { name: "user_id", type: "INTEGER" },
+      ],
+      [
+        new PrimaryKey("pk_orders", ["id"]),
+        new ForeignKey("fk_orders_user", ["user_id"], "users", ["id"], ReferentialAction.Cascade),
+      ],
+    );
+    expect(renderer.render(create)).toBe(new PostgresCreateTableStatementRenderer().render(create));
+    expect(renderer.render(new SelectStatement({ table: "users", fields: ["id"] }))).toBe(
+      "SELECT id FROM users",
+    );
+  });
+
+  it("renders type default and identity", () => {
+    const create = new CreateTableStatement("users", [
+      { name: "id", type: "int", identity: true },
+      { name: "is_enabled", type: "bool", default: new ColumnDefault("1") },
+      { name: "is_disabled", type: "bool", default: new ColumnDefault("0", "df_off") },
+      { name: "amount", type: "decimal", default: new ColumnDefault("1") },
+      { name: "flag", type: "bool", default: new ColumnDefault("true") },
+    ]);
+    expect(renderer.render(create)).toBe(
+      "CREATE TABLE users (id INTEGER GENERATED BY DEFAULT AS IDENTITY, is_enabled BOOLEAN DEFAULT TRUE, is_disabled BOOLEAN CONSTRAINT df_off DEFAULT FALSE, amount NUMERIC DEFAULT 1, flag BOOLEAN DEFAULT true)",
+    );
+    expect(DefaultStatementTextRenderer.instance.render(create)).toBe(
+      "CREATE TABLE users (id int, is_enabled bool DEFAULT 1, is_disabled bool CONSTRAINT df_off DEFAULT 0, amount decimal DEFAULT 1, flag bool DEFAULT true)",
+    );
+  });
+
+  it("renders bulk update with column types", () => {
+    const update = new BulkUpdateStatement("parents", ["label"], ["id"], [
+      { fields: [{ name: "label", value: "a" }], ids: [{ name: "id", value: 1 }] },
+      { fields: [{ name: "label", value: "b" }], ids: [{ name: "id", value: 2 }] },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE parents SET label = data.label FROM (SELECT $label__0::TEXT AS label, $id__0::INTEGER AS id UNION ALL SELECT $label__1::TEXT AS label, $id__1::INTEGER AS id) AS data WHERE parents.id = data.id",
+    );
+  });
+
+  it("renders bulk update cell types", () => {
+    const update = new BulkUpdateStatement("t", ["flag", "n", "at", "blob", "x"], ["id"], [
+      {
+        fields: [
+          { name: "flag", value: true },
+          { name: "n", value: 1.5 },
+          { name: "at", value: new Date("2020-01-02T03:04:05.000Z") },
+          { name: "blob", value: new Uint8Array([1]) },
+          { name: "x", value: null },
+        ] as { name: string; value: Cell }[],
+        ids: [{ name: "id", value: 1n }],
+      },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE t SET flag = data.flag, n = data.n, at = data.at, blob = data.blob, x = data.x FROM (SELECT $flag__0::BOOLEAN AS flag, $n__0::DOUBLE PRECISION AS n, $at__0::TIMESTAMPTZ AS at, $blob__0::BYTEA AS blob, $x__0 AS x, $id__0::INTEGER AS id) AS data WHERE t.id = data.id",
+    );
+  });
+
+  it("renders bulk update iso created as timestamptz", () => {
+    const update = new BulkUpdateStatement("contacts", ["created"], ["id"], [
+      { fields: [{ name: "created", value: "2020-01-02T03:04:05.000Z" }], ids: [{ name: "id", value: 1 }] },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE contacts SET created = data.created FROM (SELECT $created__0::TIMESTAMPTZ AS created, $id__0::INTEGER AS id) AS data WHERE contacts.id = data.id",
+    );
+  });
+
+  it("renders bulk update base64 version as bytea", () => {
+    const update = new BulkUpdateStatement("contacts", ["version"], ["id"], [
+      { fields: [{ name: "version", value: "AA==" }], ids: [{ name: "id", value: 1 }] },
+    ]);
+    expect(renderer.render(update)).toBe(
+      "UPDATE contacts SET version = data.version FROM (SELECT $version__0::BYTEA AS version, $id__0::INTEGER AS id) AS data WHERE contacts.id = data.id",
+    );
+  });
+});

package/src/PostgresStatementRenderer.ts

@@ -5,7 +5,7 @@ import {
   SelectInsertedIdStatementTextRenderer,
   StatementRenderer,
   type StatementTextRenderer,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { PostgresBulkUpdateStatementTextRenderer } from "./PostgresBulkUpdateStatementTextRenderer.ts";
 import { PostgresCreateTableStatementRenderer } from "./PostgresCreateTableStatementRenderer.ts";
 

package/src/bind.ts

@@ -1,4 +1,4 @@
-import { parametersToRecord, type Cell, type Parameter } from "@deterministic-code/datasources";
+import { parametersToRecord, type Cell, type Parameter } from "@datasources/core";
 import { isBase64 } from "./converters/BinaryConverter.ts";
 import { isIsoDate } from "./converters/DateTimeConverter.ts";
 import { reverse } from "./converters/PostgresRowTypeConverters.ts";

package/src/command.ts

@@ -17,7 +17,7 @@ import {
   type IReader,
   type IStatement,
   type Parameter,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { bindParameters, toPostgres } from "./bind.ts";
 import type { PostgresConnection } from "./connection.ts";
 import type { PostgresExecuteResult } from "./i-postgres-driver.ts";

package/src/connection.ts

@@ -8,7 +8,7 @@ import {
   type IConnection,
   type IsolationLevelName,
   type ITransaction,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import { createRequire } from "node:module";
 import { PostgresCommand } from "./command.ts";
 import type { PostgresConnectionOptions } from "./connection-options.ts";

package/src/converters/BinaryConverter.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { BinaryConverter, isBase64 } from "./BinaryConverter.ts";
+
+describe("BinaryConverter", () => {
+  it("maps binary", () => {
+    const converter = new BinaryConverter();
+    const raw = new Uint8Array([1, 2, 3, 4]);
+    expect(converter.convert(raw)).toBe(raw);
+    expect(converter.reverseConvert(raw)).toBe(raw);
+    expect(converter.reverseConvert("AQIDBA==")).toEqual(raw);
+    expect(isBase64("AA==")).toBe(true);
+    expect(isBase64("ada")).toBe(false);
+  });
+});

package/src/converters/BinaryConverter.ts

@@ -1,4 +1,4 @@
-import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+import { TypeConverter, type Cell } from "@datasources/core";
 
 export const isBase64 = (value: string): boolean => {
   const text = value.trim();

package/src/converters/BoolConverter.test.ts

@@ -0,0 +1,14 @@
+import { describe, expect, it } from "vitest";
+import { BoolConverter } from "./BoolConverter.ts";
+
+describe("BoolConverter", () => {
+  it("maps bool", () => {
+    const converter = new BoolConverter();
+    expect(converter.convert(1)).toBe(true);
+    expect(converter.convert(0)).toBe(false);
+    expect(converter.convert(true)).toBe(true);
+    expect(converter.reverseConvert(true)).toBe(true);
+    expect(converter.reverseConvert(false)).toBe(false);
+    expect(converter.reverseConvert("x")).toBe("x");
+  });
+});

package/src/converters/BoolConverter.ts

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

package/src/converters/DateTimeConverter.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { DateTimeConverter } from "./DateTimeConverter.ts";
+
+describe("DateTimeConverter", () => {
+  it("maps datetime", () => {
+    const converter = new DateTimeConverter();
+    const date = new Date("2020-01-02T03:04:05.000Z");
+    expect(converter.convert("2020-01-02T03:04:05.000Z")).toEqual(date);
+    expect(converter.convert(date)).toBe(date);
+    expect(converter.reverseConvert(date)).toBe("2020-01-02T03:04:05.000Z");
+    expect(converter.reverseConvert("x")).toBe("x");
+  });
+});

package/src/converters/DateTimeConverter.ts

@@ -1,4 +1,4 @@
-import { TypeConverter, type Cell } from "@deterministic-code/datasources";
+import { TypeConverter, type Cell } from "@datasources/core";
 
 export const isIsoDate = (value: string): boolean =>
   /^\d{4}-\d{2}-\d{2}T/.test(value) && !Number.isNaN(Date.parse(value));

package/src/converters/DecimalConverter.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DecimalConverter } from "./DecimalConverter.ts";
+
+describe("DecimalConverter", () => {
+  it("maps decimal", () => {
+    const converter = new DecimalConverter();
+    expect(converter.convert("10.5")).toBe("10.5");
+    expect(converter.reverseConvert(10.5)).toBe("10.5");
+    expect(converter.reverseConvert("10.5")).toBe("10.5");
+  });
+});

package/src/converters/DecimalConverter.ts

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

package/src/converters/PostgresRowTypeConverters.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { PostgresDriver } from "../PostgresDriver.ts";
+import { reverse, PostgresRowTypeConverters } from "./PostgresRowTypeConverters.ts";
+
+describe("PostgresRowTypeConverters", () => {
+  it("registers default types", () => {
+    expect(Object.keys(new PostgresDriver().rowTypeConverters)).toEqual(Object.keys(PostgresRowTypeConverters));
+  });
+
+  it("reverses booleans, dates, and bytes", () => {
+    const when = new Date("2024-01-02T00:00:00.000Z");
+    expect(reverse(true)).toBe(true);
+    expect(reverse(false)).toBe(false);
+    expect(reverse(when)).toBe("2024-01-02T00:00:00.000Z");
+    expect(reverse(new Uint8Array([1, 2]))).toEqual(new Uint8Array([1, 2]));
+    expect(reverse("a")).toBe("a");
+  });
+});

package/src/converters/PostgresRowTypeConverters.ts

@@ -1,4 +1,4 @@
-import { type Cell, type TypeConverter } from "@deterministic-code/datasources";
+import { type Cell, type TypeConverter } from "@datasources/core";
 import { BinaryConverter } from "./BinaryConverter.ts";
 import { BoolConverter } from "./BoolConverter.ts";
 import { DateTimeConverter } from "./DateTimeConverter.ts";

package/src/converters/UuidConverter.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { UuidConverter } from "./UuidConverter.ts";
+
+describe("UuidConverter", () => {
+  it("maps uuid", () => {
+    const converter = new UuidConverter();
+    const id = "550e8400-e29b-41d4-a716-446655440000";
+    expect(converter.convert(id)).toBe(id);
+    expect(converter.reverseConvert(id)).toBe(id);
+  });
+});

package/src/converters/UuidConverter.ts

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

package/src/i-postgres-driver.ts

@@ -1,4 +1,4 @@
-import type { Parameter } from "@deterministic-code/datasources";
+import type { Parameter } from "@datasources/core";
 import QueryStream from "pg-query-stream";
 import type { Cells, Scalar, Wire } from "./scalar.ts";
 

package/src/postgres.test.ts

@@ -0,0 +1,345 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("pg", () => {
+  class Client {
+    async connect(): Promise<void> {}
+    async query() {
+      return { rowCount: 0, rows: [] };
+    }
+    async end(): Promise<void> {}
+  }
+  return { Client, default: { Client } };
+});
+
+import { Datasource, DatasourceFactory, DatasourceError, IsolationLevel, CRUDRepository, ReadonlyRepository, untyped, Native, ParameterDirection, columnType, RowTypeConverter, CreateTableStatement, ExecuteStoredProcedureStatement, ReturnStatement, SelectStatement, type IDriver } from "@datasources/core";
+import { bindParameters, toPostgres } from "./bind.ts";
+import { PostgresCommand } from "./command.ts";
+import { PostgresConnection } from "./connection.ts";
+import { PostgresRowTypeConverters } from "./converters/PostgresRowTypeConverters.ts";
+import { pgClient, type IPgClient, type PgModule, type PgQueryResult } from "./i-postgres-driver.ts";
+import { PostgresDriver } from "./PostgresDriver.ts";
+import { PostgresTransaction } from "./transaction.ts";
+import type { Scalar } from "./scalar.ts";
+
+class FakeClient implements IPgClient {
+  static latest: FakeClient;
+  queries: Array<{ text: string; values?: Scalar[] }> = [];
+  connected = false;
+  ended = false;
+  result: PgQueryResult = { rowCount: 2, rows: [{ id: 5 }] };
+
+  constructor(_options: { connectionString: string }) {
+    FakeClient.latest = this;
+  }
+
+  async connect(): Promise<void> {
+    this.connected = true;
+  }
+  async query(text: string, values?: Scalar[]): Promise<PgQueryResult> {
+    this.queries.push({ text, values });
+    return this.result;
+  }
+  async *rows(text: string, values?: Scalar[]): AsyncGenerator<PgQueryResult["rows"][number]> {
+    this.queries.push({ text, values });
+    for (const row of this.result.rows) yield row;
+  }
+  async end(): Promise<void> {
+    this.ended = true;
+  }
+}
+
+afterEach(() => {
+  DatasourceFactory.reset();
+  DatasourceFactory.register("postgres", new PostgresDriver());
+});
+
+describe("bind", () => {
+  it("rewrites named parameters and inserts", () => {
+    expect(bindParameters()).toEqual({});
+    expect(bindParameters([{ name: "id", value: 1 }])).toEqual({ id: 1 });
+    expect(toPostgres("SELECT * FROM t WHERE id = $id AND n = $id", { id: 1 }))
+      .toEqual({ text: "SELECT * FROM t WHERE id = $1 AND n = $1", values: [1] });
+    expect(toPostgres("SELECT 1")).toEqual({ text: "SELECT 1", values: [] });
+    expect(toPostgres("SELECT * FROM t WHERE id = $id")).toEqual({
+      text: "SELECT * FROM t WHERE id = $1",
+      values: [null],
+    });
+    expect(toPostgres(`INSERT INTO "contact_sources" ("name") VALUES ('Manual')`).text)
+      .toBe(`INSERT INTO "contact_sources" ("name") VALUES ('Manual')`);
+    expect(toPostgres("SELECT * FROM OldContactsTbl").text).toBe(`SELECT * FROM "OldContactsTbl"`);
+    expect(bindParameters([{ name: "at", value: new Date("2020-01-02T03:04:05.000Z") }]))
+      .toEqual({ at: "2020-01-02T03:04:05.000Z" });
+    expect(toPostgres("SELECT $at", { at: "2020-01-02T03:04:05.000Z" })).toEqual({
+      text: "SELECT $1",
+      values: [new Date("2020-01-02T03:04:05.000Z")],
+    });
+    expect(toPostgres("SELECT $v", { v: "AA==" })).toEqual({
+      text: "SELECT $1",
+      values: [Uint8Array.from([0])],
+    });
+    expect(toPostgres("SELECT $n", { n: "ada" }).values).toEqual(["ada"]);
+  });
+});
+
+describe("PostgresConnection", () => {
+  it("opens, runs SQL, transacts, and closes", async () => {
+    const connection = new PostgresConnection({
+      url: "postgres://db/app",
+      schema: "iso",
+      Client: FakeClient,
+    });
+    await connection.open();
+    await expect(connection.open()).rejects.toThrow("Connection is already open");
+    const client = FakeClient.latest;
+    expect(client.connected).toBe(true);
+    const command = new PostgresCommand(connection);
+    expect(await command.execute("INSERT INTO items (id) VALUES ($id)", [{ name: "id", value: 1 }]))
+      .toMatchObject({ rowsAffected: 2, result: null });
+    client.result = { rowCount: 0, rows: [] };
+    expect(await command.executeNative(new Native("INSERT INTO items (id) VALUES (1)"))).toEqual({
+      rowsAffected: 0,
+      result: null,
+      parameters: undefined,
+    });
+    client.result = { rowCount: null, rows: [{ id: 9 }] };
+    expect(await command.executeNative(new Native("UPDATE items SET n = 1"))).toMatchObject({
+      rowsAffected: 1,
+      result: null,
+    });
+    expect(await command.executeNative(new Native("   "))).toEqual({ rowsAffected: 0, parameters: undefined });
+    client.result = { rowCount: null, rows: [{ id: 1 }] };
+    expect(await command.executeReader("SELECT * FROM items")).toBeInstanceOf(Object);
+    const reader = await command.executeReader("SELECT * FROM items");
+    expect(await reader.next()).toBe(true);
+    expect(await command.executeStatement(new CreateTableStatement("users", [{ name: "id", type: "INTEGER" }])))
+      .toMatchObject({ rowsAffected: 1 });
+    expect(await (await command.executeReaderNative(new Native("SELECT 1"))).next()).toBe(true);
+    await connection.startTransaction();
+    await connection.startTransaction(IsolationLevel.ReadUncommitted);
+    await connection.startTransaction(IsolationLevel.ReadCommitted);
+    await connection.startTransaction(IsolationLevel.RepeatableRead);
+    await connection.startTransaction(IsolationLevel.Serializable);
+    await new PostgresTransaction(connection).commit();
+    await new PostgresTransaction(connection).abort();
+    expect(client.queries.map((q) => q.text)).toEqual([
+      "SET search_path TO iso",
+      "INSERT INTO items (id) VALUES ($1)",
+      "INSERT INTO items (id) VALUES (1)",
+      "UPDATE items SET n = 1",
+      "SELECT * FROM items",
+      "SELECT * FROM items",
+      "CREATE TABLE users (id INTEGER)",
+      "SELECT 1",
+      "BEGIN ISOLATION LEVEL READ COMMITTED",
+      "BEGIN ISOLATION LEVEL READ UNCOMMITTED",
+      "BEGIN ISOLATION LEVEL READ COMMITTED",
+      "BEGIN ISOLATION LEVEL REPEATABLE READ",
+      "BEGIN ISOLATION LEVEL SERIALIZABLE",
+      "COMMIT",
+      "ROLLBACK",
+    ]);
+    await connection.close();
+    expect(client.ended).toBe(true);
+    await expect(connection.exec("SELECT 1")).rejects.toThrow("not open");
+    await expect(command.executeNative(new Native("x"))).rejects.toThrow("not open");
+  });
+
+  it("loads the pg client from a module", async () => {
+    const Client = class implements IPgClient {
+      async connect(): Promise<void> {}
+      async query() {
+        return { rowCount: 0, rows: [] };
+      }
+      async *rows() {}
+      async end(): Promise<void> {}
+    };
+    const named = new PostgresConnection({
+      url: "postgres://db/app",
+      Client: pgClient({ Client } as PgModule),
+    });
+    await named.open();
+    await named.close();
+    const viaDefault = new PostgresConnection({
+      url: "postgres://db/app",
+      Client: pgClient({ Client, default: { Client } } as PgModule),
+    });
+    await viaDefault.open();
+    await viaDefault.close();
+    expect(PostgresConnection.from({ DATASOURCE_URL: "postgres://db/app" }).url).toBe("postgres://db/app");
+  });
+
+  it("opens, reopens, transacts, and closes through the connection", async () => {
+    const connection = new PostgresConnection({
+      url: "postgres://db/app",
+      schema: "s",
+      Client: FakeClient,
+    });
+    await connection.open();
+    expect(connection.createCommand()).toBeInstanceOf(PostgresCommand);
+    expect(connection.isOpen).toBe(true);
+    expect(connection.schema).toBe("s");
+    const txn = await connection.startTransaction();
+    await txn.commit();
+    const txn2 = await connection.startTransaction(IsolationLevel.ReadUncommitted);
+    expect(txn2.isolation).toBe(IsolationLevel.ReadUncommitted);
+    await txn2.abort();
+    expect(txn.isolation).toBe("readCommitted");
+    await connection.close();
+    expect(FakeClient.latest.ended).toBe(true);
+    expect(() => connection.ensureOpen()).toThrow(DatasourceError);
+    await expect(connection.startTransaction()).rejects.toThrow(DatasourceError);
+  });
+
+  it("defaults url and requires a client to open", async () => {
+    const connection = new PostgresConnection();
+    expect(connection.url).toBe("");
+    await expect(connection.open()).rejects.toThrow(DatasourceError);
+  });
+});
+
+describe("PostgresCommand", () => {
+  async function setup() {
+    const connection = new PostgresConnection({ Client: FakeClient });
+    await connection.open();
+    return { connection, command: new PostgresCommand(connection), client: FakeClient.latest };
+  }
+
+  it("executes SQL through the client", async () => {
+    const { command, client } = await setup();
+    expect(await command.execute("DELETE FROM items", [{ name: "id", value: 1 }]))
+      .toEqual({ result: null, rowsAffected: 2, parameters: [{ name: "id", value: 1 }] });
+    expect(await command.executeNative(new Native(""))).toEqual({ result: undefined, rowsAffected: 0, parameters: undefined });
+    const reader = await command.executeReader("SELECT * FROM items");
+    expect(await reader.next()).toBe(true);
+    expect(reader.current).toEqual({ id: 5 });
+    const empty = await command.executeReaderNative(new Native(""));
+    expect(await empty.next()).toBe(false);
+    expect(await (await command.executeReaderNative(new Native(";"))).next()).toBe(false);
+    client.result = { rowCount: 1, rows: [{ add_one: 5 }] };
+    const n = { name: "n", value: 4 };
+    expect(await command.executeStatement(new ReturnStatement("add_one", [n]), [n]))
+      .toEqual({ result: 5, rowsAffected: 1, parameters: [n] });
+    client.result = { rowCount: 0, rows: [] };
+    expect(await command.executeStatement(new SelectStatement({ table: "dual", fields: ["1"] }))).toMatchObject({
+      result: null,
+      rowsAffected: 0,
+    });
+    client.result = { rowCount: 1, rows: [{}] };
+    expect(await command.executeStatement(new SelectStatement({ table: "dual", fields: ["1"] }))).toMatchObject({ result: null });
+    client.result = { rowCount: 0, rows: [] };
+    expect(await command.executeNative(new Native("SELECT 1"))).toEqual({
+      result: null,
+      rowsAffected: 0,
+      parameters: undefined,
+    });
+    client.result = { rowCount: 1, rows: [{ id: null }] };
+    expect(await command.executeNative(new Native("SELECT flag($b)"), [{ name: "b", value: true }])).toMatchObject({ result: null });
+    expect(await command.executeNative(new Native("SELECT when($d)"), [{ name: "d", value: new Date("2026-09-22T00:00:00.000Z") }])).toMatchObject({ result: null });
+    expect(await command.executeNative(new Native("SELECT blob($b)"), [{ name: "b", value: new Uint8Array([1, 2, 3]) }])).toMatchObject({ result: null });
+    const inout = { name: "result", value: 4, direction: ParameterDirection.InputOutput };
+    client.result = { rowCount: 1, rows: [{ result: { n: 1 } }] };
+    expect(await command.executeNative(new Native("CALL bump($result)"), [inout])).toMatchObject({
+      parameters: [{ name: "result", value: "{\"n\":1}", direction: ParameterDirection.InputOutput }],
+    });
+    client.result = { rowCount: 1, rows: [{ result: 5 }] };
+    expect(await command.executeStatement(new ExecuteStoredProcedureStatement("bump", [inout]), [inout])).toMatchObject({
+      result: null,
+      parameters: [{ name: "result", value: 5, direction: ParameterDirection.InputOutput }],
+    });
+    client.result = { rowCount: 1, rows: [{ id: 1 }] };
+    expect(
+      await command.executeNative(new Native("CALL noop($n)"), [
+        { name: "n", value: 1, direction: ParameterDirection.Input },
+      ]),
+    ).toMatchObject({ rowsAffected: 1 });
+    expect(await command.executeNative(new Native("CALL noop()"))).toMatchObject({ rowsAffected: 1 });
+    client.result = { rowCount: 1, rows: [{ other: 9 }] };
+    expect(
+      await command.executeNative(new Native("CALL bump($missing)"), [
+        { name: "missing", value: 1, direction: ParameterDirection.Output },
+      ]),
+    ).toMatchObject({
+      parameters: [{ name: "missing", value: 1, direction: ParameterDirection.Output }],
+    });
+  });
+});
+
+describe("Postgres datasource", () => {
+  it("registers and constructs children", async () => {
+    expect(
+      await new Datasource("postgres", new PostgresDriver()).createConnection(),
+    ).toBeInstanceOf(PostgresConnection);
+    const of = (): IDriver => ({
+      connection: () => new PostgresConnection({ Client: FakeClient }),
+      command: (c) => c.createCommand(),
+      transaction: (c, isolation = "readCommitted") =>
+        new PostgresTransaction(c as PostgresConnection, isolation),
+      rowTypeConverters: PostgresRowTypeConverters,
+      columnType,
+    });
+    const ds = new Datasource("postgres", of());
+    expect(ds.provider).toBe("postgres");
+    const connection = await ds.createConnection();
+    await (connection as PostgresConnection).open();
+    const command = await ds.createCommand(connection);
+    expect(command).toBeInstanceOf(PostgresCommand);
+    expect(command.connection).toBe(connection);
+    await command.execute("DELETE FROM items");
+    await command.executeReaderNative(new Native("SELECT 1"));
+    await expect(ds.createCommand()).rejects.toThrow("Connection is already open");
+    const repo = ds.createRepository(untyped(), connection);
+    expect(ds.createReadonlyRepository(untyped(), connection).constructor).toBe(ReadonlyRepository);
+    expect(repo).toBeInstanceOf(CRUDRepository);
+    expect(new Datasource("postgres", of()).createRepository(untyped())).toBeInstanceOf(CRUDRepository);
+    expect(Datasource.create({ PROVIDER: "postgres" }).provider).toBe("postgres");
+    const provided = PostgresConnection.from({
+      DATASOURCE_URL: "postgres://db/app?schema=s",
+    });
+    expect(provided.url).toBe("postgres://db/app?schema=s");
+    expect(provided.schema).toBe("s");
+    expect(PostgresConnection.from({ DATASOURCE_URL: "postgres://db/app?schema=app" }).schema).toBe("app");
+    expect(PostgresConnection.from().url).toBe("");
+    expect(PostgresConnection.from().schema).toBeUndefined();
+    const provider = new PostgresDriver();
+    expect(provider.columnType("int")).toBe("INTEGER");
+    expect(provider.columnType("uuid")).toBe("UUID");
+    expect(provider.columnType("string")).toBe("TEXT");
+    expect(provider.columnType("bool")).toBe("BOOLEAN");
+    expect(provider.columnType("decimal")).toBe("NUMERIC");
+    expect(provider.columnType("float")).toBe("DOUBLE PRECISION");
+    expect(provider.columnType("datetime")).toBe("TIMESTAMPTZ");
+    expect(provider.columnType("binary")).toBe("BYTEA");
+    expect(() => provider.columnType("xml")).toThrow('Unknown postgres type "xml"');
+    expect(provider.command(connection)).toBeInstanceOf(PostgresCommand);
+    expect(provider.transaction(connection as PostgresConnection).isolation).toBe("readCommitted");
+  });
+
+  it("maps property targets", () => {
+    const provider = new PostgresDriver();
+    const created = "2020-01-02T03:04:05.000Z";
+    const converter = RowTypeConverter.from(provider.rowTypeConverters, {
+      Key: "uuid",
+      Active: "bool",
+      Login: "string",
+      Created: "datetime",
+    });
+    const row = converter.convert({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: 1,
+      Login: "ada",
+      Created: created,
+    });
+    expect(row).toEqual({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: true,
+      Login: "ada",
+      Created: new Date(created),
+    });
+    expect(converter.reverseConvert(row)).toEqual({
+      Key: "11111111-1111-1111-1111-111111111111",
+      Active: true,
+      Login: "ada",
+      Created: created,
+    });
+  });
+});

package/src/transaction.ts

@@ -2,7 +2,7 @@ import {
   IsolationLevel,
   type ITransaction,
   type IsolationLevelName,
-} from "@deterministic-code/datasources";
+} from "@datasources/core";
 import type { PostgresConnection } from "./connection.ts";
 
 export class PostgresTransaction implements ITransaction {