@deterministic-code/datasources-postgres 0.1.1 → 0.1.2

package/src/command.ts

@@ -1,129 +0,0 @@
-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 "@datasources/core";
-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

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

package/src/connection.ts

@@ -1,95 +0,0 @@
-import {
-  DatasourceError,
-  DatasourceUrlParser,
-  IsolationLevel,
-  StatementTextRenderer,
-  type DatasourceOptions,
-  type ICommand,
-  type IConnection,
-  type IsolationLevelName,
-  type ITransaction,
-} from "@datasources/core";
-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.test.ts

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

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

@@ -1,13 +0,0 @@
-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,11 +0,0 @@
-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));
-
-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.test.ts

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

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

@@ -1,11 +0,0 @@
-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,6 +0,0 @@
-import { TypeConverter, type Cell } from "@datasources/core";
-
-export class UuidConverter extends TypeConverter<Cell, Cell> {
-  convert = (from: Cell): Cell => from;
-  reverseConvert = (to: Cell): Cell => to;
-}

package/src/i-postgres-driver.ts

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

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