@agentuity/schema 0.0.69

package/src/__tests__/errors.test.ts

@@ -0,0 +1,129 @@
+import { describe, test, expect } from 'bun:test';
+import { s, ValidationError } from '../index.js';
+
+describe('Error Handling', () => {
+	describe('ValidationError', () => {
+		test('should contain issues array', () => {
+			const schema = s.string();
+
+			try {
+				schema.parse(123);
+				throw new Error('Expected parse to throw');
+			} catch (error) {
+				expect(error).toBeInstanceOf(ValidationError);
+				if (error instanceof ValidationError) {
+					expect(Array.isArray(error.issues)).toBe(true);
+					expect(error.issues.length).toBeGreaterThan(0);
+				} else {
+					throw error;
+				}
+			}
+		});
+
+		test('should include field paths', () => {
+			const schema = s.object({
+				user: s.object({
+					name: s.string(),
+				}),
+			});
+
+			try {
+				schema.parse({
+					user: {
+						name: 123,
+					},
+				});
+				throw new Error('Expected parse to throw');
+			} catch (error) {
+				expect(error).toBeInstanceOf(ValidationError);
+				if (error instanceof ValidationError) {
+					expect(error.issues[0].path).toEqual(['user', 'name']);
+				} else {
+					throw error;
+				}
+			}
+		});
+
+		test('should have readable error message', () => {
+			const schema = s.object({
+				age: s.number(),
+			});
+
+			try {
+				schema.parse({ age: 'invalid' });
+				throw new Error('Expected parse to throw');
+			} catch (error) {
+				expect(error).toBeInstanceOf(ValidationError);
+				if (error instanceof ValidationError) {
+					expect(error.message).toContain('age');
+					expect(error.message).toContain('number');
+				} else {
+					throw error;
+				}
+			}
+		});
+	});
+
+	describe('safeParse', () => {
+		test('should not throw on invalid data', () => {
+			const schema = s.string();
+			const result = schema.safeParse(123);
+
+			expect(result.success).toBe(false);
+			if (!result.success) {
+				expect(result.error).toBeInstanceOf(ValidationError);
+			}
+		});
+
+		test('should return data on valid input', () => {
+			const schema = s.string();
+			const result = schema.safeParse('hello');
+
+			expect(result.success).toBe(true);
+			if (result.success) {
+				expect(result.data).toBe('hello');
+			}
+		});
+	});
+
+	describe('parse', () => {
+		test('should throw ValidationError on invalid data', () => {
+			const schema = s.number();
+
+			expect(() => schema.parse('not-a-number')).toThrow(ValidationError);
+		});
+
+		test('should return typed data on valid input', () => {
+			const schema = s.number();
+			const result = schema.parse(42);
+
+			expect(result).toBe(42);
+		});
+	});
+
+	describe('multiple errors', () => {
+		test('should collect all validation errors', () => {
+			const schema = s.object({
+				name: s.string(),
+				age: s.number(),
+				email: s.string(),
+			});
+
+			try {
+				schema.parse({
+					name: 123,
+					age: 'invalid',
+					email: false,
+				});
+				throw new Error('Expected parse to throw');
+			} catch (error) {
+				expect(error).toBeInstanceOf(ValidationError);
+				if (error instanceof ValidationError) {
+					expect(error.issues.length).toBe(3);
+				} else {
+					throw error;
+				}
+			}
+		});
+	});
+});

package/src/__tests__/json-schema.test.ts

@@ -0,0 +1,138 @@
+import { describe, test, expect } from 'bun:test';
+import { s } from '../index.js';
+
+describe('JSON Schema Conversion', () => {
+	describe('toJSONSchema', () => {
+		test('should convert primitive types', () => {
+			const stringSchema = s.toJSONSchema(s.string());
+			expect(stringSchema.type).toBe('string');
+
+			const numberSchema = s.toJSONSchema(s.number());
+			expect(numberSchema.type).toBe('number');
+
+			const booleanSchema = s.toJSONSchema(s.boolean());
+			expect(booleanSchema.type).toBe('boolean');
+		});
+
+		test('should convert object schemas', () => {
+			const schema = s.object({
+				name: s.string(),
+				age: s.number(),
+			});
+
+			const jsonSchema = s.toJSONSchema(schema);
+			expect(jsonSchema.type).toBe('object');
+			expect(jsonSchema.properties).toHaveProperty('name');
+			expect(jsonSchema.properties).toHaveProperty('age');
+			expect(jsonSchema.required).toContain('name');
+			expect(jsonSchema.required).toContain('age');
+		});
+
+		test('should convert array schemas', () => {
+			const schema = s.array(s.string());
+			const jsonSchema = s.toJSONSchema(schema);
+
+			expect(jsonSchema.type).toBe('array');
+			expect(jsonSchema.items).toHaveProperty('type', 'string');
+		});
+
+		test('should preserve descriptions', () => {
+			const schema = s.string().describe('A test string');
+			const jsonSchema = s.toJSONSchema(schema);
+
+			expect(jsonSchema.description).toBe('A test string');
+		});
+
+		test('should handle optional fields', () => {
+			const schema = s.object({
+				required: s.string(),
+				optional: s.optional(s.string()),
+			});
+
+			const jsonSchema = s.toJSONSchema(schema);
+			expect(jsonSchema.required).toContain('required');
+			expect(jsonSchema.required).not.toContain('optional');
+		});
+
+		test('should handle nullable fields', () => {
+			const schema = s.nullable(s.string());
+			const jsonSchema = s.toJSONSchema(schema);
+
+			expect(jsonSchema.anyOf).toHaveLength(2);
+		});
+	});
+
+	describe('fromJSONSchema', () => {
+		test('should convert primitive types', () => {
+			const stringSchema = s.fromJSONSchema({ type: 'string' });
+			expect(stringSchema.parse('hello')).toBe('hello');
+
+			const numberSchema = s.fromJSONSchema({ type: 'number' });
+			expect(numberSchema.parse(123)).toBe(123);
+		});
+
+		test('should convert object schemas', () => {
+			const jsonSchema = {
+				type: 'object' as const,
+				properties: {
+					name: { type: 'string' as const },
+					age: { type: 'number' as const },
+				},
+				required: ['name', 'age'],
+			};
+
+			const schema = s.fromJSONSchema(jsonSchema);
+			const result = schema.parse({
+				name: 'John',
+				age: 30,
+			});
+
+			expect(result).toEqual({ name: 'John', age: 30 });
+		});
+
+		test('should convert array schemas', () => {
+			const jsonSchema = {
+				type: 'array' as const,
+				items: { type: 'string' as const },
+			};
+
+			const schema = s.fromJSONSchema(jsonSchema);
+			const result = schema.parse(['a', 'b', 'c']);
+
+			expect(result).toEqual(['a', 'b', 'c']);
+		});
+
+		test('should handle enum values', () => {
+			const jsonSchema = {
+				enum: ['red', 'green', 'blue'],
+			};
+
+			const schema = s.fromJSONSchema(jsonSchema);
+			expect(schema.parse('red')).toBe('red');
+		});
+	});
+
+	describe('round-trip conversion', () => {
+		test('should preserve schema through round-trip', () => {
+			const original = s.object({
+				name: s.string(),
+				age: s.number(),
+				tags: s.array(s.string()),
+			});
+
+			const jsonSchema = s.toJSONSchema(original);
+			const reconstructed = s.fromJSONSchema(jsonSchema);
+
+			const testData = {
+				name: 'Test',
+				age: 25,
+				tags: ['tag1', 'tag2'],
+			};
+
+			const originalResult = original.parse(testData);
+			const reconstructedResult = reconstructed.parse(testData);
+
+			expect(reconstructedResult).toEqual(originalResult);
+		});
+	});
+});

package/src/__tests__/primitives.test.ts

@@ -0,0 +1,184 @@
+import { describe, test, expect } from 'bun:test';
+import { s, ValidationError } from '../index.js';
+
+describe('Primitive Schemas', () => {
+	describe('string', () => {
+		const schema = s.string();
+
+		test('should validate strings', () => {
+			expect(schema.parse('hello')).toBe('hello');
+			expect(schema.parse('')).toBe('');
+		});
+
+		test('should reject non-strings', () => {
+			expect(() => schema.parse(123)).toThrow(ValidationError);
+			expect(() => schema.parse(true)).toThrow(ValidationError);
+			expect(() => schema.parse(null)).toThrow(ValidationError);
+		});
+
+		test('should work with safeParse', () => {
+			const result = schema.safeParse('test');
+			expect(result.success).toBe(true);
+			if (result.success) {
+				expect(result.data).toBe('test');
+			}
+
+			const badResult = schema.safeParse(123);
+			expect(badResult.success).toBe(false);
+		});
+
+		test('min() should enforce minimum length', () => {
+			const minSchema = s.string().min(3);
+			expect(minSchema.parse('hello')).toBe('hello');
+			expect(minSchema.parse('abc')).toBe('abc');
+			expect(() => minSchema.parse('ab')).toThrow(ValidationError);
+		});
+
+		test('max() should enforce maximum length', () => {
+			const maxSchema = s.string().max(5);
+			expect(maxSchema.parse('hello')).toBe('hello');
+			expect(maxSchema.parse('hi')).toBe('hi');
+			expect(() => maxSchema.parse('toolong')).toThrow(ValidationError);
+		});
+
+		test('should chain min and max', () => {
+			const rangeSchema = s.string().min(3).max(10);
+			expect(rangeSchema.parse('hello')).toBe('hello');
+			expect(() => rangeSchema.parse('ab')).toThrow(ValidationError);
+			expect(() => rangeSchema.parse('this is too long')).toThrow(ValidationError);
+		});
+	});
+
+	describe('number', () => {
+		const schema = s.number();
+
+		test('should validate numbers', () => {
+			expect(schema.parse(123)).toBe(123);
+			expect(schema.parse(0)).toBe(0);
+			expect(schema.parse(-45.67)).toBe(-45.67);
+			expect(schema.parse(Infinity)).toBe(Infinity);
+			expect(schema.parse(-Infinity)).toBe(-Infinity);
+		});
+
+		test('should reject non-numbers', () => {
+			expect(() => schema.parse('123')).toThrow(ValidationError);
+			expect(() => schema.parse(true)).toThrow(ValidationError);
+			expect(() => schema.parse(NaN)).toThrow(ValidationError);
+		});
+
+		test('finite() should reject Infinity', () => {
+			const finiteSchema = s.number().finite();
+			expect(finiteSchema.parse(123)).toBe(123);
+			expect(finiteSchema.parse(0)).toBe(0);
+			expect(finiteSchema.parse(-45.67)).toBe(-45.67);
+			expect(() => finiteSchema.parse(Infinity)).toThrow(ValidationError);
+			expect(() => finiteSchema.parse(-Infinity)).toThrow(ValidationError);
+		});
+
+		test('min() should enforce minimum', () => {
+			const minSchema = s.number().min(0);
+			expect(minSchema.parse(0)).toBe(0);
+			expect(minSchema.parse(10)).toBe(10);
+			expect(() => minSchema.parse(-1)).toThrow(ValidationError);
+		});
+
+		test('max() should enforce maximum', () => {
+			const maxSchema = s.number().max(100);
+			expect(maxSchema.parse(100)).toBe(100);
+			expect(maxSchema.parse(50)).toBe(50);
+			expect(() => maxSchema.parse(101)).toThrow(ValidationError);
+		});
+
+		test('should chain min and max', () => {
+			const rangeSchema = s.number().min(0).max(100);
+			expect(rangeSchema.parse(50)).toBe(50);
+			expect(() => rangeSchema.parse(-1)).toThrow(ValidationError);
+			expect(() => rangeSchema.parse(101)).toThrow(ValidationError);
+		});
+	});
+
+	describe('boolean', () => {
+		const schema = s.boolean();
+
+		test('should validate booleans', () => {
+			expect(schema.parse(true)).toBe(true);
+			expect(schema.parse(false)).toBe(false);
+		});
+
+		test('should reject non-booleans', () => {
+			expect(() => schema.parse('true')).toThrow(ValidationError);
+			expect(() => schema.parse(1)).toThrow(ValidationError);
+			expect(() => schema.parse(0)).toThrow(ValidationError);
+		});
+	});
+
+	describe('null', () => {
+		const schema = s.null();
+
+		test('should validate null', () => {
+			expect(schema.parse(null)).toBe(null);
+		});
+
+		test('should reject non-null', () => {
+			expect(() => schema.parse(undefined)).toThrow(ValidationError);
+			expect(() => schema.parse(0)).toThrow(ValidationError);
+		});
+	});
+
+	describe('undefined', () => {
+		const schema = s.undefined();
+
+		test('should validate undefined', () => {
+			expect(schema.parse(undefined)).toBe(undefined);
+		});
+
+		test('should reject non-undefined', () => {
+			expect(() => schema.parse(null)).toThrow(ValidationError);
+			expect(() => schema.parse(0)).toThrow(ValidationError);
+		});
+	});
+
+	describe('unknown', () => {
+		const schema = s.unknown();
+
+		test('should accept any value', () => {
+			expect(schema.parse(123)).toBe(123);
+			expect(schema.parse('hello')).toBe('hello');
+			expect(schema.parse(true)).toBe(true);
+			expect(schema.parse(null)).toBe(null);
+			expect(schema.parse(undefined)).toBe(undefined);
+			expect(schema.parse({ foo: 'bar' })).toEqual({ foo: 'bar' });
+			expect(schema.parse([1, 2, 3])).toEqual([1, 2, 3]);
+		});
+
+		test('should work with safeParse', () => {
+			const result = schema.safeParse('anything');
+			expect(result.success).toBe(true);
+			if (result.success) {
+				expect(result.data).toBe('anything');
+			}
+		});
+	});
+
+	describe('any', () => {
+		const schema = s.any();
+
+		test('should accept any value', () => {
+			expect(schema.parse(123)).toBe(123);
+			expect(schema.parse('hello')).toBe('hello');
+			expect(schema.parse(true)).toBe(true);
+			expect(schema.parse(null)).toBe(null);
+			expect(schema.parse(undefined)).toBe(undefined);
+			expect(schema.parse({ foo: 'bar' })).toEqual({ foo: 'bar' });
+			expect(schema.parse([1, 2, 3])).toEqual([1, 2, 3]);
+		});
+
+		test('should work with safeParse', () => {
+			const result = schema.safeParse('anything');
+			expect(result.success).toBe(true);
+			if (result.success) {
+				expect(result.data).toBe('anything');
+			}
+		});
+	});
+});

package/src/__tests__/type-inference.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, expect } from 'bun:test';
+import { s } from '../index.js';
+
+describe('Type Inference', () => {
+	test('should infer object types', () => {
+		const schema = s.object({
+			name: s.string(),
+			age: s.number(),
+		});
+
+		type User = s.infer<typeof schema>;
+
+		const user: User = schema.parse({
+			name: 'John',
+			age: 30,
+		});
+
+		expect(user.name).toBe('John');
+		expect(user.age).toBe(30);
+	});
+
+	test('should infer array types', () => {
+		const schema = s.array(s.string());
+		type StringArray = s.infer<typeof schema>;
+
+		const arr: StringArray = schema.parse(['a', 'b', 'c']);
+		expect(arr).toEqual(['a', 'b', 'c']);
+	});
+
+	test('should infer union types', () => {
+		const schema = s.union(s.literal('admin'), s.literal('user'));
+
+		type Role = s.infer<typeof schema>;
+
+		const role: Role = schema.parse('admin');
+		expect(role).toBe('admin');
+	});
+
+	test('should infer optional types', () => {
+		const schema = s.object({
+			required: s.string(),
+			optional: s.optional(s.number()),
+		});
+
+		type Data = s.infer<typeof schema>;
+
+		const data: Data = schema.parse({
+			required: 'test',
+		});
+
+		expect(data.required).toBe('test');
+		expect(data.optional).toBe(undefined);
+	});
+
+	test('should infer nullable types', () => {
+		const schema = s.object({
+			value: s.nullable(s.string()),
+		});
+
+		type Data = s.infer<typeof schema>;
+
+		const data: Data = schema.parse({
+			value: null,
+		});
+
+		expect(data.value).toBe(null);
+	});
+});

package/src/__tests__/utils.test.ts

@@ -0,0 +1,100 @@
+import { describe, test, expect } from 'bun:test';
+import { s, ValidationError } from '../index.js';
+
+describe('Utility Schemas', () => {
+	describe('literal', () => {
+		test('should validate exact string values', () => {
+			const schema = s.literal('admin');
+			expect(schema.parse('admin')).toBe('admin');
+			expect(() => schema.parse('user')).toThrow(ValidationError);
+		});
+
+		test('should validate exact number values', () => {
+			const schema = s.literal(42);
+			expect(schema.parse(42)).toBe(42);
+			expect(() => schema.parse(41)).toThrow(ValidationError);
+		});
+
+		test('should validate exact boolean values', () => {
+			const schema = s.literal(true);
+			expect(schema.parse(true)).toBe(true);
+			expect(() => schema.parse(false)).toThrow(ValidationError);
+		});
+	});
+
+	describe('enum', () => {
+		test('should validate enum values', () => {
+			const schema = s.enum(['red', 'green', 'blue']);
+			expect(schema.parse('red')).toBe('red');
+			expect(schema.parse('green')).toBe('green');
+			expect(() => schema.parse('yellow')).toThrow(ValidationError);
+		});
+
+		test('should work with numbers', () => {
+			const schema = s.enum([1, 2, 3]);
+			expect(schema.parse(2)).toBe(2);
+			expect(() => schema.parse(4)).toThrow(ValidationError);
+		});
+
+		test('should work with mixed types', () => {
+			const schema = s.enum(['active', 'inactive', 1, 2]);
+			expect(schema.parse('active')).toBe('active');
+			expect(schema.parse(1)).toBe(1);
+			expect(() => schema.parse('pending')).toThrow(ValidationError);
+		});
+	});
+
+	describe('optional', () => {
+		const schema = s.optional(s.string());
+
+		test('should validate undefined', () => {
+			expect(schema.parse(undefined)).toBe(undefined);
+		});
+
+		test('should validate the wrapped type', () => {
+			expect(schema.parse('hello')).toBe('hello');
+		});
+
+		test('should reject invalid values', () => {
+			expect(() => schema.parse(123)).toThrow(ValidationError);
+		});
+	});
+
+	describe('nullable', () => {
+		const schema = s.nullable(s.string());
+
+		test('should validate null', () => {
+			expect(schema.parse(null)).toBe(null);
+		});
+
+		test('should validate the wrapped type', () => {
+			expect(schema.parse('hello')).toBe('hello');
+		});
+
+		test('should reject invalid values', () => {
+			expect(() => schema.parse(123)).toThrow(ValidationError);
+		});
+	});
+
+	describe('union', () => {
+		const schema = s.union(s.string(), s.number(), s.boolean());
+
+		test('should validate any union member', () => {
+			expect(schema.parse('hello')).toBe('hello');
+			expect(schema.parse(123)).toBe(123);
+			expect(schema.parse(true)).toBe(true);
+		});
+
+		test('should reject non-members', () => {
+			expect(() => schema.parse(null)).toThrow(ValidationError);
+			expect(() => schema.parse(undefined)).toThrow(ValidationError);
+		});
+
+		test('should work with literal union (enum-like)', () => {
+			const roleSchema = s.union(s.literal('admin'), s.literal('user'), s.literal('guest'));
+
+			expect(roleSchema.parse('admin')).toBe('admin');
+			expect(() => roleSchema.parse('superuser')).toThrow(ValidationError);
+		});
+	});
+});