@notionhq/workers 0.0.82 → 0.0.86

package/src/schema-builder.test.ts

@@ -0,0 +1,677 @@
+import { describe, expect, it } from "vitest";
+import type { JSONSchema } from "./json-schema.js";
+import {
+	getSchema,
+	type Infer,
+	j,
+	type SchemaBuilder,
+} from "./schema-builder.js";
+
+// ---------------------------------------------------------------------------
+// 1. Primitives
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — primitives", () => {
+	it("string()", () => {
+		expect(getSchema(j.string())).toEqual({ type: "string" });
+	});
+
+	it("number()", () => {
+		expect(getSchema(j.number())).toEqual({ type: "number" });
+	});
+
+	it("integer()", () => {
+		expect(getSchema(j.integer())).toEqual({ type: "integer" });
+	});
+
+	it("boolean()", () => {
+		expect(getSchema(j.boolean())).toEqual({ type: "boolean" });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 2. Description
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — description", () => {
+	it("adds description field", () => {
+		expect(getSchema(j.string().describe("A name"))).toEqual({
+			type: "string",
+			description: "A name",
+		});
+	});
+
+	it("is chainable — last wins", () => {
+		const s = j.number().describe("first").describe("second");
+		expect(getSchema(s)).toEqual({
+			type: "number",
+			description: "second",
+		});
+	});
+
+	it("works on all primitive types", () => {
+		expect(getSchema(j.boolean().describe("flag"))).toEqual({
+			type: "boolean",
+			description: "flag",
+		});
+		expect(getSchema(j.integer().describe("count"))).toEqual({
+			type: "integer",
+			description: "count",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 3. Enum
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — enum", () => {
+	it("string enum", () => {
+		expect(getSchema(j.enum("a", "b", "c"))).toEqual({
+			type: "string",
+			enum: ["a", "b", "c"],
+		});
+	});
+
+	it("number enum", () => {
+		expect(getSchema(j.enum(1, 2, 3))).toEqual({
+			type: "number",
+			enum: [1, 2, 3],
+		});
+	});
+
+	it("string enum type inference", () => {
+		const s = j.enum("x", "y");
+		type T = Infer<typeof s>;
+		const _a: T = "x";
+		const _b: T = "y";
+		expect(getSchema(s)).toBeDefined();
+	});
+
+	it("number enum type inference", () => {
+		const s = j.enum(10, 20);
+		type T = Infer<typeof s>;
+		const _a: T = 10;
+		const _b: T = 20;
+		expect(getSchema(s)).toBeDefined();
+	});
+
+	it("enum with description", () => {
+		expect(getSchema(j.enum("a", "b").describe("pick one"))).toEqual({
+			type: "string",
+			enum: ["a", "b"],
+			description: "pick one",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 4. Format shorthands
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — format shorthands", () => {
+	it("datetime()", () => {
+		expect(getSchema(j.datetime())).toEqual({
+			type: "string",
+			format: "date-time",
+		});
+	});
+
+	it("date()", () => {
+		expect(getSchema(j.date())).toEqual({ type: "string", format: "date" });
+	});
+
+	it("time()", () => {
+		expect(getSchema(j.time())).toEqual({ type: "string", format: "time" });
+	});
+
+	it("duration()", () => {
+		expect(getSchema(j.duration())).toEqual({
+			type: "string",
+			format: "duration",
+		});
+	});
+
+	it("email()", () => {
+		expect(getSchema(j.email())).toEqual({
+			type: "string",
+			format: "email",
+		});
+	});
+
+	it("hostname()", () => {
+		expect(getSchema(j.hostname())).toEqual({
+			type: "string",
+			format: "hostname",
+		});
+	});
+
+	it("ipv4()", () => {
+		expect(getSchema(j.ipv4())).toEqual({ type: "string", format: "ipv4" });
+	});
+
+	it("ipv6()", () => {
+		expect(getSchema(j.ipv6())).toEqual({ type: "string", format: "ipv6" });
+	});
+
+	it("uuid()", () => {
+		expect(getSchema(j.uuid())).toEqual({ type: "string", format: "uuid" });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 5. Array
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — array", () => {
+	it("basic array", () => {
+		expect(getSchema(j.array(j.string()))).toEqual({
+			type: "array",
+			items: { type: "string" },
+		});
+	});
+
+	it("array with minItems 1", () => {
+		expect(getSchema(j.array(j.string(), { minItems: 1 }))).toEqual({
+			type: "array",
+			items: { type: "string" },
+			minItems: 1,
+		});
+	});
+
+	it("array with minItems 0", () => {
+		expect(getSchema(j.array(j.number(), { minItems: 0 }))).toEqual({
+			type: "array",
+			items: { type: "number" },
+			minItems: 0,
+		});
+	});
+
+	it("array of objects", () => {
+		const schema = getSchema(
+			j.array(j.object({ name: j.string(), age: j.number() })),
+		);
+		expect(schema).toEqual({
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					age: { type: "number" },
+				},
+				required: ["name", "age"],
+				additionalProperties: false,
+			},
+		});
+	});
+
+	it("rejects minItems > 1 at type level", () => {
+		// @ts-expect-error — minItems can only be 0 or 1
+		j.array(j.string(), { minItems: 2 });
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 6. Object
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — object", () => {
+	it("auto-generates required and additionalProperties: false", () => {
+		const schema = getSchema(
+			j.object({
+				name: j.string(),
+				age: j.number(),
+			}),
+		);
+		expect(schema).toEqual({
+			type: "object",
+			properties: {
+				name: { type: "string" },
+				age: { type: "number" },
+			},
+			required: ["name", "age"],
+			additionalProperties: false,
+		});
+	});
+
+	it("nested objects", () => {
+		const schema = getSchema(
+			j.object({
+				address: j.object({
+					street: j.string(),
+					zip: j.string(),
+				}),
+			}),
+		);
+		expect(schema).toEqual({
+			type: "object",
+			properties: {
+				address: {
+					type: "object",
+					properties: {
+						street: { type: "string" },
+						zip: { type: "string" },
+					},
+					required: ["street", "zip"],
+					additionalProperties: false,
+				},
+			},
+			required: ["address"],
+			additionalProperties: false,
+		});
+	});
+
+	it("empty object", () => {
+		expect(getSchema(j.object({}))).toEqual({
+			type: "object",
+			properties: {},
+			required: [],
+			additionalProperties: false,
+		});
+	});
+
+	it("object with description", () => {
+		const schema = getSchema(j.object({ x: j.number() }).describe("A point"));
+		expect(schema).toEqual({
+			type: "object",
+			properties: { x: { type: "number" } },
+			required: ["x"],
+			additionalProperties: false,
+			description: "A point",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 7. Nullable
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — nullable", () => {
+	it("wraps in anyOf with null", () => {
+		expect(getSchema(j.string().nullable())).toEqual({
+			anyOf: [{ type: "string" }, { type: "null" }],
+		});
+	});
+
+	it("hoists description to outer wrapper", () => {
+		expect(getSchema(j.string().describe("A name").nullable())).toEqual({
+			anyOf: [{ type: "string" }, { type: "null" }],
+			description: "A name",
+		});
+	});
+
+	it("description after nullable sets on wrapper", () => {
+		expect(getSchema(j.string().nullable().describe("A name"))).toEqual({
+			anyOf: [{ type: "string" }, { type: "null" }],
+			description: "A name",
+		});
+	});
+
+	it("nullable number", () => {
+		expect(getSchema(j.number().nullable())).toEqual({
+			anyOf: [{ type: "number" }, { type: "null" }],
+		});
+	});
+
+	it("nullable enum", () => {
+		expect(getSchema(j.enum("a", "b").nullable())).toEqual({
+			anyOf: [{ type: "string", enum: ["a", "b"] }, { type: "null" }],
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 8. Ref
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — ref", () => {
+	it("produces $ref schema", () => {
+		expect(getSchema(j.ref("#/$defs/Foo"))).toEqual({
+			$ref: "#/$defs/Foo",
+		});
+	});
+
+	it("ref with description", () => {
+		expect(getSchema(j.ref("#/$defs/Bar").describe("A bar ref"))).toEqual({
+			$ref: "#/$defs/Bar",
+			description: "A bar ref",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 9. AnyOf
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — anyOf", () => {
+	it("produces anyOf schema", () => {
+		expect(getSchema(j.anyOf(j.string(), j.number()))).toEqual({
+			anyOf: [{ type: "string" }, { type: "number" }],
+		});
+	});
+
+	it("anyOf with description", () => {
+		expect(
+			getSchema(j.anyOf(j.string(), j.number()).describe("string or number")),
+		).toEqual({
+			anyOf: [{ type: "string" }, { type: "number" }],
+			description: "string or number",
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 9b. Discriminated unions
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — discriminated unions", () => {
+	it("two-variant discriminated union", () => {
+		const schema = j.anyOf(
+			j.object({ type: j.enum("text"), value: j.string() }),
+			j.object({ type: j.enum("number"), value: j.number() }),
+		);
+
+		expect(getSchema(schema)).toEqual({
+			anyOf: [
+				{
+					type: "object",
+					properties: {
+						type: { type: "string", enum: ["text"] },
+						value: { type: "string" },
+					},
+					required: ["type", "value"],
+					additionalProperties: false,
+				},
+				{
+					type: "object",
+					properties: {
+						type: { type: "string", enum: ["number"] },
+						value: { type: "number" },
+					},
+					required: ["type", "value"],
+					additionalProperties: false,
+				},
+			],
+		});
+	});
+
+	it("three-variant discriminated union with different shapes", () => {
+		const schema = j.anyOf(
+			j.object({ kind: j.enum("circle"), radius: j.number() }),
+			j.object({
+				kind: j.enum("rectangle"),
+				width: j.number(),
+				height: j.number(),
+			}),
+			j.object({
+				kind: j.enum("polygon"),
+				sides: j.array(j.object({ x: j.number(), y: j.number() })),
+			}),
+		);
+
+		const raw = getSchema(schema) as unknown as {
+			anyOf: Record<string, unknown>[];
+		};
+		expect(raw.anyOf).toHaveLength(3);
+
+		// Each variant is a valid object schema with required + additionalProperties
+		for (const variant of raw.anyOf) {
+			expect(variant.type).toBe("object");
+			expect(variant.additionalProperties).toBe(false);
+			expect(Array.isArray(variant.required)).toBe(true);
+			expect(variant.required).toContain("kind");
+		}
+
+		// Verify discriminant values
+		const discriminants = raw.anyOf.map(
+			(v) =>
+				(
+					(v.properties as Record<string, Record<string, unknown>>).kind as {
+						enum: string[];
+					}
+				).enum[0],
+		);
+		expect(discriminants).toEqual(["circle", "rectangle", "polygon"]);
+	});
+
+	it("discriminated union type inference", () => {
+		const schema = j.anyOf(
+			j.object({ status: j.enum("ok"), data: j.string() }),
+			j.object({ status: j.enum("error"), message: j.string() }),
+		);
+
+		type T = Infer<typeof schema>;
+
+		// Both variants are assignable
+		const _ok: T = { status: "ok", data: "hello" };
+		const _err: T = { status: "error", message: "fail" };
+		expect(getSchema(schema)).toBeDefined();
+	});
+
+	it("discriminated union with description on wrapper", () => {
+		const schema = j
+			.anyOf(
+				j.object({ type: j.enum("a"), x: j.number() }),
+				j.object({ type: j.enum("b"), y: j.string() }),
+			)
+			.describe("A or B");
+
+		const raw = getSchema(schema) as unknown as Record<string, unknown>;
+		expect(raw.description).toBe("A or B");
+		expect(raw.anyOf).toHaveLength(2);
+	});
+
+	it("discriminated union with descriptions on individual variants", () => {
+		const schema = j.anyOf(
+			j
+				.object({ type: j.enum("text"), value: j.string() })
+				.describe("A text node"),
+			j
+				.object({ type: j.enum("image"), url: j.string() })
+				.describe("An image node"),
+		);
+
+		const raw = getSchema(schema) as unknown as {
+			anyOf: Record<string, unknown>[];
+		};
+		expect(raw.anyOf[0]?.description).toBe("A text node");
+		expect(raw.anyOf[1]?.description).toBe("An image node");
+	});
+
+	it("discriminated union nested inside object property", () => {
+		const schema = j.object({
+			id: j.string(),
+			content: j.anyOf(
+				j.object({ type: j.enum("text"), body: j.string() }),
+				j.object({
+					type: j.enum("code"),
+					language: j.string(),
+					source: j.string(),
+				}),
+			),
+		});
+
+		const raw = getSchema(schema) as unknown as {
+			properties: { content: { anyOf: Record<string, unknown>[] } };
+		};
+		expect(raw.properties.content.anyOf).toHaveLength(2);
+
+		// The content field is in required
+		expect(
+			(getSchema(schema) as unknown as Record<string, unknown>).required,
+		).toContain("content");
+	});
+
+	it("nullable discriminated union", () => {
+		const schema = j
+			.anyOf(
+				j.object({ type: j.enum("a"), value: j.number() }),
+				j.object({ type: j.enum("b"), value: j.string() }),
+			)
+			.nullable();
+
+		const raw = getSchema(schema) as unknown as {
+			anyOf: Record<string, unknown>[];
+		};
+		// Should have the original anyOf wrapper + null
+		expect(raw.anyOf).toHaveLength(2);
+		expect(raw.anyOf[0]).toHaveProperty("anyOf"); // inner anyOf with the two variants
+		expect(raw.anyOf[1]).toEqual({ type: "null" });
+	});
+
+	it("discriminated union validates with AJV", () => {
+		const { Ajv } = require("ajv") as typeof import("ajv");
+		const ajv = new Ajv();
+
+		const schema = j.anyOf(
+			j.object({ action: j.enum("create"), name: j.string() }),
+			j.object({ action: j.enum("delete"), id: j.number() }),
+		);
+
+		const validate = ajv.compile(getSchema(schema));
+
+		expect(validate({ action: "create", name: "foo" })).toBe(true);
+		expect(validate({ action: "delete", id: 42 })).toBe(true);
+		expect(validate({ action: "create", id: 42 })).toBe(false);
+		expect(validate({ action: "update", name: "foo" })).toBe(false);
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 10. Type inference
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — type inference", () => {
+	it("getSchema output satisfies JSONSchema<T>", () => {
+		const s = j.object({
+			name: j.string(),
+			tags: j.array(j.string()),
+		});
+		const schema: JSONSchema<{ name: string; tags: string[] }> = getSchema(s);
+		expect(schema).toBeDefined();
+	});
+
+	it("Infer extracts T from SchemaBuilder<T>", () => {
+		type S = SchemaBuilder<{ name: string; age: number }>;
+		type T = Infer<S>;
+		const _: T = { name: "Alice", age: 30 };
+		expect(true).toBe(true);
+	});
+
+	it("nullable type inference", () => {
+		const s = j.object({
+			name: j.string(),
+			nickname: j.string().nullable(),
+		});
+		type T = Infer<typeof s>;
+		const _: T = { name: "Alice", nickname: null };
+		const _2: T = { name: "Alice", nickname: "Bob" };
+		expect(getSchema(s)).toBeDefined();
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 11. Integration — complex schema round-trip
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — integration", () => {
+	it("complex schema produces correct output", () => {
+		const schema = j.object({
+			foo: j.enum("a", "b", "c").describe("The foo field"),
+			bar: j.string(),
+			count: j.number(),
+			tags: j.array(j.string()),
+			address: j.object({
+				street: j.string(),
+				zip: j.string(),
+			}),
+			nickname: j.string().nullable(),
+			createdAt: j.datetime(),
+		});
+
+		expect(getSchema(schema)).toEqual({
+			type: "object",
+			properties: {
+				foo: {
+					type: "string",
+					enum: ["a", "b", "c"],
+					description: "The foo field",
+				},
+				bar: { type: "string" },
+				count: { type: "number" },
+				tags: { type: "array", items: { type: "string" } },
+				address: {
+					type: "object",
+					properties: {
+						street: { type: "string" },
+						zip: { type: "string" },
+					},
+					required: ["street", "zip"],
+					additionalProperties: false,
+				},
+				nickname: {
+					anyOf: [{ type: "string" }, { type: "null" }],
+				},
+				createdAt: { type: "string", format: "date-time" },
+			},
+			required: [
+				"foo",
+				"bar",
+				"count",
+				"tags",
+				"address",
+				"nickname",
+				"createdAt",
+			],
+			additionalProperties: false,
+		});
+	});
+});
+
+// ---------------------------------------------------------------------------
+// 12. Constraint enforcement
+// ---------------------------------------------------------------------------
+
+describe("json-schema-builder — constraint enforcement", () => {
+	it("object always has required matching properties keys", () => {
+		const schema = getSchema(
+			j.object({ x: j.number(), y: j.string(), z: j.boolean() }),
+		);
+		const raw = schema as unknown as Record<string, unknown>;
+		expect(raw.required).toEqual(["x", "y", "z"]);
+		expect(raw.additionalProperties).toBe(false);
+	});
+
+	it("no forbidden keywords in output", () => {
+		const schema = getSchema(
+			j.object({
+				name: j.string(),
+				items: j.array(j.number()),
+				nested: j.object({ a: j.boolean() }),
+			}),
+		);
+		const json = JSON.stringify(schema);
+		expect(json).not.toContain('"allOf"');
+		expect(json).not.toContain('"not"');
+		expect(json).not.toContain('"if"');
+		expect(json).not.toContain('"then"');
+		expect(json).not.toContain('"else"');
+	});
+
+	it("nested objects also enforce required and additionalProperties", () => {
+		const schema = getSchema(
+			j.object({
+				outer: j.object({
+					inner: j.object({
+						value: j.string(),
+					}),
+				}),
+			}),
+		);
+		const raw = schema as unknown as Record<string, unknown>;
+		const outer = (raw as { properties: { outer: Record<string, unknown> } })
+			.properties.outer;
+		expect(outer.required).toEqual(["inner"]);
+		expect(outer.additionalProperties).toBe(false);
+	});
+});