first commit

packages/core/tests/fields/image.test.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+
+import { image } from "../../src/fields/image.js";
+
+describe("image field", () => {
+	it("should create field definition", () => {
+		const field = image();
+
+		expect(field.type).toBe("image");
+		expect(field.schema).toBeDefined();
+		expect(field.ui?.widget).toBe("image");
+	});
+
+	it("should accept valid image value", () => {
+		const field = image();
+		const valid = {
+			id: "img-123",
+			src: "https://example.com/image.jpg",
+			alt: "Test image",
+			width: 800,
+			height: 600,
+		};
+
+		expect(() => field.schema.parse(valid)).not.toThrow();
+	});
+
+	it("should accept image without optional fields", () => {
+		const field = image();
+		const minimal = {
+			id: "img-123",
+			src: "https://example.com/image.jpg",
+		};
+
+		expect(() => field.schema.parse(minimal)).not.toThrow();
+	});
+
+	it("should reject invalid image value", () => {
+		const field = image();
+
+		expect(() => field.schema.parse({ id: "missing-src" })).toThrow();
+		expect(() => field.schema.parse("not an object")).toThrow();
+	});
+
+	it("should support required option", () => {
+		const required = image({ required: true });
+		const optional = image({ required: false });
+
+		// Required should reject undefined
+		expect(() => required.schema.parse(undefined)).toThrow();
+
+		// Optional should accept undefined
+		expect(() => optional.schema.parse(undefined)).not.toThrow();
+	});
+
+	it("should store options", () => {
+		const field = image({
+			maxSize: 5 * 1024 * 1024, // 5MB
+			allowedTypes: ["image/jpeg", "image/png"],
+		});
+
+		expect(field.options?.maxSize).toBe(5 * 1024 * 1024);
+		expect(field.options?.allowedTypes).toEqual(["image/jpeg", "image/png"]);
+	});
+});

packages/core/tests/fields/portable-text.test.ts

@@ -0,0 +1,45 @@
+import { describe, it, expect } from "vitest";
+
+import { portableText } from "../../src/fields/portable-text.js";
+
+describe("portableText field", () => {
+	it("should create field definition", () => {
+		const field = portableText();
+
+		expect(field.type).toBe("portableText");
+		expect(field.schema).toBeDefined();
+		expect(field.ui?.widget).toBe("portableText");
+	});
+
+	it("should accept valid Portable Text", () => {
+		const field = portableText();
+		const valid = [
+			{
+				_type: "block",
+				_key: "abc123",
+				style: "normal",
+				children: [{ _type: "span", text: "Hello World" }],
+			},
+		];
+
+		expect(() => field.schema.parse(valid)).not.toThrow();
+	});
+
+	it("should reject invalid Portable Text", () => {
+		const field = portableText();
+
+		expect(() => field.schema.parse("not an array")).toThrow();
+		expect(() => field.schema.parse([{ missing: "_type" }])).toThrow();
+	});
+
+	it("should support required option", () => {
+		const required = portableText({ required: true });
+		const optional = portableText({ required: false });
+
+		// Required should reject undefined
+		expect(() => required.schema.parse(undefined)).toThrow();
+
+		// Optional should accept undefined
+		expect(() => optional.schema.parse(undefined)).not.toThrow();
+	});
+});

packages/core/tests/fields/reference.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from "vitest";
+
+import { reference } from "../../src/fields/reference.js";
+
+describe("reference field", () => {
+	it("should create field definition", () => {
+		const field = reference("posts");
+
+		expect(field.type).toBe("reference");
+		expect(field.schema).toBeDefined();
+		expect(field.ui?.widget).toBe("reference");
+		expect(field.options?.collection).toBe("posts");
+	});
+
+	it("should accept valid reference ID", () => {
+		const field = reference("posts");
+
+		expect(() => field.schema.parse("post-123")).not.toThrow();
+		expect(() => field.schema.parse("abc-def-ghi")).not.toThrow();
+	});
+
+	it("should reject invalid reference", () => {
+		const field = reference("posts");
+
+		expect(() => field.schema.parse(123)).toThrow();
+		expect(() => field.schema.parse({})).toThrow();
+		expect(() => field.schema.parse(null)).toThrow();
+	});
+
+	it("should support required option", () => {
+		const required = reference("posts", { required: true });
+		const optional = reference("posts", { required: false });
+
+		// Required should reject undefined
+		expect(() => required.schema.parse(undefined)).toThrow();
+
+		// Optional should accept undefined
+		expect(() => optional.schema.parse(undefined)).not.toThrow();
+	});
+});