@afora/core 0.0.2 → 0.0.3

package/dist/testing/index.js

@@ -0,0 +1,502 @@
+import"../index-hn82hm31.js";
+import {
+  RepositoryUniqueViolation2,
+  RepositoryEntityNotFound2,
+  blueprintOf2,
+  entityOf2
+} from "../index-sw2b9ehx.js";
+
+// src/testing/provider-contract.ts
+function contextOf(name = "Accounts") {
+  class Account extends entityOf2(blueprintOf2((ctx) => ({ email: ctx.string, name: ctx.string }))) {
+  }
+  return {
+    entity: Account,
+    name,
+    unique: ["id", "email"],
+    env: {}
+  };
+}
+var sequence = 0;
+function row(overrides = {}) {
+  sequence += 1;
+  const id = `id-${String(sequence).padStart(4, "0")}`;
+  return { id, email: `${id}@example.com`, name: id, ...overrides };
+}
+async function failure(promise) {
+  try {
+    await promise;
+  } catch (error) {
+    return error;
+  }
+  return;
+}
+var ids = (rows) => rows.map((r) => r.id);
+function providerContract(runner, makeProvider, options = {}) {
+  const { describe, it, expect } = runner;
+  async function fixture() {
+    const provider = await makeProvider();
+    const context = contextOf();
+    const seed = async (...rows) => {
+      for (const data of rows)
+        await provider.insert(context, data);
+    };
+    return { provider, context, seed };
+  }
+  describe("provider contract", () => {
+    describe("writes and reads", () => {
+      it("inserts and finds by id, empty provider counts zero", async () => {
+        const { provider, context } = await fixture();
+        expect(await provider.count(context)).toBe(0);
+        expect(await provider.findOne(context)).toBe(undefined);
+        expect(await provider.findMany(context)).toEqual([]);
+        const data = row({ age: 30 });
+        await provider.insert(context, data);
+        expect(await provider.count(context)).toBe(1);
+        expect(await provider.findOne(context, { where: { id: data.id } })).toEqual(data);
+        expect(await provider.findMany(context)).toEqual([data]);
+      });
+      it("findOne is undefined when nothing matches", async () => {
+        const { provider, context, seed } = await fixture();
+        await seed(row());
+        expect(await provider.findOne(context, { where: { id: "missing" } })).toBe(undefined);
+        expect(await provider.findMany(context, { where: { id: "missing" } })).toEqual([]);
+      });
+      it("update replaces the stored value", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ name: "Ana" });
+        await seed(data);
+        await provider.update(context, { ...data, name: "Bia" });
+        expect(await provider.findOne(context, { where: { id: data.id } })).toEqual({ ...data, name: "Bia" });
+        expect(await provider.count(context)).toBe(1);
+      });
+      it("remove deletes the row", async () => {
+        const { provider, context, seed } = await fixture();
+        const [a, b] = [row(), row()];
+        await seed(a, b);
+        await provider.remove(context, a.id);
+        expect(ids(await provider.findMany(context))).toEqual([b.id]);
+        expect(await provider.count(context)).toBe(1);
+      });
+      it("update and remove of an unknown id throw RepositoryEntityNotFound", async () => {
+        const { provider, context, seed } = await fixture();
+        await seed(row());
+        const updated = await failure(provider.update(context, row()));
+        expect(updated instanceof RepositoryEntityNotFound2).toBe(true);
+        const removed = await failure(provider.remove(context, "missing"));
+        expect(removed instanceof RepositoryEntityNotFound2).toBe(true);
+        expect(await provider.count(context)).toBe(1);
+      });
+      it("keeps tables of different contexts apart", async () => {
+        const provider = await makeProvider();
+        const [one, two] = [contextOf("One"), contextOf("Two")];
+        await provider.insert(one, row());
+        expect(await provider.count(one)).toBe(1);
+        expect(await provider.count(two)).toBe(0);
+      });
+    });
+    describe("unique keys", () => {
+      it("insert throws RepositoryUniqueViolation for a repeated id", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row();
+        await seed(data);
+        const error = await failure(provider.insert(context, { ...row(), id: data.id }));
+        expect(error instanceof RepositoryUniqueViolation2).toBe(true);
+        expect(error.details.key).toBe("id");
+        expect(await provider.count(context)).toBe(1);
+      });
+      it("insert throws for a repeated unique key", async () => {
+        const { provider, context, seed } = await fixture();
+        await seed(row({ email: "a@example.com" }));
+        const error = await failure(provider.insert(context, row({ email: "a@example.com" })));
+        expect(error instanceof RepositoryUniqueViolation2).toBe(true);
+        expect(error.details.key).toBe("email");
+        expect(await provider.count(context)).toBe(1);
+      });
+      it("update throws when taking the unique value of another row", async () => {
+        const { provider, context, seed } = await fixture();
+        const [a, b] = [row({ email: "a@example.com" }), row()];
+        await seed(a, b);
+        const error = await failure(provider.update(context, { ...b, email: "a@example.com" }));
+        expect(error instanceof RepositoryUniqueViolation2).toBe(true);
+        expect(error.details.key).toBe("email");
+        expect(await provider.findOne(context, { where: { id: b.id } })).toEqual(b);
+      });
+      it("update may keep the unique values of its own row", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ email: "a@example.com" });
+        await seed(data);
+        await provider.update(context, { ...data, name: "Other" });
+        expect(await provider.findOne(context, { where: { id: data.id } })).toEqual({ ...data, name: "Other" });
+      });
+      it("soft-deleted rows keep occupying unique values", async () => {
+        const { provider, context, seed } = await fixture();
+        await seed(row({
+          email: "a@example.com",
+          deletedAt: "2024-01-01T00:00:00.000Z"
+        }));
+        const inserted = await failure(provider.insert(context, row({ email: "a@example.com" })));
+        expect(inserted instanceof RepositoryUniqueViolation2).toBe(true);
+        const other = row();
+        await seed(other);
+        const updated = await failure(provider.update(context, { ...other, email: "a@example.com" }));
+        expect(updated instanceof RepositoryUniqueViolation2).toBe(true);
+      });
+    });
+    describe("where", () => {
+      it("matches scalars by equality", async () => {
+        const { provider, context, seed } = await fixture();
+        const [a, b, c] = [
+          row({ age: 20, name: "Ana", active: true }),
+          row({ age: 30, name: "Bia", active: false }),
+          row({ age: 30, name: "Cy", active: true })
+        ];
+        await seed(a, b, c);
+        const find = (where) => provider.findMany(context, { where });
+        expect(ids(await find({ age: 30 }))).toEqual([b.id, c.id]);
+        expect(ids(await find({ name: "Ana" }))).toEqual([a.id]);
+        expect(ids(await find({ active: false }))).toEqual([b.id]);
+        expect(ids(await find({ age: 31 }))).toEqual([]);
+        expect(ids(await find({}))).toEqual([a.id, b.id, c.id]);
+      });
+      it("matches structured values by structure", async () => {
+        const { provider, context, seed } = await fixture();
+        const [a, b] = [
+          row({ address: { city: "Rio", zip: "1" }, tags: ["x", "y"] }),
+          row({ address: { city: "Rio", zip: "2" }, tags: ["y", "x"] })
+        ];
+        await seed(a, b);
+        const find = (where) => provider.findMany(context, { where });
+        expect(ids(await find({ address: { city: "Rio", zip: "1" } }))).toEqual([a.id]);
+        expect(ids(await find({ address: { city: "Rio" } }))).toEqual([]);
+        expect(ids(await find({ tags: ["y", "x"] }))).toEqual([b.id]);
+        expect(ids(await find({ tags: ["x"] }))).toEqual([]);
+      });
+      it("matches membership with in", async () => {
+        const { provider, context, seed } = await fixture();
+        const [a, b, c] = [row({ age: 1 }), row({ age: 2 }), row({ age: 3 })];
+        await seed(a, b, c);
+        const find = (where) => provider.findMany(context, { where });
+        expect(ids(await find({ age: { in: [1, 3] } }))).toEqual([a.id, c.id]);
+        expect(ids(await find({ id: { in: [b.id, "missing"] } }))).toEqual([
+          b.id
+        ]);
+        expect(ids(await find({ age: { in: [] } }))).toEqual([]);
+        expect(await provider.count(context, { where: { age: { in: [] } } })).toBe(0);
+        expect(await provider.findOne(context, { where: { age: { in: [] } } })).toBe(undefined);
+      });
+      it("ANDs conditions on several keys", async () => {
+        const { provider, context, seed } = await fixture();
+        const [a, b, c] = [
+          row({ age: 30, name: "Ana" }),
+          row({ age: 30, name: "Bia" }),
+          row({ age: 20, name: "Bia" })
+        ];
+        await seed(a, b, c);
+        const find = (where) => provider.findMany(context, { where });
+        expect(ids(await find({ age: 30, name: "Bia" }))).toEqual([b.id]);
+        expect(ids(await find({ age: { in: [20, 30] }, name: { in: ["Bia"] } }))).toEqual([b.id, c.id]);
+        expect(ids(await find({ age: 20, name: "Ana" }))).toEqual([]);
+      });
+    });
+    describe("orderBy", () => {
+      const order = async (rows, orderBy) => {
+        const { provider, context, seed } = await fixture();
+        await seed(...rows);
+        return ids(await provider.findMany(context, { orderBy }));
+      };
+      it("is ascending by default and descending on request", async () => {
+        const [a, b, c] = [row({ age: 2 }), row({ age: 3 }), row({ age: 1 })];
+        expect(await order([a, b, c], [{ key: "age" }])).toEqual([
+          c.id,
+          a.id,
+          b.id
+        ]);
+        expect(await order([a, b, c], [{ key: "age", direction: "asc" }])).toEqual([c.id, a.id, b.id]);
+        expect(await order([a, b, c], [{ key: "age", direction: "desc" }])).toEqual([b.id, a.id, c.id]);
+      });
+      it("sorts numbers numerically", async () => {
+        const [a, b, c] = [
+          row({ age: 10 }),
+          row({ age: 9 }),
+          row({ age: 100 })
+        ];
+        expect(await order([a, b, c], [{ key: "age" }])).toEqual([
+          b.id,
+          a.id,
+          c.id
+        ]);
+      });
+      it("sorts strings by code point", async () => {
+        const [lower, upper, wide, emoji] = [
+          row({ name: "a" }),
+          row({ name: "Z" }),
+          row({ name: "ｚ" }),
+          row({ name: "\uD83D\uDE00" })
+        ];
+        expect(await order([emoji, lower, wide, upper], [{ key: "name" }])).toEqual([upper.id, lower.id, wide.id, emoji.id]);
+      });
+      it("puts missing values first when ascending and last when descending", async () => {
+        const [a, b, c] = [row({ age: 2 }), row(), row({ age: 1 })];
+        expect(await order([a, b, c], [{ key: "age" }])).toEqual([
+          b.id,
+          c.id,
+          a.id
+        ]);
+        expect(await order([a, b, c], [{ key: "age", direction: "desc" }])).toEqual([a.id, c.id, b.id]);
+      });
+      it("keeps the insertion order of ties", async () => {
+        const [a, b, c, d] = [
+          row({ group: 1 }),
+          row({ group: 0 }),
+          row({ group: 1 }),
+          row({ group: 0 })
+        ];
+        expect(await order([a, b, c, d], [{ key: "group" }])).toEqual([
+          b.id,
+          d.id,
+          a.id,
+          c.id
+        ]);
+        expect(await order([a, b, c, d], [{ key: "group", direction: "desc" }])).toEqual([a.id, c.id, b.id, d.id]);
+      });
+      it("sorts by several keys in turn", async () => {
+        const [a, b, c, d] = [
+          row({ group: 1, name: "b" }),
+          row({ group: 0, name: "z" }),
+          row({ group: 1, name: "a" }),
+          row({ group: 0, name: "y" })
+        ];
+        expect(await order([a, b, c, d], [{ key: "group" }, { key: "name", direction: "desc" }])).toEqual([b.id, d.id, a.id, c.id]);
+        expect(await order([a, b, c, d], [{ key: "group", direction: "desc" }, { key: "name" }])).toEqual([c.id, a.id, d.id, b.id]);
+      });
+    });
+    describe("limit and offset", () => {
+      const seeded = async () => {
+        const f = await fixture();
+        const rows = [1, 2, 3, 4, 5].map((n) => row({ n }));
+        await f.seed(...rows);
+        return { ...f, rows };
+      };
+      const byN = [{ key: "n" }];
+      it("limit takes the first rows, offset skips rows before it", async () => {
+        const { provider, context, rows } = await seeded();
+        const find = (limit, offset) => provider.findMany(context, { orderBy: byN, limit, offset }).then(ids);
+        expect(await find(2)).toEqual([rows[0]?.id, rows[1]?.id]);
+        expect(await find(undefined, 3)).toEqual([rows[3]?.id, rows[4]?.id]);
+        expect(await find(2, 1)).toEqual([rows[1]?.id, rows[2]?.id]);
+        expect(await find(10, 4)).toEqual([rows[4]?.id]);
+        expect(await find(2, 5)).toEqual([]);
+      });
+      it("limit 0 returns nothing", async () => {
+        const { provider, context } = await seeded();
+        expect(await provider.findMany(context, { limit: 0 })).toEqual([]);
+        expect(await provider.findOne(context, { limit: 0 })).toBe(undefined);
+      });
+      it("findOne returns the first row after the offset", async () => {
+        const { provider, context, rows } = await seeded();
+        expect((await provider.findOne(context, { orderBy: byN, offset: 2 }))?.id).toBe(rows[2]?.id);
+        expect(await provider.findOne(context, { orderBy: byN, offset: 5 })).toBe(undefined);
+      });
+      it("count ignores order, limit and offset", async () => {
+        const { provider, context } = await seeded();
+        expect(await provider.count(context, {
+          orderBy: [{ key: "n", direction: "desc" }],
+          limit: 1,
+          offset: 3
+        })).toBe(5);
+        expect(await provider.count(context, {
+          where: { n: { in: [1, 2] } },
+          limit: 0,
+          offset: 9
+        })).toBe(2);
+      });
+    });
+    describe("withDeleted", () => {
+      const deletedAt = "2024-01-01T00:00:00.000Z";
+      const seeded = async () => {
+        const f = await fixture();
+        const [live, gone] = [row({ n: 1 }), row({ n: 2, deletedAt })];
+        await f.seed(live, gone);
+        return { ...f, live, gone };
+      };
+      it("excludes deleted rows by default", async () => {
+        const { provider, context, live, gone } = await seeded();
+        expect(ids(await provider.findMany(context))).toEqual([live.id]);
+        expect(ids(await provider.findMany(context, { withDeleted: false }))).toEqual([live.id]);
+        expect(await provider.count(context)).toBe(1);
+        expect(await provider.findOne(context, { where: { id: gone.id } })).toBe(undefined);
+      });
+      it("includes them with withDeleted", async () => {
+        const { provider, context, live, gone } = await seeded();
+        const query = { withDeleted: true };
+        expect(ids(await provider.findMany(context, query))).toEqual([
+          live.id,
+          gone.id
+        ]);
+        expect(await provider.count(context, query)).toBe(2);
+        expect(await provider.findOne(context, {
+          where: { id: gone.id },
+          withDeleted: true
+        })).toEqual(gone);
+      });
+    });
+    describe("copies", () => {
+      it("does not share data with the caller on write", async () => {
+        const { provider, context } = await fixture();
+        const data = row({ address: { city: "Rio" }, tags: ["x"] });
+        await provider.insert(context, data);
+        data.address.city = "SP";
+        data.tags.push("y");
+        const stored = await provider.findOne(context, {
+          where: { id: data.id }
+        });
+        expect(stored?.address).toEqual({ city: "Rio" });
+        expect(stored?.tags).toEqual(["x"]);
+      });
+      it("does not share data with the caller on read", async () => {
+        const { provider, context, seed } = await fixture();
+        const data = row({ address: { city: "Rio" }, tags: ["x"] });
+        await seed(data);
+        const one = await provider.findOne(context, {
+          where: { id: data.id }
+        });
+        one.address.city = "SP";
+        one.name = "changed";
+        const many = await provider.findMany(context);
+        many[0].tags.push("y");
+        const stored = await provider.findOne(context, {
+          where: { id: data.id }
+        });
+        expect(stored).toEqual(data);
+      });
+    });
+    const withTransactions = async () => {
+      const enabled = options.transactions ?? (await makeProvider()).capabilities?.transactions;
+      return enabled === true;
+    };
+    describe("transactions", () => {
+      const transactional = (name, body) => it(name, async () => {
+        if (!await withTransactions())
+          return;
+        await body();
+      });
+      const open = async () => {
+        const f = await fixture();
+        const transaction = f.provider.transaction?.bind(f.provider);
+        if (!transaction) {
+          throw new Error("the provider advertises transactions but has none");
+        }
+        return { ...f, transaction };
+      };
+      transactional("commits the writes when the callback resolves", async () => {
+        const { provider, context, seed, transaction } = await open();
+        const [a, b] = [row({ name: "a" }), row()];
+        await seed(a);
+        const result = await transaction(async (tx) => {
+          await tx.insert(context, b);
+          await tx.update(context, { ...a, name: "changed" });
+          expect(await tx.count(context)).toBe(2);
+          return "done";
+        });
+        expect(result).toBe("done");
+        expect(ids(await provider.findMany(context))).toEqual([a.id, b.id]);
+        expect((await provider.findOne(context, { where: { id: a.id } }))?.name).toBe("changed");
+      });
+      transactional("rolls back every write when the callback rejects", async () => {
+        const { provider, context, seed, transaction } = await open();
+        const [a, b] = [row({ name: "a" }), row()];
+        await seed(a, b);
+        const boom = new Error("boom");
+        const error = await failure(transaction(async (tx) => {
+          await tx.insert(context, row());
+          await tx.update(context, { ...a, name: "changed" });
+          await tx.remove(context, b.id);
+          throw boom;
+        }));
+        expect(error).toBe(boom);
+        expect(await provider.findMany(context)).toEqual([a, b]);
+      });
+      transactional("rolls back after a failed write inside", async () => {
+        const { provider, context, seed, transaction } = await open();
+        const a = row({ email: "a@example.com" });
+        await seed(a);
+        const error = await failure(transaction(async (tx) => {
+          await tx.insert(context, row());
+          await tx.insert(context, row({ email: "a@example.com" }));
+        }));
+        expect(error instanceof RepositoryUniqueViolation2).toBe(true);
+        expect(await provider.findMany(context)).toEqual([a]);
+      });
+      transactional("does not lose writes made outside meanwhile", async () => {
+        const { provider, context, transaction } = await open();
+        const [inside, outside] = [row(), row()];
+        let release = () => {};
+        const gate = new Promise((resolve) => {
+          release = resolve;
+        });
+        let started = () => {};
+        const entered = new Promise((resolve) => {
+          started = resolve;
+        });
+        const running = failure(transaction(async (tx) => {
+          await tx.insert(context, inside);
+          started();
+          await gate;
+          throw new Error("rollback");
+        }));
+        await entered;
+        const writing = provider.insert(context, outside);
+        release();
+        await running;
+        await writing;
+        expect(ids(await provider.findMany(context))).toEqual([outside.id]);
+      });
+      transactional("rejects the scoped provider after the callback", async () => {
+        const { context, transaction } = await open();
+        let scoped;
+        await transaction(async (tx) => {
+          scoped = tx;
+        });
+        const error = await failure(scoped.insert(context, row()));
+        expect(error instanceof Error).toBe(true);
+        const read = await failure(scoped.count(context));
+        expect(read instanceof Error).toBe(true);
+      });
+      transactional("treats a nested transaction as a savepoint", async () => {
+        const { provider, context, transaction } = await open();
+        const [outer, kept, dropped] = [row(), row(), row()];
+        await transaction(async (tx) => {
+          expect(typeof tx.transaction).toBe("function");
+          await tx.insert(context, outer);
+          await tx.transaction?.(async (inner) => {
+            await inner.insert(context, kept);
+          });
+          const error = await failure(tx.transaction?.(async (inner) => {
+            await inner.insert(context, dropped);
+            throw new Error("inner");
+          }) ?? Promise.resolve());
+          expect(error.message).toBe("inner");
+          expect(ids(await tx.findMany(context))).toEqual([outer.id, kept.id]);
+        });
+        expect(ids(await provider.findMany(context))).toEqual([
+          outer.id,
+          kept.id
+        ]);
+      });
+      transactional("rolls the outer back even if an inner one committed", async () => {
+        const { provider, context, transaction } = await open();
+        await failure(transaction(async (tx) => {
+          await tx.transaction?.(async (inner) => {
+            await inner.insert(context, row());
+          });
+          throw new Error("outer");
+        }));
+        expect(await provider.count(context)).toBe(0);
+      });
+    });
+  });
+}
+export {
+  providerContract
+};

package/dist/testing/provider-contract.d.ts

@@ -0,0 +1,22 @@
+import { type IRepositoryProvider } from "../index.js";
+/** The parts of a test runner the kit uses; `bun:test`, vitest and jest fit. */
+export interface ContractRunner {
+    describe(name: string, body: () => void): void;
+    it(name: string, body: () => unknown): void;
+    expect(value: unknown): {
+        toBe(expected: unknown): unknown;
+        toEqual(expected: unknown): unknown;
+    };
+}
+export interface ProviderContractOptions {
+    /**
+     * Run the transaction cases. Defaults to `provider.capabilities?.transactions`.
+     */
+    readonly transactions?: boolean;
+}
+/**
+ * Registers the behavior every `IRepositoryProvider` v2 must have. Pass the
+ * `describe`, `it` and `expect` of your runner and a factory of fresh, empty
+ * providers (called once per case).
+ */
+export declare function providerContract(runner: ContractRunner, makeProvider: () => IRepositoryProvider | Promise<IRepositoryProvider>, options?: ProviderContractOptions): void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@afora/core",
-	"version": "0.0.2",
+	"version": "0.0.3",
 	"description": "Domain modeling on TypeBox: entities with invariants, repositories, use cases, sensitive data masking and layered exceptions, usable by any Standard Schema consumer.",
 	"keywords": [
 		"domain-driven-design",
@@ -40,6 +40,16 @@
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
 		},
+		"./experimental": {
+			"types": "./dist/experimental.d.ts",
+			"import": "./dist/experimental.js",
+			"default": "./dist/experimental.js"
+		},
+		"./testing": {
+			"types": "./dist/testing/index.d.ts",
+			"import": "./dist/testing/index.js",
+			"default": "./dist/testing/index.js"
+		},
 		"./package.json": "./package.json"
 	},
 	"files": [
@@ -58,33 +68,43 @@
 		"lint": "biome lint .",
 		"fmt": "biome check --write .",
 		"knip": "knip",
-		"build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target node --format esm --packages external && tsc -p tsconfig.build.json",
+		"build": "rm -rf dist && bun build ./src/index.ts ./src/experimental.ts ./src/testing/index.ts --outdir ./dist --target node --format esm --splitting --packages external && tsc -p tsconfig.build.json",
 		"postbuild": "bun scripts/add-dts-extensions.ts",
 		"bench": "cd bench && bun install && bun run.ts",
 		"smoke": "bun run build && node scripts/smoke.mjs",
 		"test:types": "bun run build && bun tests/types-compat/run.ts",
+		"test:type-perf": "bun run build && bun test ./tests/type-perf",
+		"test:api": "bun run build && bun test ./tests/api-surface",
+		"docs:links": "bun scripts/check-doc-links.ts",
 		"test:interop": "cd examples/interop && bun install && bun test",
+		"test:blog": "cd examples/blog && bun install && bun test",
 		"prepare": "husky",
 		"prepublishOnly": "bun run typecheck && bun test && bun run smoke",
-		"test:codegen": "bun test --cwd packages/codegen",
+		"test:codegen": "bun run --cwd packages/codegen test",
+		"test:roundtrip": "bun run --cwd packages/codegen test:roundtrip",
 		"test:mcp": "bun test --cwd packages/mcp",
-		"build:packages": "bun run build && bun run --cwd packages/codegen build && bun run --cwd packages/mcp build"
+		"test:hono": "bun test --cwd packages/hono",
+		"test:drizzle": "bun test --cwd packages/drizzle",
+		"build:packages": "bun run build && bun run --cwd packages/codegen build && bun run --cwd packages/mcp build && bun run --cwd packages/hono build && bun run --cwd packages/drizzle build"
 	},
 	"dependencies": {
-		"slugify": "^1.6.9",
-		"typebox": "^1.4.3"
+		"slugify": "^1.6.9"
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.6.3",
 		"@commitlint/cli": "^21.2.4",
 		"@commitlint/config-conventional": "^21.2.4",
+		"@seriousme/openapi-schema-validator": "2.11.0",
 		"@types/bun": "^1.4.4",
 		"husky": "^9.1.7",
 		"knip": "^6.43.0",
-		"typescript": "^7.0.2"
+		"typebox": "^1.4.3",
+		"typescript": "^7.0.2",
+		"typescript-language-service": "npm:typescript@5.9.3"
 	},
 	"peerDependencies": {
-		"typescript": ">=5.5"
+		"typescript": ">=5.5",
+		"typebox": "^1"
 	},
 	"peerDependenciesMeta": {
 		"typescript": {