@forgehive/schema 0.1.3 → 0.2.0

package/dist/test/optionals.test.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("../index");
-describe('Schema Custom Validations', () => {
+describe('Schema Optional Fields', () => {
     describe('Optional Fields', () => {
         it('should handle optional string fields', () => {
-            const schema = index_1.Schema.from({
-                name: { type: 'string', optional: true },
-                age: { type: 'number' }
+            const schema = new index_1.Schema({
+                name: index_1.Schema.string().optional(),
+                age: index_1.Schema.number()
             });
             // Valid with optional field present
             expect(schema.validate({ name: 'John', age: 30 })).toBe(true);
@@ -16,9 +16,9 @@ describe('Schema Custom Validations', () => {
             expect(schema.validate({ name: 'John' })).toBe(false);
         });
         it('should handle optional array fields', () => {
-            const schema = index_1.Schema.from({
-                tags: { type: 'array', items: { type: 'string' }, optional: true },
-                scores: { type: 'array', items: { type: 'number' } }
+            const schema = new index_1.Schema({
+                tags: index_1.Schema.array(index_1.Schema.string()).optional(),
+                scores: index_1.Schema.array(index_1.Schema.number())
             });
             // Valid with optional array present
             expect(schema.validate({ tags: ['tag1', 'tag2'], scores: [1, 2, 3] })).toBe(true);
@@ -28,23 +28,25 @@ describe('Schema Custom Validations', () => {
             expect(schema.validate({ tags: ['tag1'] })).toBe(false);
         });
         it('should correctly describe optional fields', () => {
-            const schema = index_1.Schema.from({
-                name: { type: 'string', optional: true },
-                age: { type: 'number' },
-                tags: { type: 'array', items: { type: 'string' }, optional: true }
+            const schema = new index_1.Schema({
+                name: index_1.Schema.string().optional(),
+                age: index_1.Schema.number(),
+                tags: index_1.Schema.array(index_1.Schema.string()).optional()
             });
             const description = schema.describe();
-            expect(description.name).toEqual({ type: 'string', optional: true });
-            expect(description.age).toEqual({ type: 'number' });
-            expect(description.tags).toEqual({ type: 'array', items: { type: 'string' }, optional: true });
+            // Optionality is expressed by absence from the `required` list
+            expect(description.required).toEqual(['age']);
+            expect(description.properties?.name).toEqual({ type: 'string' });
+            expect(description.properties?.age).toEqual({ type: 'number' });
+            expect(description.properties?.tags).toEqual({ type: 'array', items: { type: 'string' } });
         });
     });
     describe('Schema Roundtrip', () => {
         it('should maintain optional fields through describe/from cycle', () => {
-            const originalSchema = index_1.Schema.from({
-                name: { type: 'string', optional: true },
-                age: { type: 'number' },
-                tags: { type: 'array', items: { type: 'string' }, optional: true }
+            const originalSchema = new index_1.Schema({
+                name: index_1.Schema.string().optional(),
+                age: index_1.Schema.number(),
+                tags: index_1.Schema.array(index_1.Schema.string()).optional()
             });
             const description = originalSchema.describe();
             const reconstructedSchema = index_1.Schema.from(description);
@@ -55,6 +57,8 @@ describe('Schema Custom Validations', () => {
             expect(reconstructedSchema.validate(validData)).toBe(true);
             expect(originalSchema.validate(dataWithoutOptional)).toBe(true);
             expect(reconstructedSchema.validate(dataWithoutOptional)).toBe(true);
+            // The reconstructed schema preserves which field stayed required
+            expect(reconstructedSchema.describe().required).toEqual(['age']);
         });
     });
 });

package/dist/test/parse.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/parse.test.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('Schema.parse()', () => {
+    it('returns typed data on success', () => {
+        const schema = new index_1.Schema({
+            name: index_1.Schema.string(),
+            age: index_1.Schema.number(),
+        });
+        const data = schema.parse({ name: 'John', age: 30 });
+        expect(data).toEqual({ name: 'John', age: 30 });
+        // Type-level: the result is { name: string; age: number }
+        const name = data.name;
+        const age = data.age;
+        expect(name).toBe('John');
+        expect(age).toBe(30);
+    });
+    it('strips unknown keys', () => {
+        const schema = new index_1.Schema({
+            name: index_1.Schema.string(),
+        });
+        const data = schema.parse({ name: 'John', extra: 'ignored' });
+        expect(data).toEqual({ name: 'John' });
+        expect(data).not.toHaveProperty('extra');
+    });
+    it('coerces nothing and throws ZodError on invalid data', () => {
+        const schema = new index_1.Schema({
+            name: index_1.Schema.string(),
+            age: index_1.Schema.number(),
+        });
+        expect(() => schema.parse({ name: 'John', age: 'thirty' })).toThrow();
+    });
+    it('throws a ZodError exposing issues with path and message', () => {
+        const schema = new index_1.Schema({
+            name: index_1.Schema.string(),
+            age: index_1.Schema.number().min(18),
+        });
+        try {
+            schema.parse({ name: 123, age: 10 });
+            throw new Error('expected parse to throw');
+        }
+        catch (err) {
+            const zodError = err;
+            expect(Array.isArray(zodError.issues)).toBe(true);
+            const paths = (zodError.issues ?? []).map((issue) => issue.path.join('.'));
+            expect(paths).toContain('name');
+            expect(paths).toContain('age');
+        }
+    });
+    it('parses nested objects and optionals', () => {
+        const schema = new index_1.Schema({
+            user: index_1.Schema.object({
+                name: index_1.Schema.string(),
+                nickname: index_1.Schema.string().optional(),
+            }),
+        });
+        expect(schema.parse({ user: { name: 'John' } })).toEqual({ user: { name: 'John' } });
+        expect(schema.parse({ user: { name: 'John', nickname: 'JJ' } })).toEqual({
+            user: { name: 'John', nickname: 'JJ' },
+        });
+        expect(() => schema.parse({ user: {} })).toThrow();
+    });
+});
+describe('Schema.safeParse()', () => {
+    it('returns success: true with data on valid input', () => {
+        const schema = new index_1.Schema({
+            name: index_1.Schema.string(),
+            age: index_1.Schema.number(),
+        });
+        const result = schema.safeParse({ name: 'John', age: 30 });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toEqual({ name: 'John', age: 30 });
+            // Type-level: result.data is fully typed
+            const name = result.data.name;
+            expect(name).toBe('John');
+        }
+    });
+    it('returns success: false with an error on invalid input', () => {
+        const schema = new index_1.Schema({
+            name: index_1.Schema.string(),
+            age: index_1.Schema.number(),
+        });
+        const result = schema.safeParse({ name: 'John', age: 'thirty' });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            expect(result.error).toBeDefined();
+            expect(Array.isArray(result.error.issues)).toBe(true);
+            const paths = result.error.issues.map((issue) => issue.path.join('.'));
+            expect(paths).toContain('age');
+        }
+    });
+    it('does not throw on invalid input', () => {
+        const schema = new index_1.Schema({
+            age: index_1.Schema.number(),
+        });
+        expect(() => schema.safeParse({ age: 'nope' })).not.toThrow();
+    });
+    it('reports each failing field in the issues list', () => {
+        const schema = new index_1.Schema({
+            email: index_1.Schema.email(),
+            age: index_1.Schema.number().min(18),
+            username: index_1.Schema.string().min(3),
+        });
+        const result = schema.safeParse({ email: 'nope', age: 5, username: 'ab' });
+        expect(result.success).toBe(false);
+        if (!result.success) {
+            const paths = result.error.issues.map((issue) => issue.path.join('.'));
+            expect(paths).toEqual(expect.arrayContaining(['email', 'age', 'username']));
+        }
+    });
+    it('strips unknown keys on success', () => {
+        const schema = new index_1.Schema({
+            name: index_1.Schema.string(),
+        });
+        const result = schema.safeParse({ name: 'John', extra: true });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.data).toEqual({ name: 'John' });
+        }
+    });
+    it('infers optional fields as possibly undefined', () => {
+        const schema = new index_1.Schema({
+            name: index_1.Schema.string(),
+            age: index_1.Schema.number().optional(),
+        });
+        const result = schema.safeParse({ name: 'John' });
+        expect(result.success).toBe(true);
+        if (result.success) {
+            const age = result.data.age;
+            expect(age).toBeUndefined();
+        }
+    });
+});

package/dist/test/record.test.js

@@ -32,22 +32,17 @@ describe('Schema Record Types', () => {
             });
             expect(result).toBe(false);
         });
-        it('should create a schema from description with string record type', () => {
-            const description = {
-                data: {
-                    type: 'stringRecord',
-                    optional: false
-                }
-            };
-            const schema = index_1.default.from(description);
+        it('should round-trip a string record schema', () => {
+            const schema = index_1.default.from(new index_1.default({
+                data: index_1.default.stringRecord(),
+            }).describe());
             const validData = {
                 data: {
                     firstName: 'John',
                     lastName: 'Doe'
                 }
             };
-            const result = schema.validate(validData);
-            expect(result).toBe(true);
+            expect(schema.validate(validData)).toBe(true);
         });
     });
     describe('Number Record', () => {
@@ -77,22 +72,17 @@ describe('Schema Record Types', () => {
             });
             expect(result).toBe(false);
         });
-        it('should create a schema from description with number record type', () => {
-            const description = {
-                data: {
-                    type: 'numberRecord',
-                    optional: false
-                }
-            };
-            const schema = index_1.default.from(description);
+        it('should round-trip a number record schema', () => {
+            const schema = index_1.default.from(new index_1.default({
+                data: index_1.default.numberRecord(),
+            }).describe());
             const validData = {
                 data: {
                     age: 30,
                     experience: 5
                 }
             };
-            const result = schema.validate(validData);
-            expect(result).toBe(true);
+            expect(schema.validate(validData)).toBe(true);
         });
     });
     describe('Boolean Record', () => {
@@ -122,22 +112,17 @@ describe('Schema Record Types', () => {
             });
             expect(result).toBe(false);
         });
-        it('should create a schema from description with boolean record type', () => {
-            const description = {
-                data: {
-                    type: 'booleanRecord',
-                    optional: false
-                }
-            };
-            const schema = index_1.default.from(description);
+        it('should round-trip a boolean record schema', () => {
+            const schema = index_1.default.from(new index_1.default({
+                data: index_1.default.booleanRecord(),
+            }).describe());
             const validData = {
                 data: {
                     isActive: true,
                     isAdmin: false
                 }
             };
-            const result = schema.validate(validData);
-            expect(result).toBe(true);
+            expect(schema.validate(validData)).toBe(true);
         });
     });
     describe('Mixed Record', () => {
@@ -206,14 +191,10 @@ describe('Schema Record Types', () => {
             });
             expect(result).toBe(false);
         });
-        it('should create a schema from description with mixed record type', () => {
-            const description = {
-                data: {
-                    type: 'mixedRecord',
-                    optional: false
-                }
-            };
-            const schema = index_1.default.from(description);
+        it('should round-trip a mixed record schema', () => {
+            const schema = index_1.default.from(new index_1.default({
+                data: index_1.default.mixedRecord(),
+            }).describe());
             const validData = {
                 data: {
                     name: 'John',
@@ -221,12 +202,11 @@ describe('Schema Record Types', () => {
                     isActive: true
                 }
             };
-            const result = schema.validate(validData);
-            expect(result).toBe(true);
+            expect(schema.validate(validData)).toBe(true);
         });
     });
     describe('Common Record Functionality', () => {
-        it('should reject a record with non-string keys', () => {
+        it('should treat numeric keys as strings (JS limitation)', () => {
             const schema = new index_1.default({
                 data: index_1.default.stringRecord(),
             });
@@ -247,14 +227,10 @@ describe('Schema Record Types', () => {
             const result = schema.validate(invalidData);
             expect(result).toBe(true);
         });
-        it('should create a schema from description with optional record type', () => {
-            const description = {
-                data: {
-                    type: 'stringRecord',
-                    optional: true
-                }
-            };
-            const schema = index_1.default.from(description);
+        it('should round-trip an optional record schema', () => {
+            const schema = index_1.default.from(new index_1.default({
+                data: index_1.default.stringRecord().optional()
+            }).describe());
             // Test with record present
             const validData1 = {
                 data: {
@@ -266,38 +242,47 @@ describe('Schema Record Types', () => {
             expect(schema.validate(validData1)).toBe(true);
             expect(schema.validate(validData2)).toBe(true);
         });
-        it('should describe a schema with string record type', () => {
+        it('should describe a string record as an object with string additionalProperties', () => {
             const schema = new index_1.default({
                 data: index_1.default.stringRecord(),
             });
             const description = schema.describe();
-            expect(description).toHaveProperty('data');
-            expect(description.data).toHaveProperty('type', 'stringRecord');
-            // The optional property is only included when it's true, not when it's false
+            expect(description.properties?.data).toMatchObject({
+                type: 'object',
+                additionalProperties: { type: 'string' }
+            });
         });
-        it('should describe a schema with number record type', () => {
+        it('should describe a number record as an object with number additionalProperties', () => {
             const schema = new index_1.default({
                 data: index_1.default.numberRecord(),
             });
             const description = schema.describe();
-            expect(description).toHaveProperty('data');
-            expect(description.data).toHaveProperty('type', 'numberRecord');
+            expect(description.properties?.data).toMatchObject({
+                type: 'object',
+                additionalProperties: { type: 'number' }
+            });
         });
-        it('should describe a schema with boolean record type', () => {
+        it('should describe a boolean record as an object with boolean additionalProperties', () => {
             const schema = new index_1.default({
                 data: index_1.default.booleanRecord(),
             });
             const description = schema.describe();
-            expect(description).toHaveProperty('data');
-            expect(description.data).toHaveProperty('type', 'booleanRecord');
+            expect(description.properties?.data).toMatchObject({
+                type: 'object',
+                additionalProperties: { type: 'boolean' }
+            });
         });
-        it('should describe a schema with mixed record type', () => {
+        it('should describe a mixed record as an object with anyOf additionalProperties', () => {
             const schema = new index_1.default({
                 data: index_1.default.mixedRecord(),
             });
             const description = schema.describe();
-            expect(description).toHaveProperty('data');
-            expect(description.data).toHaveProperty('type', 'mixedRecord');
+            expect(description.properties?.data).toMatchObject({
+                type: 'object',
+                additionalProperties: {
+                    anyOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }]
+                }
+            });
         });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forgehive/schema",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
     "ts-jest": "^29.1.2"
   },
   "dependencies": {
-    "zod": "^3.24.2"
+    "zod": "^4.4.3"
   },
   "scripts": {
     "build": "tsc",