@deterministic-code/datasources 0.1.1 → 0.1.3

package/src/builders/builders.test.ts

@@ -1,404 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  Aggregate,
-  ArrayExpression,
-  CheckConstraint,
-  ColumnDefault,
-  CreateIndexStatement,
-  CreateTableStatement,
-  CreateTableStatementTextRenderer,
-  DeleteStatement,
-  ForeignKey,
-  Identifier,
-  InsertStatement,
-  Join,
-  Literal,
-  NotNull,
-  Operator,
-  OrderBy,
-  PrimaryKey,
-  SelectStatement,
-  ReferentialAction,
-  ExpressionEvaluator,
-  StatementEvaluator,
-  ParameterDirection,
-  ReturnStatement,
-  UniqueConstraint,
-  ExecuteStoredProcedureStatement,
-  UpdateStatement,
-  WhereText,
-  Where,
-  eq,
-  ne,
-  gt,
-  lt,
-  ge,
-  le,
-  DefaultStatementTextRenderer,
-} from "../index.ts";
-import type { ITableConstraint, TableConstraintKind } from "../index.ts";
-import type { Parameter } from "../index.ts";
-
-describe("Query and Where", () => {
-  it("keeps optional where on the query", () => {
-    const select = new SelectStatement({ table: "dual", fields: ["1"] });
-    const where = new WhereText("id = 1");
-    const withWhere = new SelectStatement({ table: "dual", fields: ["1"], where });
-    expect(DefaultStatementTextRenderer.instance.render(select)).toBe("SELECT 1 FROM dual");
-    expect(select.where).toBeUndefined();
-    expect(withWhere.where).toBe(where);
-    expect(DefaultStatementTextRenderer.instance.render(where)).toBe("id = 1");
-  });
-});
-
-describe("Where", () => {
-  it("renders compare, groups, and not", () => {
-    const where = new Where(
-      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
-    );
-    expect(DefaultStatementTextRenderer.instance.render(where)).toBe("id = $id AND age > $age");
-    expect(where.parameters).toEqual([
-      { name: "id", value: 1 },
-      { name: "age", value: 18 },
-    ]);
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.NotEquals("id", 2)))).toBe("id <> $id");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.LessThan("n", 0)))).toBe("n < $n");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.GreaterThanOrEqual("n", 0)))).toBe("n >= $n");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.LessThanOrEqual("n", 0)))).toBe("n <= $n");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.Equals(new Literal(1), new Literal(1))))).toBe("1 = 1");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.Equals(new Literal(1), new Literal(0))))).toBe("1 = 0");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.Equals("id", 1)))).toBe("id = $id");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.Or(where, new Operator.Equals("name", "a"))))).toBe(
-      "(id = $id AND age > $age) OR name = $name",
-    );
-    expect(
-      DefaultStatementTextRenderer.instance.render(new Where(
-        new Operator.And(
-          new Operator.Or(new Operator.Equals("id", 1), new Operator.Equals("id", 2)),
-          new Operator.Equals("age", 18),
-        ),
-      )),
-    ).toBe("(id = $id OR id = $id) AND age = $age");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.Not(new Where(new Operator.Equals("id", 1)))))).toBe(
-      "NOT (id = $id)",
-    );
-    expect(new Where(new Operator.Not(new Where(new Operator.Equals("id", 1)))).parameters).toEqual([
-      { name: "id", value: 1 },
-    ]);
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.In("id", [])))).toBe("1 = 0");
-    expect(new Where(new Operator.In("id", [])).parameters).toEqual([]);
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.In("id", [1, 2])))).toBe("id IN ($id_0, $id_1)");
-    expect(new Where(new Operator.In("id", [1, 2])).parameters).toEqual([
-      { name: "id_0", value: 1 },
-      { name: "id_1", value: 2 },
-    ]);
-    const and = where.condition;
-    expect(and).toBeInstanceOf(Operator.And);
-    if (!(and instanceof Operator.And)) throw new Error("and");
-    expect(and.left).toBeInstanceOf(Operator.Equals);
-    if (!(and.left instanceof Operator.Equals)) throw new Error("left");
-    expect(and.left.left).toBeInstanceOf(Identifier);
-    if (!(and.left.left instanceof Identifier)) throw new Error("id");
-    expect(and.left.left.name).toBe("id");
-    expect(and.left.right).toBeInstanceOf(Literal);
-    if (!(and.left.right instanceof Literal)) throw new Error("lit");
-    expect(and.left.right.value).toBe(1);
-  });
-});
-
-describe("ExpressionEvaluator", () => {
-  it("evaluates compare, groups, not, and in", () => {
-    expect(new StatementEvaluator().evaluate(new SelectStatement({ table: "dual", fields: ["1"] }))).toBeUndefined();
-    const evaluator = new ExpressionEvaluator();
-    const row = { id: 1, age: 21, name: "a" };
-    expect(evaluator.evaluate(new Where(new Operator.Equals("id", 1)), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.Equals("id", 2)), row)).toBe(false);
-    expect(evaluator.evaluate(new Where(new Operator.NotEquals("id", 2)), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.GreaterThan("age", 18)), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.LessThan("age", 30)), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.GreaterThanOrEqual("age", 21)), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.LessThanOrEqual("age", 21)), row)).toBe(true);
-    expect(
-      evaluator.evaluate(
-        new Where(new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18))),
-        row,
-      ),
-    ).toBe(true);
-    expect(
-      evaluator.evaluate(
-        new Where(new Operator.Or(new Operator.Equals("id", 0), new Operator.Equals("name", "a"))),
-        row,
-      ),
-    ).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.Not(new Operator.Equals("id", 1))), row)).toBe(false);
-    expect(evaluator.evaluate(new Where(new Operator.In("id", [1, 2])), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.Equals(new Literal(1), new Literal(1))), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.Equals(new Literal(1), new Literal(0))), row)).toBe(false);
-    expect(() => evaluator.evaluate(new WhereText("id = 1"), row)).toThrow("text where is not evaluable");
-    expect(() => evaluator.evaluate(new ArrayExpression([]), row)).toThrow("array is not a scalar");
-    expect(() =>
-      evaluator.evaluate(new Operator.GreaterThan(new Literal(true), new Literal(1)), row),
-    ).toThrow("empty compare");
-    expect(() =>
-      evaluator.evaluate(new Operator.In(new Identifier("id"), new Literal(1)), row),
-    ).toThrow("empty in");
-    expect(evaluator.evaluate(new Where(new Operator.LessThan("name", "b")), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.GreaterThanOrEqual("name", "a")), row)).toBe(true);
-    expect(evaluator.evaluate(new Where(new Operator.GreaterThan("name", "Z")), row)).toBe(true);
-    expect(
-      DefaultStatementTextRenderer.instance.render(new Where(new Operator.In(new Identifier("id"), new ArrayExpression([])))),
-    ).toBe("1 = 0");
-    expect(new Where(new Identifier("id")).parameters).toEqual([]);
-    expect(new Where(new ArrayExpression([new Literal(1)])).parameters).toEqual([]);
-    expect(() => new Where(new WhereText("x")).parameters).toThrow("empty expression");
-    expect(
-      evaluator.evaluate(new Operator.GreaterThan(new Literal(2n), new Literal(1n)), row),
-    ).toBe(true);
-    expect(
-      DefaultStatementTextRenderer.instance.render(new Where(new Operator.Equals(new Identifier("a"), new Identifier("b")))),
-    ).toBe("a = b");
-    expect(
-      new Where(new Operator.Equals(new Identifier("a"), new Identifier("b"))).parameters,
-    ).toEqual([]);
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new Operator.In(new Literal(1), new Literal(2))))).toBe("1 IN 2");
-    expect(() => DefaultStatementTextRenderer.instance.render(new Where(new WhereText("x")))).toThrow("empty expression");
-    expect(evaluator.evaluate(new Identifier("missing"), row)).toBeNull();
-    expect(evaluator.evaluate(new Literal(null), row)).toBeNull();
-    expect(() => evaluator.evaluate(new WhereText("x"), row)).toThrow("text where is not evaluable");
-    expect(
-      DefaultStatementTextRenderer.instance.render(new Where(new Operator.Equals(new Literal(true), new Literal(false)))),
-    ).toBe("true = false");
-    expect(
-      DefaultStatementTextRenderer.instance.render(new Where(new Operator.Equals(new Literal(null), new Literal(null)))),
-    ).toBe("null = null");
-    expect(
-      new Where(new Operator.Equals(new Literal(true), new Literal(false))).parameters,
-    ).toEqual([]);
-    class Ghost extends Operator {}
-    expect(() => evaluator.evaluate(new Ghost(), row)).toThrow("empty expression");
-    expect(() => DefaultStatementTextRenderer.instance.render(new Where(new Ghost()))).toThrow("empty expression");
-    expect(() => new Where(new Ghost()).parameters).toThrow("empty expression");
-    expect(DefaultStatementTextRenderer.instance.render(new Where(new ArrayExpression([new Literal(1)])))).toBe("1");
-    expect(
-      () =>
-        new Where(
-          new Operator.In(new Identifier("id"), new ArrayExpression([new Identifier("x")])),
-        ).parameters,
-    ).toThrow("empty in");
-  });
-});
-
-describe("statements", () => {
-  const fields = [
-    { name: "id", value: 1 },
-    { name: "name", value: "a" },
-  ] as const;
-
-  it("creates write and ddl statements", () => {
-    const where = new Where(new Operator.Equals("id", 1));
-    const query = new SelectStatement({ table: "users", fields: ["id", "name"], where });
-    expect(DefaultStatementTextRenderer.instance.render(query)).toBe(
-      "SELECT id, name FROM users WHERE id = $id",
-    );
-    expect(query.where).toBe(where);
-    expect(DefaultStatementTextRenderer.instance.render(new SelectStatement({ table: "users", fields: [] }))).toBe(
-      "SELECT * FROM users",
-    );
-    expect(new SelectStatement({ table: "users", fields: [] }).where).toBeUndefined();
-    expect(DefaultStatementTextRenderer.instance.render(new SelectStatement({ table: "users", fields: ["id", "name"] }))).toBe(
-      "SELECT id, name FROM users",
-    );
-    expect(
-      DefaultStatementTextRenderer.instance.render(new SelectStatement({
-        table: "users",
-        fields: ["users.id", "orders.total"],
-        joins: [Join.inner("orders", "users.id", "orders.user_id")],
-      })),
-    ).toBe(
-      "SELECT users.id, orders.total FROM users INNER JOIN orders ON users.id = orders.user_id",
-    );
-    expect(
-      DefaultStatementTextRenderer.instance.render(new SelectStatement({
-        table: "users",
-        fields: ["users.id"],
-        where: new Where(new Operator.Equals("users.id", 1)),
-        joins: [
-          Join.inner("orders", "users.id", "orders.user_id"),
-          Join.left("payments", "orders.id", "payments.order_id"),
-          Join.right("profiles", "users.id", "profiles.user_id"),
-        ],
-      })),
-    ).toBe(
-      "SELECT users.id FROM users INNER JOIN orders ON users.id = orders.user_id LEFT JOIN payments ON orders.id = payments.order_id RIGHT JOIN profiles ON users.id = profiles.user_id WHERE users.id = $users.id",
-    );
-    expect(DefaultStatementTextRenderer.instance.render(new SelectStatement({ table: "users", fields: ["id"], joins: [] }))).toBe(
-      "SELECT id FROM users",
-    );
-    const grouped = new SelectStatement({
-      table: "orders",
-      fields: ["status", Aggregate.count("*", "n"), Aggregate.sum("amount", "total")],
-      where: new Where(new Operator.Equals("status", "open")),
-      joins: [Join.inner("customers", "orders.customer_id", "customers.id")],
-      groupBy: ["status"],
-      orderBy: [OrderBy.desc("total"), OrderBy.asc("status")],
-      limit: 10,
-    });
-    expect(DefaultStatementTextRenderer.instance.render(grouped)).toBe(
-      "SELECT status, COUNT(*) AS n, SUM(amount) AS total FROM orders INNER JOIN customers ON orders.customer_id = customers.id WHERE status = $status GROUP BY status ORDER BY total DESC, status ASC LIMIT 10",
-    );
-    const byStatus = new SelectStatement({ table: "users", fields: ["id"], groupBy: ["id"] });
-    expect(DefaultStatementTextRenderer.instance.render(byStatus)).toBe("SELECT id FROM users GROUP BY id");
-    const bounds = new SelectStatement({ table: "users", fields: [Aggregate.min("n"), Aggregate.max("n")] });
-    expect(DefaultStatementTextRenderer.instance.render(bounds)).toBe("SELECT MIN(n), MAX(n) FROM users");
-    const ordered = new SelectStatement({
-      table: "users",
-      fields: ["id"],
-      orderBy: [OrderBy.asc("id"), OrderBy.desc("name")],
-    });
-    expect(DefaultStatementTextRenderer.instance.render(ordered)).toBe("SELECT id FROM users ORDER BY id ASC, name DESC");
-    const limited = new SelectStatement({ table: "users", fields: ["id"], limit: 10 });
-    expect(DefaultStatementTextRenderer.instance.render(limited)).toBe("SELECT id FROM users LIMIT 10");
-    expect(DefaultStatementTextRenderer.instance.render(new SelectStatement({ table: "users", fields: ["id"], limit: 0 }))).toBe(
-      "SELECT id FROM users LIMIT 0",
-    );
-    expect(() =>
-      DefaultStatementTextRenderer.instance.render(
-        new SelectStatement({ table: "users", fields: ["id"], limit: -1 }),
-      ),
-    ).toThrow("negative limit");
-    const insert = new InsertStatement("users", [...fields]);
-    expect(DefaultStatementTextRenderer.instance.render(insert)).toBe(
-      "INSERT INTO users (id, name) VALUES ($id, $name)",
-    );
-    const update = new UpdateStatement("users", [...fields], where);
-    expect(DefaultStatementTextRenderer.instance.render(update)).toBe(
-      "UPDATE users SET id = $id, name = $name WHERE id = $id",
-    );
-    expect(update.where).toBe(where);
-    expect(DefaultStatementTextRenderer.instance.render(new UpdateStatement("users", [...fields]))).toBe(
-      "UPDATE users SET id = $id, name = $name",
-    );
-    const del = new DeleteStatement("users", where);
-    expect(DefaultStatementTextRenderer.instance.render(del)).toBe("DELETE FROM users WHERE id = $id");
-    expect(del.where).toBe(where);
-    expect(DefaultStatementTextRenderer.instance.render(new DeleteStatement("users"))).toBe(
-      "DELETE FROM users",
-    );
-    const createTable = new CreateTableStatement("users", [
-      { name: "id", type: "INTEGER" },
-      { name: "name", type: "TEXT" },
-    ]);
-    expect(DefaultStatementTextRenderer.instance.render(createTable)).toBe("CREATE TABLE users (id INTEGER, name TEXT)");
-    expect(new class extends CreateTableStatementTextRenderer {
-      override render(_statement: CreateTableStatement): string {
-        return "CREATE TABLE replaced";
-      }
-    }().render(createTable)).toBe("CREATE TABLE replaced");
-    const namedTable = new CreateTableStatement(
-      "orders",
-      [
-        { name: "id", type: "INTEGER", default: new ColumnDefault("0", "df_id"), notNull: new NotNull("nn_id") },
-        { name: "tenant_id", type: "INTEGER" },
-        { name: "user_id", type: "INTEGER" },
-        { name: "qty", type: "INTEGER" },
-      ],
-      [
-        new PrimaryKey("pk_orders", ["id", "tenant_id"]),
-        new ForeignKey("fk_orders_user", ["user_id"], "users", ["id"], ReferentialAction.Cascade),
-        new UniqueConstraint("uq_orders_user", ["user_id"]),
-        new CheckConstraint("chk_orders_qty", "qty > 0"),
-      ],
-    );
-    expect(DefaultStatementTextRenderer.instance.render(namedTable)).toBe(
-      "CREATE TABLE orders (id INTEGER CONSTRAINT df_id DEFAULT 0 CONSTRAINT nn_id NOT NULL, tenant_id INTEGER, user_id INTEGER, qty INTEGER, CONSTRAINT pk_orders PRIMARY KEY (id, tenant_id), CONSTRAINT fk_orders_user FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE, CONSTRAINT uq_orders_user UNIQUE (user_id), CONSTRAINT chk_orders_qty CHECK (qty > 0))",
-    );
-    expect(
-      DefaultStatementTextRenderer.instance.render(new CreateTableStatement(
-        "items",
-        [
-          { name: "id", type: "INTEGER", default: new ColumnDefault("0") },
-          { name: "name", type: "TEXT", notNull: new NotNull() },
-        ],
-        [new ForeignKey("fk_items_user", ["id"], "users", ["id"])],
-      )),
-    ).toBe(
-      "CREATE TABLE items (id INTEGER DEFAULT 0, name TEXT NOT NULL, CONSTRAINT fk_items_user FOREIGN KEY (id) REFERENCES users (id))",
-    );
-    expect(DefaultStatementTextRenderer.instance.render(new CreateTableStatement("users", [{ name: "id", type: "INTEGER" }], []))).toBe(
-      "CREATE TABLE users (id INTEGER)",
-    );
-    expect(
-      DefaultStatementTextRenderer.instance.render(new CreateTableStatement(
-        "t",
-        [{ name: "id", type: "INTEGER" }],
-        [new ForeignKey("fk_set_null", ["id"], "u", ["id"], ReferentialAction.SetNull, ReferentialAction.SetDefault)],
-      )),
-    ).toBe(
-      "CREATE TABLE t (id INTEGER, CONSTRAINT fk_set_null FOREIGN KEY (id) REFERENCES u (id) ON DELETE SET NULL ON UPDATE SET DEFAULT)",
-    );
-    expect(
-      DefaultStatementTextRenderer.instance.render(new CreateTableStatement(
-        "t",
-        [{ name: "id", type: "INTEGER" }],
-        [new ForeignKey("fk_restrict", ["id"], "u", ["id"], ReferentialAction.Restrict, ReferentialAction.NoAction)],
-      )),
-    ).toBe(
-      "CREATE TABLE t (id INTEGER, CONSTRAINT fk_restrict FOREIGN KEY (id) REFERENCES u (id) ON DELETE RESTRICT ON UPDATE NO ACTION)",
-    );
-    expect(() =>
-      DefaultStatementTextRenderer.instance.render(new CreateTableStatement("t", [{ name: "id", type: "INTEGER" }], [
-        { kind: "nope" as TableConstraintKind, name: "x" } as ITableConstraint,
-      ])),
-    ).toThrow("empty constraint");
-    const createIndex = new CreateIndexStatement("idx_orders_user", "orders", ["user_id"]);
-    expect(DefaultStatementTextRenderer.instance.render(createIndex)).toBe("CREATE INDEX idx_orders_user ON orders (user_id)");
-    expect(DefaultStatementTextRenderer.instance.render(new CreateIndexStatement("uq_orders_code", "orders", ["code"], true))).toBe(
-      "CREATE UNIQUE INDEX uq_orders_code ON orders (code)",
-    );
-    const call = new ExecuteStoredProcedureStatement("save", [...fields]);
-    expect(DefaultStatementTextRenderer.instance.render(call)).toBe("CALL save($id, $name)");
-    expect(DefaultStatementTextRenderer.instance.render(new ExecuteStoredProcedureStatement("save", []))).toBe(
-      "CALL save()",
-    );
-    const ret = new ReturnStatement("add", [...fields]);
-    expect(DefaultStatementTextRenderer.instance.render(ret)).toBe("SELECT add($id, $name)");
-    expect(DefaultStatementTextRenderer.instance.render(new ReturnStatement("add", []))).toBe("SELECT add()");
-    expect(
-      DefaultStatementTextRenderer.instance.render(new ExecuteStoredProcedureStatement("save", [
-        { name: "id", value: 1 },
-        { name: "ret", direction: ParameterDirection.ReturnValue },
-      ])),
-    ).toBe("CALL save($id)");
-    expect(
-      DefaultStatementTextRenderer.instance.render(new ReturnStatement("add", [
-        { name: "id", value: 1 },
-        { name: "ret", direction: ParameterDirection.ReturnValue },
-      ])),
-    ).toBe("SELECT add($id)");
-    const input: Parameter = { name: "id", value: 1 };
-    const output: Parameter = { name: "count", direction: ParameterDirection.Output };
-    expect(input.direction).toBeUndefined();
-    expect(output.direction).toBe(ParameterDirection.Output);
-  });
-});
-
-describe("comparison aliases", () => {
-  it("renders comparison symbols", () => {
-    const equals = new Where("username", eq, "grace");
-    const notEquals = new Where("id", ne, 2);
-    const greater = new Where("n", gt, 0);
-    const less = new Where("n", lt, 0);
-    const greaterOrEqual = new Where("n", ge, 0);
-    const lessOrEqual = new Where("n", le, 0);
-    const both = equals.and("is_enabled", eq, 0);
-    const either = equals.or("is_enabled", eq, 0);
-    expect(DefaultStatementTextRenderer.instance.render(equals)).toBe("username = $username");
-    expect(DefaultStatementTextRenderer.instance.render(notEquals)).toBe("id <> $id");
-    expect(DefaultStatementTextRenderer.instance.render(greater)).toBe("n > $n");
-    expect(DefaultStatementTextRenderer.instance.render(less)).toBe("n < $n");
-    expect(DefaultStatementTextRenderer.instance.render(greaterOrEqual)).toBe("n >= $n");
-    expect(DefaultStatementTextRenderer.instance.render(lessOrEqual)).toBe("n <= $n");
-    expect(DefaultStatementTextRenderer.instance.render(both)).toBe("username = $username AND is_enabled = $is_enabled");
-    expect(DefaultStatementTextRenderer.instance.render(either)).toBe("username = $username OR is_enabled = $is_enabled");
-  });
-});

package/src/builders/index.ts

@@ -1,2 +0,0 @@
-export type { Field } from "./Field.ts";
-export type { Scalar } from "./Scalar.ts";

package/src/collectAsync.ts

@@ -1,7 +0,0 @@
-export async function collectAsync<T>(items: AsyncIterable<T>): Promise<T[]> {
-  const collected: T[] = [];
-  for await (const item of items) {
-    collected.push(item);
-  }
-  return collected;
-}

package/src/converters/Cell.ts

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

package/src/converters/ChangeCasingConverter.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { ChangeCasingConverter, type Casing } from "./ChangeCasingConverter.ts";
-
-describe("ChangeCasingConverter", () => {
-  it("changes every casing variation", () => {
-    const forms: [Casing, string][] = [
-      ["camelCase", "twoWords"],
-      ["capitalCase", "Two Words"],
-      ["constantCase", "TWO_WORDS"],
-      ["dotCase", "two.words"],
-      ["kebabCase", "two-words"],
-      ["noCase", "two words"],
-      ["pascalCase", "TwoWords"],
-      ["pascalSnakeCase", "Two_Words"],
-      ["pathCase", "two/words"],
-      ["sentenceCase", "Two words"],
-      ["snakeCase", "two_words"],
-      ["trainCase", "Two-Words"],
-    ];
-    for (const [, from] of forms) {
-      for (const [casing, expected] of forms)
-        expect(new ChangeCasingConverter(casing).convert(from)).toBe(expected);
-      expect(new ChangeCasingConverter("snakeCase").reverseConvert(from)).toBe(from);
-    }
-    expect(new ChangeCasingConverter("camelCase").convert("XMLParser")).toBe("xmlParser");
-    expect(new ChangeCasingConverter("camelCase").convert("html5")).toBe("html5");
-    expect(new ChangeCasingConverter("camelCase").convert("v2Name")).toBe("v2Name");
-    expect(new ChangeCasingConverter("snakeCase").convert("")).toBe("");
-    expect(new ChangeCasingConverter("snakeCase").convert("___")).toBe("");
-    expect(new ChangeCasingConverter("snakeCase").convert(" two  words\t")).toBe("two_words");
-    expect(new ChangeCasingConverter("camelCase").convert("")).toBe("");
-    expect(() => new ChangeCasingConverter("nope" as Casing).convert("a")).toThrow();
-  });
-});

package/src/converters/ChangeCasingConverter.ts

@@ -1,59 +0,0 @@
-export type Casing =
-  | "camelCase"
-  | "capitalCase"
-  | "constantCase"
-  | "dotCase"
-  | "kebabCase"
-  | "noCase"
-  | "pascalCase"
-  | "pascalSnakeCase"
-  | "pathCase"
-  | "sentenceCase"
-  | "snakeCase"
-  | "trainCase";
-
-const cap = (word: string) => word[0].toUpperCase() + word.slice(1);
-const sep = (c: string) => c === "_" || c === "." || c === "-" || c === "/" || /\s/.test(c);
-const upper = (c: string) => c !== c.toLowerCase();
-const lower = (c: string) => c !== c.toUpperCase();
-const letter = (c: string) => upper(c) || lower(c);
-const digit = (c: string) => c >= "0" && c <= "9";
-
-const words = (text: string): string[] => {
-  const parts: string[] = [];
-  let start = 0;
-  for (let i = 0; i < text.length; i++) {
-    const split =
-      sep(text[i]) ||
-      (i > 0 && lower(text[i - 1]) && upper(text[i])) ||
-      (i > 0 && i + 1 < text.length && upper(text[i - 1]) && upper(text[i]) && lower(text[i + 1])) ||
-      (i > 0 && letter(text[i - 1]) !== letter(text[i]) && (letter(text[i - 1]) || digit(text[i - 1])) && (letter(text[i]) || digit(text[i])));
-    if (!split) continue;
-    if (i > start) parts.push(text.slice(start, i));
-    start = sep(text[i]) ? i + 1 : i;
-  }
-  if (start < text.length) parts.push(text.slice(start));
-  return parts.map((word) => word.toLowerCase()).filter((word) => word.length > 0);
-};
-
-const join = (parts: string[], casing: Casing): string =>
-  ({
-    camelCase: () => parts.map((word, i) => (i === 0 ? word : cap(word))).join(""),
-    capitalCase: () => parts.map(cap).join(" "),
-    constantCase: () => parts.map((word) => word.toUpperCase()).join("_"),
-    dotCase: () => parts.join("."),
-    kebabCase: () => parts.join("-"),
-    noCase: () => parts.join(" "),
-    pascalCase: () => parts.map(cap).join(""),
-    pascalSnakeCase: () => parts.map(cap).join("_"),
-    pathCase: () => parts.join("/"),
-    sentenceCase: () => parts.map((word, i) => (i === 0 ? cap(word) : word)).join(" "),
-    snakeCase: () => parts.join("_"),
-    trainCase: () => parts.map(cap).join("-"),
-  }[casing]());
-
-export class ChangeCasingConverter {
-  constructor(private readonly casing: Casing) {}
-  convert = (from: string) => join(words(from), this.casing);
-  reverseConvert = (to: string) => to;
-}

package/src/converters/Constructable.ts

@@ -1 +0,0 @@
-export type Constructable<T> = new () => T;

package/src/converters/MetaDataRowTypeConverter.ts

@@ -1,80 +0,0 @@
-import type { Cell, Cells } from "./Cell.ts";
-import { TypeConverter } from "./TypeConverter.ts";
-import type { Constructable } from "./Constructable.ts";
-import type { IMapper } from "../mappers/IMapper.ts";
-import { IdentityMapper } from "../mappers/IdentityMapper.ts";
-
-const scalarId = (value: Cell | object | undefined): Cell | undefined => {
-  if (value === undefined || value === null || typeof value !== "object" || value instanceof Date || value instanceof Uint8Array)
-    return value === undefined ? undefined : (value as Cell);
-  const record = value as Record<string, Cell | undefined>;
-  return record.Id !== undefined ? record.Id : record.id;
-};
-
-export class MetaDataRowTypeConverter<T = Cells> extends TypeConverter<T, Cells> {
-  fields: Record<string, TypeConverter<Cell, Cell>>;
-  references = new Set<string>();
-  referenceColumns: IMapper<string, string> = new IdentityMapper<string>();
-  shouldCoerceId = false;
-
-  constructor(fields: Record<string, TypeConverter<Cell, Cell>> = {}) {
-    super();
-    this.fields = { ...fields };
-  }
-
-  convert = (row: Cells, type?: Constructable<T>): T => {
-    const blank = type ? new type() : {};
-    const cells = Object.fromEntries(
-      Object.entries(row).filter(([key, value]) => {
-        if (this.references.has(key)) return false;
-        const current = (blank as Cells)[key];
-        return !(typeof current === "string" && typeof value !== "string" && value !== null);
-      }),
-    );
-    const dest = Object.assign(blank, cells) as T;
-    const record = dest as Record<string, Cell | object>;
-    for (const [key, value] of Object.entries(row)) {
-      if (this.references.has(key)) {
-        const current = record[key];
-        const target = current !== null && typeof current === "object" && !Array.isArray(current)
-          ? current as Record<string, Cell>
-          : {};
-        const id = "Id" in target ? "Id" : "id";
-        target[id] = value;
-        record[key] = target;
-        continue;
-      }
-      const converter = this.fields[key];
-      if (converter) record[key] = converter.convert(value);
-    }
-    return dest;
-  };
-
-  reverseConvert = (row: T): Cells => {
-    const cells: Cells = {};
-    for (const [key, value] of Object.entries(row as Record<string, Cell | object>)) {
-      if (Array.isArray(value)) continue;
-      if (
-        value !== null &&
-        typeof value === "object" &&
-        !(value instanceof Date) &&
-        !(value instanceof Uint8Array) &&
-        !this.references.has(key)
-      )
-        continue;
-      if (this.references.has(key)) {
-        const id = scalarId(value);
-        if (id !== undefined && id !== null) cells[this.referenceColumns.map(key)] = this.converted(key, id);
-        continue;
-      }
-      const converter = this.fields[key];
-      cells[key] = converter ? converter.reverseConvert(value as Cell) : (value as Cell);
-    }
-    return cells;
-  };
-
-  private converted = (key: string, value: Cell): Cell => {
-    const converter = this.fields[key];
-    return converter ? converter.reverseConvert(value) : value;
-  };
-}

package/src/converters/PluralizerConverter.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { PluralizerConverter } from "./PluralizerConverter.ts";
-
-describe("PluralizerConverter", () => {
-  it("pluralizes and singularizes", () => {
-    const pairs: [string, string][] = [
-      ["person", "people"],
-      ["child", "children"],
-      ["man", "men"],
-      ["woman", "women"],
-      ["mouse", "mice"],
-      ["goose", "geese"],
-      ["tooth", "teeth"],
-      ["foot", "feet"],
-      ["ox", "oxen"],
-      ["sheep", "sheep"],
-      ["fish", "fish"],
-      ["series", "series"],
-      ["species", "species"],
-      ["deer", "deer"],
-      ["news", "news"],
-      ["box", "boxes"],
-      ["dish", "dishes"],
-      ["church", "churches"],
-      ["quiz", "quizes"],
-      ["kiss", "kisses"],
-      ["bus", "buses"],
-      ["city", "cities"],
-      ["cat", "cats"],
-      ["toy", "toys"],
-      ["2y", "2ys"],
-      ["Person", "People"],
-      ["", ""],
-    ];
-    const converter = new PluralizerConverter();
-    for (const [singular, plural] of pairs) {
-      expect(converter.convert(singular)).toBe(plural);
-      expect(converter.convert(plural)).toBe(plural);
-      expect(converter.reverseConvert(plural)).toBe(singular);
-      expect(converter.reverseConvert(singular)).toBe(singular);
-    }
-  });
-});