@forgehive/schema 0.1.4 → 0.2.0

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.4",
+  "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",