@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/StatementMappers.test.ts

@@ -1,221 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { DictionaryMapper } from "./mappers/DictionaryMapper.ts";
-import { StatementMappers } from "./StatementMappers.ts";
-import { DefaultStatementTextRenderer } from "./statements/DefaultStatementTextRenderer.ts";
-import { DeleteStatement } from "./statements/DeleteStatement.ts";
-import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.ts";
-import { Identifier } from "./statements/Identifier.ts";
-import { InsertStatement } from "./statements/InsertStatement.ts";
-import { Join } from "./statements/Join.ts";
-import { Operator } from "./statements/Operator.ts";
-import { OrderBy } from "./statements/OrderBy.ts";
-import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.ts";
-import { SelectStatement } from "./statements/SelectStatement.ts";
-import { UpdateStatement } from "./statements/UpdateStatement.ts";
-import { Where } from "./statements/Where.ts";
-import { WhereText } from "./statements/WhereText.ts";
-import type { Cell } from "./converters/Cell.ts";
-
-const mapper = (name: string, value: Cell): Cell =>
-  typeof value === "string" ? `${name}:${value.toUpperCase()}` : value;
-
-describe("StatementMappers", () => {
-  it("maps a select", () => {
-    const mappings = new StatementMappers(
-      new DictionaryMapper([
-        ["User", "people"],
-        ["Role", "roles"],
-      ]),
-      new DictionaryMapper([
-        ["Name", "full_name"],
-        ["title", "book.title"],
-        ["id", "user_id"],
-      ]),
-    );
-    const select = new SelectStatement({
-      distinct: true,
-      table: "User",
-      fields: ["Name", "title", "scope.title", "alias.other", '"schema.name".id'],
-      where: new Where(new Operator.Equals("Name", "Bea")),
-      joins: [Join.inner("Role", "User.id", "Role.user_id"), Join.cross("logs")],
-      groupBy: ["Name"],
-      having: new Where(new Operator.Equals("Name", "Bea")),
-      orderBy: [OrderBy.desc("Name")],
-      limit: 5,
-      offset: 1,
-    });
-    const mapped = mappings.apply(select, mapper) as SelectStatement;
-    expect(mapped.table).toBe("people");
-    expect(mapped.fields).toEqual([
-      "full_name",
-      "book.title",
-      "book.title",
-      "alias.other",
-      '"schema.name".user_id',
-    ]);
-    expect(mapped.distinct).toBe(true);
-    expect(mapped.limit).toBe(5);
-    expect(mapped.offset).toBe(1);
-    expect(mapped.groupBy).toEqual(["full_name"]);
-    expect(mapped.orderBy).toEqual([{ column: "full_name", direction: "desc" }]);
-    expect((mapped.joins[0]?.on as Operator.Equals).left).toBeInstanceOf(Identifier);
-    expect(((mapped.joins[0]?.on as Operator.Equals).left as Identifier).name).toBe("people.user_id");
-    expect(mapped.joins[1]).toEqual({ kind: "cross", table: "logs" });
-    expect(DefaultStatementTextRenderer.instance.render(mapped)).toContain("full_name = $full_name");
-    expect(mapped.where?.parameters?.[0]?.value).toBe("Name:BEA");
-    expect(mappings.property("full_name")).toBe("Name");
-    expect(mappings.property("people.full_name")).toBe("Name");
-    expect(mappings.property("other")).toBe("other");
-    expect(mappings.property("people.missing")).toBe("people.missing");
-  });
-
-  it("maps writes", () => {
-    const mappings = new StatementMappers(
-      new DictionaryMapper([
-        ["User", "people"],
-        ["Role", "roles"],
-      ]),
-      new DictionaryMapper([
-        ["Name", "full_name"],
-        ["title", "book.title"],
-        ["id", "user_id"],
-      ]),
-    );
-    const insert = mappings.apply(new InsertStatement("User", [{ name: "Name", value: "Ada" }]), mapper) as InsertStatement;
-    expect(DefaultStatementTextRenderer.instance.render(insert)).toBe("INSERT INTO people (full_name) VALUES ($full_name)");
-    expect(insert.fields[0]?.value).toBe("Ada");
-
-    const update = mappings.apply(
-      new UpdateStatement("User", [{ name: "Name", value: "Ada" }], new Where(new Operator.Equals("Name", "Bea"))),
-      mapper,
-    ) as UpdateStatement;
-    expect(DefaultStatementTextRenderer.instance.render(update)).toBe(
-      "UPDATE people SET full_name = $full_name WHERE full_name = $full_name__where",
-    );
-    expect(update.parameters[0]?.value).toBe("Ada");
-    expect(update.parameters[1]).toEqual({ name: "full_name__where", value: "Name:BEA" });
-
-    const deleted = mappings.apply(
-      new DeleteStatement("User", new Where(new Operator.Equals("Name", "Bea"))),
-      mapper,
-    ) as DeleteStatement;
-    expect(DefaultStatementTextRenderer.instance.render(deleted)).toBe("DELETE FROM people WHERE full_name = $full_name");
-
-    const inserted = mappings.apply(new SelectInsertedIdStatement("User", "id"), mapper) as SelectInsertedIdStatement;
-    expect(inserted.table).toBe("people");
-    expect(inserted.column).toBe("user_id");
-  });
-
-  it("leaves raw and other statements", () => {
-    const mappings = new StatementMappers(
-      new DictionaryMapper([
-        ["User", "people"],
-        ["Role", "roles"],
-      ]),
-      new DictionaryMapper([
-        ["Name", "full_name"],
-        ["title", "book.title"],
-        ["id", "user_id"],
-      ]),
-    );
-    const call = new ExecuteStoredProcedureStatement("save_user", []);
-    expect(mappings.apply(call, mapper)).toBe(call);
-    expect(mappings.apply(undefined, mapper)).toBeUndefined();
-    const text = new WhereText("name = $name");
-    expect(mappings.applyWhere(text, mapper)).toBe(text);
-    const kept = mappings.apply(new DeleteStatement("User", text), mapper) as DeleteStatement;
-    expect(kept.where).toBe(text);
-    expect(DefaultStatementTextRenderer.instance.render(kept)).toBe("DELETE FROM people WHERE name = $name");
-  });
-
-  it("maps a select field alias", () => {
-    const mappings = new StatementMappers(
-      new DictionaryMapper([
-        ["Contact", "contacts_base"],
-        ["Address", "address"],
-      ]),
-      new DictionaryMapper([
-        ["Id", "id"],
-        ["FirstName", "first_name"],
-        ["ContactId", "contact_id"],
-      ]),
-    );
-    const select = new SelectStatement({
-      table: "Contact",
-      fields: ["Contact.Id AS Id", "Contact.FirstName AS FirstName", "Address.Id AS AddressId"],
-      joins: [Join.left("Address", "Contact.Id", "Address.ContactId")],
-    });
-    const mapped = mappings.apply(select, mapper) as SelectStatement;
-    expect(DefaultStatementTextRenderer.instance.render(mapped)).toBe(
-      "SELECT contacts_base.id AS Id, contacts_base.first_name AS FirstName, address.id AS AddressId FROM contacts_base LEFT JOIN address ON contacts_base.id = address.contact_id",
-    );
-  });
-
-  it("maps a contacts select", () => {
-    const mappings = new StatementMappers(
-      new DictionaryMapper([
-        ["Contact", "contacts_base"],
-        ["ContactSource", "contact_source"],
-        ["ContactType", "contact_type"],
-        ["Address", "address"],
-        ["AddressType", "address_type"],
-        ["Phone", "phone"],
-        ["PhoneType", "phone_type"],
-      ]),
-      new DictionaryMapper([
-        ["Id", "id"],
-        ["FirstName", "first_name"],
-        ["LastName", "last_name"],
-        ["Email", "email"],
-        ["Name", "name"],
-        ["Line1", "line1"],
-        ["City", "city"],
-        ["Number", "number"],
-        ["ContactId", "contact_id"],
-        ["ContactSourceId", "contact_source_id"],
-        ["ContactTypeId", "contact_type_id"],
-        ["AddressTypeId", "address_type_id"],
-        ["PhoneTypeId", "phone_type_id"],
-      ]),
-    );
-    const select = new SelectStatement({
-      distinct: true,
-      table: "Contact",
-      fields: [
-        "Contact.FirstName",
-        "Contact.LastName",
-        "Contact.Email",
-        "ContactSource.Name",
-        "Address.Line1",
-        "Address.City",
-        "Phone.Number",
-      ],
-      where: new Where(
-        new Operator.And(
-          new Operator.Equals("Contact.Email", "ada@ex.com"),
-          new Operator.GreaterThan("Address.City", "A"),
-        ),
-      ),
-      joins: [
-        Join.inner("ContactSource", "Contact.ContactSourceId", "ContactSource.Id"),
-        Join.inner("ContactType", "Contact.ContactTypeId", "ContactType.Id"),
-        Join.left("Address", "Contact.Id", "Address.ContactId"),
-        Join.left("AddressType", "Address.AddressTypeId", "AddressType.Id"),
-        Join.left("Phone", "Contact.Id", "Phone.ContactId"),
-        Join.left("PhoneType", "Phone.PhoneTypeId", "PhoneType.Id"),
-      ],
-      groupBy: ["Contact.LastName"],
-      having: new Where(new Operator.Equals("ContactType.Name", "person")),
-      orderBy: [OrderBy.asc("Contact.LastName"), OrderBy.desc("Contact.FirstName")],
-      limit: 20,
-      offset: 1,
-    });
-    const mapped = mappings.apply(select, mapper) as SelectStatement;
-    expect(DefaultStatementTextRenderer.instance.render(mapped)).toBe(
-      "SELECT DISTINCT contacts_base.first_name, contacts_base.last_name, contacts_base.email, contact_source.name, address.line1, address.city, phone.number FROM contacts_base INNER JOIN contact_source ON contacts_base.contact_source_id = contact_source.id INNER JOIN contact_type ON contacts_base.contact_type_id = contact_type.id LEFT JOIN address ON contacts_base.id = address.contact_id LEFT JOIN address_type ON address.address_type_id = address_type.id LEFT JOIN phone ON contacts_base.id = phone.contact_id LEFT JOIN phone_type ON phone.phone_type_id = phone_type.id WHERE contacts_base.email = $contacts_base.email AND address.city > $address.city GROUP BY contacts_base.last_name HAVING contact_type.name = $contact_type.name ORDER BY contacts_base.last_name ASC, contacts_base.first_name DESC LIMIT 20 OFFSET 1",
-    );
-    expect(mapped.where?.parameters[0]?.value).toBe("Contact.Email:ADA@EX.COM");
-    expect(mapped.where?.parameters[1]?.value).toBe("Address.City:A");
-    expect((mapped.having as Where).parameters[0]?.value).toBe("ContactType.Name:PERSON");
-  });
-});

package/src/StatementMappers.ts

@@ -1,110 +0,0 @@
-import type { Cell } from "./converters/Cell.ts";
-import type { IMapper } from "./mappers/IMapper.ts";
-import { DeleteStatement } from "./statements/DeleteStatement.ts";
-import type { IStatement } from "./statements/IStatement.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-import { InsertStatement } from "./statements/InsertStatement.ts";
-import { SelectInsertedIdStatement } from "./statements/SelectInsertedIdStatement.ts";
-import { SelectStatement } from "./statements/SelectStatement.ts";
-import { UpdateStatement } from "./statements/UpdateStatement.ts";
-import { Where } from "./statements/Where.ts";
-
-export class StatementMappers implements IMapper<string, string> {
-  constructor(
-    private readonly entityMappers: IMapper<string, string>,
-    private readonly propertyMappers: IMapper<string, string>,
-  ) {}
-
-  map = (property: string): string => {
-    const dot = lastDot(property);
-    if (dot < 0) return this.propertyMappers.map(property);
-    const qualifier = property.slice(0, dot);
-    const name = property.slice(dot + 1);
-    const mapped = this.propertyMappers.map(name);
-    if (mapped !== name && mapped.includes(".")) return mapped;
-    const table = this.entityMappers.map(qualifier);
-    return table === qualifier && mapped === name ? property : `${table}.${mapped}`;
-  };
-
-  reverseMap = (key: string): string => {
-    const reversed = this.propertyMappers.reverseMap(key);
-    if (reversed !== key && this.propertyMappers.map(reversed) === key) return reversed;
-    const dot = lastDot(key);
-    if (dot < 0) return reversed;
-    const column = key.slice(dot + 1);
-    const name = this.propertyMappers.reverseMap(column);
-    return name !== column && this.propertyMappers.map(name) === column ? name : reversed;
-  };
-
-  column = (property: string): string => this.map(property);
-
-  property = (key: string): string => this.reverseMap(key);
-
-  apply = (
-    query: IStatement | undefined,
-    cell: (property: string, value: Cell) => Cell,
-  ): IStatement | undefined => {
-    if (query instanceof SelectStatement && query.table)
-      return new SelectStatement({
-        distinct: query.distinct,
-        table: this.entityMappers.map(query.table),
-        fields: query.fields.map(this.mapSelectField),
-        where: query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
-        joins: query.joins.map((join) => ({
-          kind: join.kind,
-          table: this.entityMappers.map(join.table),
-          on: join.on ? new Where(join.on).map(this.column, cell).condition : undefined,
-        })),
-        groupBy: query.groupBy.map(this.column),
-        having: query.having instanceof Where ? this.applyWhere(query.having, cell) : query.having,
-        orderBy: query.orderBy.map((order) => ({ column: this.column(order.column), direction: order.direction })),
-        limit: query.limit,
-        offset: query.offset,
-      });
-    if (query instanceof InsertStatement && query.table !== undefined)
-      return new InsertStatement(
-        this.entityMappers.map(query.table),
-        query.fields.map((field) => ({ name: this.column(field.name), value: field.value })),
-      );
-    if (query instanceof UpdateStatement && query.table !== undefined)
-      return new UpdateStatement(
-        this.entityMappers.map(query.table),
-        query.fields.map((field) => ({ name: this.column(field.name), value: field.value })),
-        query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
-      );
-    if (query instanceof DeleteStatement && query.table !== undefined)
-      return new DeleteStatement(
-        this.entityMappers.map(query.table),
-        query.where instanceof Where ? this.applyWhere(query.where, cell) : query.where,
-      );
-    if (query instanceof SelectInsertedIdStatement)
-      return new SelectInsertedIdStatement(this.entityMappers.map(query.table), this.column(query.column));
-    return query;
-  };
-
-  applyWhere = (
-    where: IWhere | undefined,
-    cell: (property: string, value: Cell) => Cell,
-  ): IWhere | undefined =>
-    where instanceof Where ? where.map(this.column, cell) : where;
-
-  private mapSelectField = (field: string): string => {
-    const asIndex = field.toUpperCase().indexOf(" AS ");
-    if (asIndex >= 0) {
-      const expression = field.slice(0, asIndex).trim();
-      const alias = field.slice(asIndex + 4).trim();
-      return `${this.map(expression)} AS ${alias}`;
-    }
-    return this.map(field);
-  };
-}
-
-const lastDot = (name: string): number => {
-  let quoted = false;
-  let dot = -1;
-  for (let i = 0; i < name.length; i++) {
-    if (name[i] === '"') quoted = !quoted;
-    if (name[i] === "." && !quoted) dot = i;
-  }
-  return dot;
-};

package/src/StoredEnrichment.ts

@@ -1,25 +0,0 @@
-import type { Enrichment } from "./Enrichment.ts";
-import type { ICRUDRepository } from "./ICRUDRepository.ts";
-import type { Row } from "./Row.ts";
-
-export type ApplyEnrichment<T extends object = object> = (
-  parents: T[],
-  sources?: (Row | undefined)[],
-) => Promise<void>;
-
-export class StoredEnrichment<T extends object = object> {
-  apply: ApplyEnrichment<T>;
-  persist?: ICRUDRepository<object>;
-  link?: ICRUDRepository<object>;
-
-  constructor(
-    readonly enrichment: Enrichment,
-    apply: ApplyEnrichment<T>,
-    persist?: ICRUDRepository<object>,
-    link?: ICRUDRepository<object>,
-  ) {
-    this.apply = apply;
-    this.persist = persist;
-    this.link = link;
-  }
-}

package/src/StoredProcedureBulkWriteStrategy.ts

@@ -1,164 +0,0 @@
-import type { Cell, Cells } from "./converters/Cell.ts";
-import { DatasourceError } from "./DatasourceError.ts";
-import type { Response } from "./Response.ts";
-import type { IWhere } from "./statements/IWhere.ts";
-import { ExecuteStoredProcedureStatement } from "./statements/ExecuteStoredProcedureStatement.ts";
-import type { CRUDRepository } from "./CRUDRepository.ts";
-import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
-import type { ICommand } from "./ICommand.ts";
-import { execute } from "./ICommand.ts";
-import type { IBulkWriteStrategy } from "./IBulkWriteStrategy.ts";
-import { repositoryParts } from "./CRUDRepositoryBuilder.ts";
-import { MetaDataRowTypeConverter } from "./converters/MetaDataRowTypeConverter.ts";
-import { afterBulkWrite } from "./BulkWriteEnrichment.ts";
-import { ParameterDirection } from "./ParameterDirection.ts";
-import type { Parameter } from "./Parameter.ts";
-
-const empty = (): Response => ({ result: null, rowsAffected: 0 });
-
-const json = (rows: Cells[]): string => `[${rows.map(object).join(",")}]`;
-
-const object = (row: Cells): string =>
-  `{${Object.entries(row)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([key, value]) => `${quote(key)}:${scalar(value)}`)
-    .join(",")}}`;
-
-const scalar = (value: Cell): string => {
-  if (value === null || value === undefined) return "null";
-  if (typeof value === "boolean") return value ? "true" : "false";
-  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : fail();
-  if (typeof value === "bigint") return value.toString();
-  if (typeof value === "string") return quote(value);
-  if (value instanceof Date) return quote(roundTrip(value));
-  if (value instanceof Uint8Array) return quote(base64(value));
-  return fail();
-};
-
-const fail = (): string => {
-  throw new DatasourceError("Unsupported bulk payload value");
-};
-
-const roundTrip = (date: Date): string =>
-  date.toISOString().replace(/\.(\d{3})Z$/, (_, fraction: string) => `.${fraction}0000Z`);
-
-const base64 = (bytes: Uint8Array): string =>
-  btoa(Array.from(bytes, (byte) => String.fromCharCode(byte)).join(""));
-
-const quote = (text: string): string => {
-  let result = "\"";
-  for (const ch of text) {
-    result += ({
-      "\\": "\\\\",
-      "\"": "\\\"",
-      "\b": "\\b",
-      "\f": "\\f",
-      "\n": "\\n",
-      "\r": "\\r",
-      "\t": "\\t",
-    }[ch] ?? (ch < " " ? `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}` : ch));
-  }
-  return `${result}"`;
-};
-
-export class StoredProcedureBulkWriteStrategy<T extends object> implements IBulkWriteStrategy<T> {
-  repo!: CRUDRepository<T>;
-  command!: ICommand;
-  options!: CRUDRepositoryOptions<T>;
-
-  attach = (command: ICommand, options: CRUDRepositoryOptions<T>): void => {
-    this.command = command;
-    this.options = options;
-  };
-
-  constructor(
-    private readonly createName: string,
-    private readonly updateName: string,
-    private readonly deleteName: string,
-  ) {}
-
-  create = (items: T[]): Promise<Response> => this.then(this.call(this.createName, items, true), items, "create");
-
-  update = (items: T[], _byWhere: IWhere | undefined): Promise<Response> =>
-    this.then(this.call(this.updateName, items), items, "update");
-
-  delete = (items: T[], _byWhere: IWhere | undefined): Promise<Response> =>
-    this.then(this.call(this.deleteName, items), items, "delete");
-
-  private then = async (write: Promise<Response>, items: T[], mode: "create" | "update" | "delete"): Promise<Response> => {
-    const response = await write;
-    await afterBulkWrite(this.repo, this.options, items, mode);
-    return response;
-  };
-
-  private call = async (name: string, items: T[], generated = false): Promise<Response> => {
-    if (items.length === 0) return empty();
-    const payload = { name: "payload", value: json(items.map((item) => this.rowOf(item, generated))) };
-      const parameters: Parameter[] = generated && this.ids().length === 1
-      ? [payload, { name: "ids", value: null, direction: ParameterDirection.InputOutput }]
-      : [payload];
-    const response = await execute(this.command, new ExecuteStoredProcedureStatement(name, parameters), parameters);
-    if (generated) this.applyIds(items, response.parameters);
-    return response;
-  };
-
-  private ids = (): readonly string[] => this.options.ids ?? this.repo.ids ?? ["id"];
-
-  private rowOf = (item: T, create = false): Cells => {
-    const stored = this.reverse(item);
-    const statements = repositoryParts(this.command.connection, this.options).statements;
-    const row: Cells = {};
-    for (const name of statements.readColumns) {
-      if (create && this.identity(name) && !assigned(stored[name] ?? stored[this.ids()[0]!])) continue;
-      const match = Object.entries(stored).find(([key]) => this.column(key) === name);
-      row[name] = match?.[1] ?? null;
-    }
-    return row;
-  };
-
-  private identity = (column: string): boolean => this.ids().length === 1 && this.ids()[0] === column;
-
-  private applyIds = (items: T[], parameters?: Parameter[]): void => {
-    if (this.ids().length !== 1) return;
-    const found = parameters?.find((parameter) => parameter.name === "ids");
-    const list = parseIds(found?.value);
-    const column = this.ids()[0]!;
-    for (let index = 0; index < items.length && index < list.length; index++)
-      stamp(items[index], column, list[index]!);
-  };
-
-  private column = (property: string): string => this.options.propertyMappings?.map(property) ?? property;
-
-  private reverse = (item: T): Cells => {
-    const objects = this.options.objectConverter ?? new MetaDataRowTypeConverter<T>();
-    const row = objects.reverseConvert(item);
-    return this.options.rowConverter ? this.options.rowConverter.reverseConvert(row) : row;
-  };
-}
-
-const assigned = (value: Cell | undefined): boolean => {
-  if (value === null || value === undefined) return false;
-  if (value === 0 || value === 0n) return false;
-  if (typeof value === "string") return value.length > 0;
-  return true;
-};
-
-const parseIds = (value: Cell | undefined): number[] => {
-  const text =
-    typeof value === "string" ? value.trim()
-    : typeof value === "number" || typeof value === "bigint" ? String(value)
-    : "";
-  if (text === "" || text === "[]" || text === "null") return [];
-  return text
-    .replace(/^\[/, "")
-    .replace(/\]$/, "")
-    .split(",")
-    .map((part) => part.trim())
-    .filter(Boolean)
-    .map((part) => Number(part));
-};
-
-const stamp = <T extends object>(item: T, column: string, id: number): void => {
-  const key = column in item ? column : "id" in item ? "id" : "Id" in item ? "Id" : column;
-  (item as Record<string, Cell>)[key] = id;
-};

package/src/StreamingReader.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { splitStatements, statementParameters, statementUsesParameter, statementReader, StreamingReader } from "./index.ts";
-
-describe("splitStatements", () => {
-  it("splits on semicolons outside quotes and comments", () => {
-    expect(splitStatements("")).toEqual([]);
-    expect(splitStatements("SELECT 1")).toEqual(["SELECT 1"]);
-    expect(splitStatements("SELECT 1;")).toEqual(["SELECT 1"]);
-    expect(splitStatements("SELECT 1 AS id; SELECT 2 AS id")).toEqual([
-      "SELECT 1 AS id",
-      "SELECT 2 AS id",
-    ]);
-    expect(splitStatements("SELECT ';' AS id; SELECT 2 AS id")).toEqual([
-      "SELECT ';' AS id",
-      "SELECT 2 AS id",
-    ]);
-    expect(splitStatements('SELECT "a""b" AS id; SELECT `c`')).toEqual([
-      'SELECT "a""b" AS id',
-      "SELECT `c`",
-    ]);
-    expect(splitStatements("SELECT 1; -- tail\nSELECT 2")).toEqual([
-      "SELECT 1",
-      "-- tail\nSELECT 2",
-    ]);
-    expect(splitStatements("SELECT 1; /* ; */ SELECT 2")).toEqual([
-      "SELECT 1",
-      "/* ; */ SELECT 2",
-    ]);
-    const mysql = "CREATE PROCEDURE add_user()\nBEGIN\n  INSERT INTO t VALUES (1);\nEND";
-    expect(splitStatements(mysql)).toEqual([mysql]);
-    const postgres =
-      "CREATE PROCEDURE bulk_create_user(payload jsonb)\nLANGUAGE plpgsql\nAS $$\nBEGIN\n  INSERT INTO t VALUES (1);\nEND;\n$$";
-    expect(splitStatements(postgres)).toEqual([postgres]);
-  });
-
-  it("matches a parameter token at a word boundary", () => {
-    expect(statementUsesParameter("INSERT INTO t (is_enabled) VALUES ($is_enabled__10)", "is_enabled__10")).toBe(true);
-    expect(statementUsesParameter("INSERT INTO t (is_enabled) VALUES ($is_enabled__10)", "is_enabled__1")).toBe(false);
-    expect(statementUsesParameter("$is_enabled__1", "is_enabled__1")).toBe(true);
-    expect(statementParameters("INSERT INTO t (a, b) VALUES ($a__0, $b__0), ($a__1, $b__1)")).toEqual([
-      "a__0",
-      "b__0",
-      "a__1",
-      "b__1",
-    ]);
-  });
-});
-
-describe("StreamingReader", () => {
-  it("reads the current set and advances on nextResult", async () => {
-    const sets = [[{ id: 1 }], [{ id: 2 }]];
-    let set = 0;
-    let row = 0;
-    let reads = 0;
-    let closed = false;
-    const reader = new StreamingReader(
-      async () => {
-        reads += 1;
-        const rows = sets[set] ?? [];
-        if (row >= rows.length) return undefined;
-        const current = rows[row];
-        row += 1;
-        return current;
-      },
-      async () => {
-        set += 1;
-        row = 0;
-        return set < sets.length;
-      },
-      async () => {
-        closed = true;
-      },
-    );
-    expect(reads).toBe(0);
-    expect(await reader.next()).toBe(true);
-    expect(reader.current).toEqual({ id: 1 });
-    expect(await reader.next()).toBe(false);
-    expect(reader.current).toBeUndefined();
-    expect(await reader.nextResult()).toBe(true);
-    expect(reader.current).toBeUndefined();
-    expect(await reader.next()).toBe(true);
-    expect(reader.current).toEqual({ id: 2 });
-    expect(await reader.nextResult()).toBe(false);
-    await reader.dispose();
-    await reader.dispose();
-    expect(closed).toBe(true);
-    const plain = new StreamingReader(
-      async () => undefined,
-      async () => false,
-    );
-    expect(await Array.fromAsync(plain.read())).toEqual([]);
-    await plain.dispose();
-    await plain[Symbol.asyncDispose]();
-    await plain.dispose();
-  });
-
-  it("loads one statement at a time", async () => {
-    const loaded: string[] = [];
-    const reader = statementReader(["SELECT 1 AS id", "SELECT 2 AS id"], async function* (sql) {
-      loaded.push(sql);
-      yield sql.endsWith("1 AS id") ? { id: 1 } : { id: 2 };
-    });
-    expect(loaded).toEqual([]);
-    expect(await reader.next()).toBe(true);
-    expect(reader.current).toEqual({ id: 1 });
-    expect(await reader.next()).toBe(false);
-    expect(loaded).toEqual(["SELECT 1 AS id"]);
-    expect(await reader.nextResult()).toBe(true);
-    expect(await reader.next()).toBe(true);
-    expect(reader.current).toEqual({ id: 2 });
-    expect(await reader.nextResult()).toBe(false);
-    expect(await reader.next()).toBe(false);
-    expect(loaded).toEqual(["SELECT 1 AS id", "SELECT 2 AS id"]);
-    await reader.dispose();
-  });
-
-  it("returns false when a statement reader has no statements", async () => {
-    const reader = statementReader([], async function* () {});
-    expect(await reader.next()).toBe(false);
-    expect(await reader.nextResult()).toBe(false);
-    const blank = statementReader([""], async function* () {
-      yield { id: 1 };
-    });
-    expect(await blank.next()).toBe(false);
-  });
-});