@deterministic-code/datasources 0.1.0 → 0.1.1

package/src/repository.test.ts

@@ -0,0 +1,410 @@
+import { describe, expect, it } from "vitest";
+import {
+  CRUDRepository,
+  DefaultStatementTextRenderer,
+  ExecuteStoredProcedureStatement,
+  SelectStatement,
+  MetaDataRowTypeConverter,
+  TransformMapper,
+  WhereText,
+  Where,
+  Operator,
+  CRUDRepositoryBuilder,
+  ReadonlyRepositoryBuilder,
+  createCRUDRepositoryOptions,
+} from "./index.ts";
+import { MockCommand } from "./mocks/mock-command.ts";
+import { MockConnection } from "./mocks/mock-connection.ts";
+import { MockReader } from "./mocks/mock-reader.ts";
+import type { Cell, Cells } from "./converters/Cell.ts";
+import { TypeConverter } from "./converters/TypeConverter.ts";
+import type { Constructable } from "./converters/Constructable.ts";
+import type { CRUDRepositoryOptions } from "./CRUDRepositoryOptions.ts";
+
+class Item {
+  id = 0;
+  name = "";
+}
+
+class Label {
+  name = "";
+}
+
+class PascalId {
+  Id = 0;
+}
+
+class Composite {
+  org_id = 0;
+  user_id = 0;
+  name = "";
+}
+
+const asType = <T>(type: new () => T) => type as Constructable<Cells>;
+
+const create = (overrides: Partial<CRUDRepositoryOptions<Cells>> = {}) => {
+  const connection = new MockConnection(undefined, "memory");
+  const command = new MockCommand(connection);
+  connection.command = command;
+  const type = overrides.type ?? asType(Item);
+  const options = {
+    ...overrides,
+    type,
+    entity: overrides.entity ?? "users",
+    objectConverter: overrides.objectConverter ?? new MetaDataRowTypeConverter(),
+  };
+  const repo = new CRUDRepository<Cells>(connection, options);
+  return { repo, command };
+};
+
+describe("CRUDRepository", () => {
+  it("builds select and maps rows", async () => {
+    const { repo, command } = create();
+    repo.addMiddleware({ beforeCommand() {}, afterCommand() {} });
+    command.reader = new MockReader([
+      { id: 1, name: "a" },
+    ]);
+    const rows: Cells[] = [];
+    for await (const row of repo.read()) rows.push(row);
+    expect(rows).toEqual([{ id: 1, name: "a" }]);
+    expect(command.executeReaderCalls[0]?.text).toBe("SELECT id, name FROM users");
+    command.reader = new MockReader([{ id: 1, name: "a" }]);
+    expect(await repo.readSingle()).toEqual({ id: 1, name: "a" });
+  });
+
+  it("uses caller query and returns empty", async () => {
+    const { repo, command } = create();
+    command.reader = new MockReader([]);
+    const where = new Where(new Operator.Equals("id", 9));
+    expect(
+      await repo.readSingle(new SelectStatement({ table: "users", fields: ["id"], where })),
+    ).toBeUndefined();
+    expect(command.executeReaderCalls[0]?.text).toBe(
+      "SELECT id FROM users WHERE id = $id",
+    );
+    expect(command.executeReaderCalls[0]?.parameters).toEqual([{ name: "id", value: 9 }]);
+  });
+
+  it("attaches where to the default select", async () => {
+    const { repo, command } = create();
+    command.reader = new MockReader([]);
+    expect(await repo.readSingle(new Where(new Operator.Equals("id", 9)))).toBeUndefined();
+    expect(command.executeReaderCalls[0]?.text).toBe(
+      "SELECT id, name FROM users WHERE id = $id",
+    );
+    expect(command.executeReaderCalls[0]?.parameters).toEqual([{ name: "id", value: 9 }]);
+  });
+
+  it("calls a stored procedure and maps rows", async () => {
+    const { repo, command } = create();
+    command.reader = new MockReader([{ id: 1, name: "a" }]);
+    const parameters = [{ name: "id", value: 9 }];
+    const call = new ExecuteStoredProcedureStatement("get_user", parameters);
+    const rows: Cells[] = [];
+    for await (const row of repo.read(call, parameters)) rows.push(row);
+    expect(rows).toEqual([{ id: 1, name: "a" }]);
+    expect(command.executeReaderCalls[0]?.text).toBe("CALL get_user($id)");
+    expect(command.executeReaderCalls[0]?.parameters).toEqual([{ name: "id", value: 9 }]);
+    command.reader = new MockReader([{ id: 1, name: "a" }]);
+    expect(await repo.readSingle(call, parameters)).toEqual({ id: 1, name: "a" });
+  });
+
+  it("adds updates and deletes through builders", async () => {
+    const { repo, command } = create();
+    command.response = { result: undefined, rowsAffected: 1 };
+    command.reader = new MockReader([{ id: 9 }]);
+    const obj = { id: 0, name: "a" };
+    const created = await repo.create(obj);
+    expect(command.executeCalls[0]?.text).toBe(
+      "INSERT INTO users (name) VALUES ($name)",
+    );
+    expect(command.executeReaderCalls[0]?.text).toBe("users.id");
+    expect(created.id).toBe(9);
+    const updated = await repo.update(obj);
+    expect(updated.rowsAffected).toBe(1);
+    expect(command.executeCalls[1]?.text).toBe(
+      "UPDATE users SET name = $name WHERE id = $id",
+    );
+    const removed = await repo.delete(obj);
+    expect(removed.rowsAffected).toBe(1);
+    expect(command.executeCalls[2]?.text).toBe("DELETE FROM users WHERE id = $id");
+  });
+
+  it("includes an assigned id on create", async () => {
+    const { repo, command } = create();
+    command.response = { result: undefined, rowsAffected: 1 };
+    const created = await repo.create({ id: 42, name: "ada" });
+    expect(command.executeCalls[0]?.text).toBe("INSERT INTO users (id, name) VALUES ($id, $name)");
+    expect(command.executeReaderCalls).toEqual([]);
+    expect(created.id).toBe(42);
+  });
+
+  it("maps create result onto Id when id is absent", async () => {
+    const { repo, command } = create({ type: asType(PascalId), ids: ["Id"] });
+    command.response = { result: undefined, rowsAffected: 1 };
+    command.reader = new MockReader([{ Id: 9 }]);
+    const item = Object.assign(new PascalId(), { Id: 0 });
+    const created = await repo.create(item);
+    expect(created.Id).toBe(9);
+  });
+
+  it("updates without id columns using a tautology", async () => {
+    const { repo, command } = create({ ids: [] });
+    command.response = { result: undefined, rowsAffected: 1 };
+    const updated = await repo.update({ id: 1, name: "a" });
+    expect(updated.rowsAffected).toBe(1);
+    expect(command.executeCalls[0]?.text).toContain("1 = 1");
+    await expect(repo.readSingleById(1)).rejects.toThrow("ReadSingleById requires an Id column");
+    const removed = await repo.delete({ id: 1, name: "a" });
+    expect(removed.rowsAffected).toBe(1);
+    expect(command.executeCalls[1]?.parameters).toEqual([]);
+    const removedByWhere = await repo.delete({ id: 1, name: "a" }, new WhereText("id = $id"));
+    expect(removedByWhere.rowsAffected).toBe(1);
+    expect(command.executeCalls[2]?.parameters).toEqual([
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ]);
+    const versioned = create();
+    versioned.command.response = { result: undefined, rowsAffected: 1 };
+    const versionedUpdate = await versioned.repo.update(
+      { id: 1, name: "b", name_extra: "x" },
+      new Where(new Operator.And(
+        new Operator.Equals("name_extra", "x"),
+        new Operator.Equals("name", "a"),
+      )),
+    );
+    expect(versionedUpdate.rowsAffected).toBe(1);
+    expect(versioned.command.executeCalls[0]?.text).toContain("name = $name__where");
+    expect(versioned.command.executeCalls[0]?.text).toContain("name_extra = $name_extra");
+    const versionedWhere = await versioned.repo.update({ id: 1, name: "b" }, {
+      accept: () => "name = $name",
+      parameters: [{ name: "skipped" }, { name: "name", value: "a" }],
+    });
+    expect(versionedWhere.rowsAffected).toBe(1);
+    expect(versioned.command.executeCalls[1]?.text).toContain("name = $name__where");
+  });
+
+  it("includes assigned composite ids on create", async () => {
+    const { repo, command } = create({
+      ids: ["org_id", "user_id"],
+      type: asType(Composite),
+    });
+    const created = await repo.create({ org_id: 1, user_id: 2, name: 3 });
+    expect(created.org_id).toBe(1);
+    expect(created.user_id).toBe(2);
+    expect(command.executeCalls[0]?.text).toBe(
+      "INSERT INTO users (name, org_id, user_id) VALUES ($name, $org_id, $user_id)",
+    );
+    expect(command.executeCalls[0]?.parameters?.map((field) => field.value)).toEqual([3, 1, 2]);
+    command.response = { result: undefined, rowsAffected: 1 };
+    const updated = await repo.update({ org_id: 1, user_id: 2, name: 4 });
+    expect(updated.rowsAffected).toBe(1);
+    expect(command.executeCalls[1]?.text).toContain(
+      "org_id = $org_id AND user_id = $user_id",
+    );
+  });
+
+  it("omits null datetime and version on create and update", async () => {
+    const { repo, command } = create();
+    command.response = { result: undefined, rowsAffected: 1 };
+    command.reader = new MockReader([{ id: 7 }, { id: 7 }]);
+    const created = await repo.create({ id: 0, name: "ada", created: null, version: undefined });
+    expect(created.id).toBe(7);
+    expect(command.executeCalls[0]?.text).toBe("INSERT INTO users (name) VALUES ($name)");
+    const updated = await repo.update({ id: 1, name: "ada", created: null, version: null });
+    expect(updated.rowsAffected).toBe(1);
+    expect(command.executeCalls[1]?.text).toBe(
+      "UPDATE users SET name = $name WHERE id = $id",
+    );
+    const when = new Date("2024-06-01T00:00:00.000Z");
+    const grace = await repo.create({ id: 0, name: "grace", created: when, version: new Uint8Array([9, 9]) });
+    expect(grace.id).toBe(7);
+    expect(command.executeCalls[2]?.text).toBe(
+      "INSERT INTO users (created, name, version) VALUES ($created, $name, $version)",
+    );
+  });
+
+  it("reads a single row by id columns", async () => {
+    const { repo, command } = create();
+    command.reader = new MockReader([]);
+    expect(await repo.readSingleById(9)).toBeUndefined();
+    expect(command.executeReaderCalls[0]?.text).toBe(
+      "SELECT id, name FROM users WHERE id = $id",
+    );
+    expect(command.executeReaderCalls[0]?.parameters).toEqual([{ name: "id", value: 9 }]);
+
+    const composite = create({ ids: ["org_id", "user_id"], type: asType(Composite) });
+    composite.command.reader = new MockReader([]);
+    expect(await composite.repo.readSingleById({ org_id: 1, user_id: 2 })).toBeUndefined();
+    expect(composite.command.executeReaderCalls[0]?.text).toContain(
+      "org_id = $org_id AND user_id = $user_id",
+    );
+    await expect(composite.repo.readSingleById(1)).rejects.toThrow(
+      "Composite id requires a row keyed by each Id column",
+    );
+    await expect(composite.repo.readSingleById({ org_id: 1 })).rejects.toThrow(
+      "Missing Id value",
+    );
+  });
+
+  it("throws on missing id, bad rows, and empty update", async () => {
+    const connection = new MockConnection();
+    const command = new MockCommand(connection);
+    connection.command = command;
+    const { repo, command: query } = create();
+    query.reader = {
+      current: undefined,
+      next: async () => true,
+      nextResult: async () => false,
+      async *read() {
+        while (await this.next()) {
+          if (this.current !== undefined) yield this.current;
+        }
+      },
+      dispose: async () => {},
+    };
+    await expect(async () => {
+      for await (const _ of repo.read()) {
+        /* consume */
+      }
+    }).rejects.toThrow("Reader current must be a row");
+    await expect(repo.update({ name: "a" })).rejects.toThrow("Missing Id value");
+    await expect(repo.delete({ name: "a" })).rejects.toThrow("Missing Id value");
+    await expect(repo.update({ id: 1 })).rejects.toThrow("non-Id field");
+    query.reader = {
+      current: undefined,
+      next: async () => true,
+      nextResult: async () => false,
+      async *read() {
+        while (await this.next()) {
+          if (this.current !== undefined) yield this.current;
+        }
+      },
+      dispose: async () => {},
+    };
+    await expect(async () => {
+      for await (const _ of repo.read()) {
+        /* consume */
+      }
+    }).rejects.toThrow("Reader current must be a row");
+    query.response = { result: undefined, rowsAffected: 1 };
+    const updated = await repo.update({ id: 1, name: "a" }, new WhereText("id = 1"));
+    expect(updated.rowsAffected).toBe(1);
+    const typed = new CRUDRepository(connection, {
+      type: asType(Item),
+      entity: "users",
+      objectConverter: new MetaDataRowTypeConverter(),
+    });
+    command.response = { result: undefined, rowsAffected: 1 };
+    const created = await typed.create(Object.assign(new Item(), { id: 1, name: "a" }));
+    expect(created.id).toBe(1);
+    expect(command.executeCalls[0]?.text).toContain("INSERT INTO users");
+    const removed = await typed.delete(Object.assign(new Item(), { name: "z" }), new Where(new Operator.Equals("name", "z")));
+    expect(removed.rowsAffected).toBe(1);
+    expect(command.executeCalls[1]?.text).toBe("DELETE FROM users WHERE name = $name");
+  });
+
+  it("builds repository options from a type", () => {
+    const connection = new MockConnection();
+    const fromId = createCRUDRepositoryOptions(asType(Item));
+    expect(fromId.ids).toEqual(["id"]);
+    expect(fromId.entity).toBe("Item");
+    expect(createCRUDRepositoryOptions(asType(Label)).ids).toEqual([]);
+    expect(createCRUDRepositoryOptions(asType(PascalId)).ids).toEqual(["Id"]);
+    expect(new CRUDRepository(connection, fromId)).toBeInstanceOf(CRUDRepository);
+    expect(new CRUDRepository(asType(Item), connection)).toBeInstanceOf(CRUDRepository);
+    expect(new CRUDRepositoryBuilder().parts(connection, fromId).connection).toBe(connection);
+    expect(new CRUDRepositoryBuilder().parts(connection, createCRUDRepositoryOptions(asType(Item))).ids).toEqual(["id"]);
+    expect(DefaultStatementTextRenderer.instance.render(new ReadonlyRepositoryBuilder().parts(connection, {}).statements.select())).toBe("SELECT * FROM ");
+    expect(DefaultStatementTextRenderer.instance.render(new ReadonlyRepositoryBuilder().parts(connection, { type: asType(Item) }).statements.select())).toBe(
+      "SELECT id, name FROM Item",
+    );
+  });
+
+  it("builder maps entity and columns", async () => {
+    const entity = new TransformMapper<string, string>(
+      (name) => (name === "users" ? "people" : name),
+      (name) => name,
+    );
+    const propertyMappings = new TransformMapper<string, string>(
+      (name) => ({ id: "user_id", name: "full_name" }[name] ?? name),
+      (name) => name,
+    );
+    const { repo, command } = create({
+      entityMapper: entity,
+      propertyMappings,
+    });
+    command.reader = new MockReader([]);
+    await repo.readSingle();
+    expect(command.executeReaderCalls[0]?.text).toBe(
+      "SELECT full_name, user_id FROM people",
+    );
+    command.response = { result: undefined, rowsAffected: 1 };
+    const row = { id: 0, name: "a" };
+    const created = await repo.create(row);
+    expect(created.id).toBe(0);
+    expect(command.executeCalls[0]?.text).toBe(
+      "INSERT INTO people (full_name) VALUES ($full_name)",
+    );
+    const updated = await repo.update(row);
+    expect(updated.rowsAffected).toBe(1);
+    expect(command.executeCalls[1]?.text).toBe(
+      "UPDATE people SET full_name = $full_name WHERE user_id = $user_id",
+    );
+    const removed = await repo.delete(row);
+    expect(removed.rowsAffected).toBe(1);
+    expect(command.executeCalls[2]?.text).toBe(
+      "DELETE FROM people WHERE user_id = $user_id",
+    );
+  });
+
+  it("reverse-converts a field only before values are applied", async () => {
+    class Flag extends TypeConverter<Cell, Cell> {
+      convert = (value: Cell): Cell => value;
+      reverseConvert = (value: Cell): Cell => (value === true ? 1 : 0);
+    }
+    class Row {
+      id = 0;
+      on = false;
+    }
+    const connection = new MockConnection();
+    const command = new MockCommand(connection);
+    connection.command = command;
+    const repo = new CRUDRepository<Row>(connection, {
+      type: Row,
+      entity: "rows",
+      objectConverter: new MetaDataRowTypeConverter<Row>({ on: new Flag() }),
+    });
+    command.response = { result: undefined, rowsAffected: 1 };
+    const created = await repo.create(Object.assign(new Row(), { id: 1, on: true }));
+    expect(created.id).toBe(1);
+    const updated = await repo.update(
+      Object.assign(new Row(), { id: 1, on: true }),
+      new Where(new Operator.Equals("on", true)),
+    );
+    expect(updated.rowsAffected).toBe(1);
+    expect(command.executeCalls[1]?.parameters).toContainEqual({ name: "on", value: 1 });
+  });
+
+  it("keeps a where value when the converter has no fields", async () => {
+    class Plain extends TypeConverter<Item, Cells> {
+      convert = (row: Cells): Item => Object.assign(new Item(), row);
+      reverseConvert = (row: Item): Cells => ({ id: row.id, name: row.name });
+    }
+    const connection = new MockConnection();
+    const command = new MockCommand(connection);
+    connection.command = command;
+    const repo = new CRUDRepository<Item>(connection, {
+      type: Item,
+      entity: "items",
+      objectConverter: new Plain(),
+    });
+    command.response = { result: undefined, rowsAffected: 1 };
+    const updated = await repo.update(
+      Object.assign(new Item(), { id: 1, name: "a" }),
+      new Where(new Operator.Equals("name", "a")),
+    );
+    expect(updated.rowsAffected).toBe(1);
+    expect(command.executeCalls[0]?.parameters).toContainEqual({ name: "name", value: "a" });
+  });
+});

package/src/repository.type.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { MemoryDriver } from "@datasources/memory";
+import { MockConnection } from "./mocks/mock-connection.ts";
+import { CRUDRepository } from "./CRUDRepository.ts";
+import { ReadonlyRepository } from "./ReadonlyRepository.ts";
+
+class Item {
+  id = 0;
+}
+
+describe("repository type", () => {
+  it("reports constructor from typed construction", () => {
+    const repo = new CRUDRepository(Item, new MockConnection());
+    expect(repo.type).toBe(Item);
+    expect(new ReadonlyRepository(Item, new MockConnection()).type).toBe(Item);
+  });
+
+  it("crud repository reports item type", () => {
+    const repo = new CRUDRepository(Item, new MemoryDriver().connection());
+    expect(repo.type).toBe(Item);
+  });
+
+  it("untyped options report Object", () => {
+    const repo = new CRUDRepository(new MockConnection(), {
+      entity: "items",
+    });
+    expect(repo.type).toBe(Object);
+  });
+});

package/src/statements/SelectInsertedIdStatement.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "vitest";
+import { DefaultStatementTextRenderer, SelectInsertedIdStatement } from "../index.ts";
+
+describe("SelectInsertedIdStatement", () => {
+  it("requires a provider implementation", () => {
+    const statement = new SelectInsertedIdStatement("users", "id");
+    expect(() => DefaultStatementTextRenderer.instance.render(statement)).toThrow(
+      "provider must implement SelectInsertIdStatement",
+    );
+  });
+});

package/src/statements/StatementCompile.test.ts

@@ -0,0 +1,231 @@
+import { describe, expect, it } from "vitest";
+import {
+  Aggregate,
+  CheckConstraint,
+  ColumnDefault,
+  CreateIndexStatement,
+  CreateTableStatement,
+  DeleteStatement,
+  ForeignKey,
+  InsertStatement,
+  Join,
+  NotNull,
+  Operator,
+  OrderBy,
+  PrimaryKey,
+  SelectStatement,
+  ReferentialAction,
+  ReturnStatement,
+  UniqueConstraint,
+  ExecuteStoredProcedureStatement,
+  UpdateStatement,
+  WhereText,
+  Where,
+  DefaultStatementTextRenderer,
+} from "../index.ts";
+
+describe("statement compile", () => {
+  it("wraps query text and an optional where", () => {
+    const select = new SelectStatement({ table: "dual", fields: ["1"] });
+    const byId = new WhereText("id = 1");
+    const withWhere = new SelectStatement({ table: "dual", fields: ["1"], where: byId });
+    expect(DefaultStatementTextRenderer.instance.render(select)).toBe("SELECT 1 FROM dual");
+    expect(select.where).toBeUndefined();
+    expect(withWhere.where).toBe(byId);
+    expect(DefaultStatementTextRenderer.instance.render(byId)).toBe("id = 1");
+  });
+
+  it("compiles a select", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const query = new SelectStatement({ table: "users", fields: ["id", "name"], where });
+    expect(DefaultStatementTextRenderer.instance.render(query)).toBe(
+      "SELECT id, name FROM users WHERE id = $id AND age > $age",
+    );
+    expect(query.where).toBe(where);
+  });
+
+  it("joins tables", () => {
+    const query = 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"),
+      ],
+    });
+    expect(DefaultStatementTextRenderer.instance.render(query)).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",
+    );
+  });
+
+  it("groups aggregates orders and limits", () => {
+    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",
+    );
+  });
+
+  it("groups rows", () => {
+    const byStatus = new SelectStatement({ table: "users", fields: ["id"], groupBy: ["id"] });
+    expect(DefaultStatementTextRenderer.instance.render(byStatus)).toBe("SELECT id FROM users GROUP BY id");
+  });
+
+  it("aggregates without grouping", () => {
+    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");
+  });
+
+  it("orders rows", () => {
+    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",
+    );
+  });
+
+  it("limits rows", () => {
+    const limited = new SelectStatement({ table: "users", fields: ["id"], limit: 10 });
+    expect(DefaultStatementTextRenderer.instance.render(limited)).toBe("SELECT id FROM users LIMIT 10");
+  });
+
+  it("compiles an insert", () => {
+    const fields = [
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ];
+    const insert = new InsertStatement("users", fields);
+    expect(DefaultStatementTextRenderer.instance.render(insert)).toBe(
+      "INSERT INTO users (id, name) VALUES ($id, $name)",
+    );
+  });
+
+  it("compiles an update", () => {
+    const fields = [
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ];
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const update = new UpdateStatement("users", fields, where);
+    expect(DefaultStatementTextRenderer.instance.render(update)).toBe(
+      "UPDATE users SET id = $id, name = $name WHERE id = $id AND age > $age",
+    );
+    expect(update.where).toBe(where);
+  });
+
+  it("compiles a delete", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const del = new DeleteStatement("users", where);
+    expect(DefaultStatementTextRenderer.instance.render(del)).toBe(
+      "DELETE FROM users WHERE id = $id AND age > $age",
+    );
+    expect(del.where).toBe(where);
+  });
+
+  it("compiles a create table", () => {
+    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)",
+    );
+  });
+
+  it("compiles named constraints", () => {
+    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))",
+    );
+  });
+
+  it("compiles a create index", () => {
+    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)",
+    );
+  });
+
+  it("compiles a create unique index", () => {
+    const createIndex = new CreateIndexStatement("uq_orders_code", "orders", ["code"], true);
+    expect(DefaultStatementTextRenderer.instance.render(createIndex)).toBe(
+      "CREATE UNIQUE INDEX uq_orders_code ON orders (code)",
+    );
+  });
+
+  it("compiles a call", () => {
+    const fields = [
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ];
+    const call = new ExecuteStoredProcedureStatement("save", fields);
+    expect(DefaultStatementTextRenderer.instance.render(call)).toBe("CALL save($id, $name)");
+  });
+
+  it("compiles a select function call", () => {
+    const fields = [
+      { name: "id", value: 1 },
+      { name: "name", value: "a" },
+    ];
+    const ret = new ReturnStatement("add", fields);
+    expect(DefaultStatementTextRenderer.instance.render(ret)).toBe("SELECT add($id, $name)");
+  });
+
+  it("renders compare groups not and in", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const inIds = new Where(new Operator.In("id", [1, 2]));
+    expect(DefaultStatementTextRenderer.instance.render(where)).toBe("id = $id AND age > $age");
+    expect(DefaultStatementTextRenderer.instance.render(inIds)).toBe("id IN ($id_0, $id_1)");
+  });
+
+  it("compare tree", () => {
+    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");
+  });
+
+  it("attaches where to a query", () => {
+    const where = new Where(
+      new Operator.And(new Operator.Equals("id", 1), new Operator.GreaterThan("age", 18)),
+    );
+    const query = new SelectStatement({ table: "users", fields: ["id", "name"], where });
+    expect(DefaultStatementTextRenderer.instance.render(query)).toBe(
+      "SELECT id, name FROM users WHERE id = $id AND age > $age",
+    );
+  });
+});