@forgehive/schema 0.1.0

package/dist/test/custom-validations.test.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('Schema Custom Number Validations', () => {
+    it('should validate number min/max constraints', () => {
+        const schema = index_1.Schema.from({
+            age: {
+                type: 'number',
+                validations: {
+                    min: 18,
+                    max: 100
+                }
+            },
+            score: {
+                type: 'number',
+                validations: {
+                    min: 0,
+                    max: 100
+                }
+            }
+        });
+        // Valid cases
+        expect(schema.validate({ age: 25, score: 85 })).toBe(true);
+        expect(schema.validate({ age: 18, score: 0 })).toBe(true);
+        expect(schema.validate({ age: 100, score: 100 })).toBe(true);
+        // Invalid cases
+        expect(schema.validate({ age: 17, score: 85 })).toBe(false);
+        expect(schema.validate({ age: 25, score: -1 })).toBe(false);
+        expect(schema.validate({ age: 101, score: 85 })).toBe(false);
+        expect(schema.validate({ age: 25, score: 101 })).toBe(false);
+    });
+    it('should correctly describe number validations', () => {
+        const schema = index_1.Schema.from({
+            age: {
+                type: 'number',
+                validations: {
+                    min: 18,
+                    max: 100
+                }
+            }
+        });
+        const description = schema.describe();
+        expect(description.age).toEqual({
+            type: 'number',
+            validations: {
+                min: 18,
+                max: 100
+            }
+        });
+    });
+});
+describe('Schema Custom String Validations', () => {
+    it('should validate string email format', () => {
+        const schema = index_1.Schema.from({
+            email: {
+                type: 'string',
+                validations: {
+                    email: true
+                }
+            }
+        });
+        // Valid cases
+        expect(schema.validate({ email: 'user@example.com' })).toBe(true);
+        expect(schema.validate({ email: 'test.name@domain.co.uk' })).toBe(true);
+        expect(schema.validate({ email: 'user+tag@example.com' })).toBe(true);
+        // Invalid cases
+        expect(schema.validate({ email: 'not-an-email' })).toBe(false);
+        expect(schema.validate({ email: 'missing@domain' })).toBe(false);
+        expect(schema.validate({ email: '@domain.com' })).toBe(false);
+    });
+    it('should validate string length constraints', () => {
+        const schema = index_1.Schema.from({
+            username: {
+                type: 'string',
+                validations: {
+                    minLength: 3,
+                    maxLength: 20
+                }
+            }
+        });
+        // Valid cases
+        expect(schema.validate({ username: 'abc' })).toBe(true);
+        expect(schema.validate({ username: 'valid_username' })).toBe(true);
+        expect(schema.validate({ username: 'a'.repeat(20) })).toBe(true);
+        // Invalid cases
+        expect(schema.validate({ username: 'ab' })).toBe(false);
+        expect(schema.validate({ username: 'a'.repeat(21) })).toBe(false);
+    });
+    it('should validate string regex pattern', () => {
+        const schema = index_1.Schema.from({
+            username: {
+                type: 'string',
+                validations: {
+                    regex: '^[a-zA-Z0-9_]+$'
+                }
+            }
+        });
+        // Valid cases
+        expect(schema.validate({ username: 'john_doe123' })).toBe(true);
+        expect(schema.validate({ username: 'User123' })).toBe(true);
+        expect(schema.validate({ username: '123456' })).toBe(true);
+        // Invalid cases
+        expect(schema.validate({ username: 'john-doe' })).toBe(false);
+        expect(schema.validate({ username: 'user@123' })).toBe(false);
+        expect(schema.validate({ username: 'user name' })).toBe(false);
+    });
+    it('should correctly describe string validations', () => {
+        const schema = index_1.Schema.from({
+            email: {
+                type: 'string',
+                validations: {
+                    email: true,
+                    minLength: 5,
+                    maxLength: 100
+                }
+            }
+        });
+        const description = schema.describe();
+        expect(description.email).toEqual({
+            type: 'string',
+            validations: {
+                email: true,
+                minLength: 5,
+                maxLength: 100
+            }
+        });
+    });
+    it('should correctly describe string regex validation', () => {
+        const schema = index_1.Schema.from({
+            username: {
+                type: 'string',
+                validations: {
+                    regex: '^[a-zA-Z0-9_]+$'
+                }
+            }
+        });
+        const description = schema.describe();
+        expect(description.username).toEqual({
+            type: 'string',
+            validations: {
+                regex: '^[a-zA-Z0-9_]+$'
+            }
+        });
+    });
+    it('should handle regex with other string validations', () => {
+        const schema = index_1.Schema.from({
+            username: {
+                type: 'string',
+                validations: {
+                    regex: '^[a-zA-Z0-9_]+$',
+                    minLength: 3,
+                    maxLength: 20
+                }
+            }
+        });
+        // Valid cases
+        expect(schema.validate({ username: 'john_doe123' })).toBe(true);
+        expect(schema.validate({ username: 'User123' })).toBe(true);
+        // Invalid cases - regex
+        expect(schema.validate({ username: 'john-doe' })).toBe(false);
+        expect(schema.validate({ username: 'user@123' })).toBe(false);
+        // Invalid cases - length
+        expect(schema.validate({ username: 'ab' })).toBe(false);
+        expect(schema.validate({ username: 'a'.repeat(21) })).toBe(false);
+    });
+    it('should handle regex patterns containing forward slashes', () => {
+        const schema = index_1.Schema.from({
+            path: {
+                type: 'string',
+                validations: {
+                    regex: '^/api/v[0-9]+/users/[0-9]+$'
+                }
+            }
+        });
+        // Valid cases
+        expect(schema.validate({ path: '/api/v1/users/123' })).toBe(true);
+        expect(schema.validate({ path: '/api/v2/users/456' })).toBe(true);
+        expect(schema.validate({ path: '/api/v10/users/789' })).toBe(true);
+        // Invalid cases
+        expect(schema.validate({ path: 'api/v1/users/123' })).toBe(false);
+        expect(schema.validate({ path: '/api/v1/users' })).toBe(false);
+        expect(schema.validate({ path: '/api/v1/users/abc' })).toBe(false);
+        // Verify the description preserves the slashes within the pattern
+        const description = schema.describe();
+        expect(description.path).toEqual({
+            type: 'string',
+            validations: {
+                regex: '^/api/v[0-9]+/users/[0-9]+$'
+            }
+        });
+    });
+    it('should handle round trip of regex patterns containing forward slashes', () => {
+        const schema = index_1.Schema.from({
+            path: {
+                type: 'string',
+                validations: {
+                    regex: '^/api/v[0-9]+/users/[0-9]+$'
+                }
+            }
+        });
+        const description = schema.describe();
+        const cloneSchema = index_1.Schema.from(description);
+        // Valid cases
+        expect(cloneSchema.validate({ path: '/api/v1/users/123' })).toBe(true);
+        expect(cloneSchema.validate({ path: '/api/v2/users/456' })).toBe(true);
+        expect(cloneSchema.validate({ path: '/api/v10/users/789' })).toBe(true);
+        // Invalid cases
+        expect(cloneSchema.validate({ path: 'api/v1/users/123' })).toBe(false);
+        expect(cloneSchema.validate({ path: '/api/v1/users' })).toBe(false);
+        expect(cloneSchema.validate({ path: '/api/v1/users/abc' })).toBe(false);
+        // Verify the description preserves the slashes within the pattern
+        const cloneDescription = cloneSchema.describe();
+        expect(cloneDescription).toMatchObject(description);
+    });
+});
+describe('Schema Roundtrip', () => {
+    it('should maintain custom validations through describe/from cycle', () => {
+        const originalSchema = index_1.Schema.from({
+            age: {
+                type: 'number',
+                validations: {
+                    min: 18,
+                    max: 100
+                }
+            },
+            email: {
+                type: 'string',
+                validations: {
+                    email: true
+                }
+            },
+            username: {
+                type: 'string',
+                validations: {
+                    regex: '^[a-zA-Z0-9_]+$',
+                    minLength: 3,
+                    maxLength: 20
+                }
+            }
+        });
+        const description = originalSchema.describe();
+        const reconstructedSchema = index_1.Schema.from(description);
+        // Both schemas should validate the same data
+        const validData = {
+            age: 25,
+            email: 'user@example.com',
+            username: 'john_doe123'
+        };
+        const invalidData = {
+            age: 17,
+            email: 'not-an-email',
+            username: 'john-doe'
+        };
+        expect(originalSchema.validate(validData)).toBe(true);
+        expect(reconstructedSchema.validate(validData)).toBe(true);
+        expect(originalSchema.validate(invalidData)).toBe(false);
+        expect(reconstructedSchema.validate(invalidData)).toBe(false);
+    });
+});

package/dist/test/dates.test.d.ts

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

package/dist/test/dates.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('Schema single date field', () => {
+    const schema = index_1.Schema.from({
+        createdAt: { type: 'date' }
+    });
+    it('should validate a valid date', () => {
+        const data = {
+            createdAt: new Date()
+        };
+        expect(schema.validate(data)).toBe(true);
+    });
+    it('should validate a valid date string', () => {
+        const data = {
+            createdAt: new Date('2024-03-20T12:00:00Z')
+        };
+        expect(schema.validate(data)).toBe(true);
+    });
+    it('should reject invalid date', () => {
+        const data = {
+            createdAt: 'invalid-date'
+        };
+        expect(schema.validate(data)).toBe(false);
+    });
+    it('should reject non-date value', () => {
+        const data = {
+            createdAt: 123
+        };
+        expect(schema.validate(data)).toBe(false);
+    });
+});
+describe('Schema array of dates', () => {
+    const schema = index_1.Schema.from({
+        timestamps: { type: 'array', items: { type: 'date' } }
+    });
+    it('should validate an array of valid dates', () => {
+        const data = {
+            timestamps: [new Date(), new Date()]
+        };
+        expect(schema.validate(data)).toBe(true);
+    });
+    it('should validate an array of valid date strings', () => {
+        const data = {
+            timestamps: [new Date('2024-03-20T12:00:00Z'), new Date('2024-03-21T12:00:00Z')]
+        };
+        expect(schema.validate(data)).toBe(true);
+    });
+    it('should reject array with invalid date', () => {
+        const data = {
+            timestamps: [new Date(), 'invalid-date']
+        };
+        expect(schema.validate(data)).toBe(false);
+    });
+    it('should reject non-array value', () => {
+        const data = {
+            timestamps: 'not-an-array'
+        };
+        expect(schema.validate(data)).toBe(false);
+    });
+});
+describe('Dates Schema description', () => {
+    it('should correctly describe date fields', () => {
+        const schema = new index_1.Schema({
+            createdAt: index_1.Schema.date(),
+            timestamps: index_1.Schema.array(index_1.Schema.date())
+        });
+        const description = schema.describe();
+        expect(description).toEqual({
+            createdAt: { type: 'date' },
+            timestamps: { type: 'array', items: { type: 'date' } }
+        });
+    });
+});

package/dist/test/index.test.d.ts

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

package/dist/test/index.test.js

@@ -0,0 +1,170 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = __importDefault(require("../index"));
+describe('Schema basic types', () => {
+    it('should validate a string', () => {
+        const schema = new index_1.default({
+            name: index_1.default.string(),
+        });
+        const result = schema.validate({
+            name: 'World',
+        });
+        expect(result).toBe(true);
+    });
+    it('should validate a string and number', () => {
+        const schema = new index_1.default({
+            name: index_1.default.string(),
+            age: index_1.default.number(),
+        });
+        const result = schema.validate({
+            name: 'World',
+            age: 20,
+        });
+        expect(result).toEqual(true);
+    });
+});
+describe('Schema description', () => {
+    it('should describe a string', () => {
+        const schema = new index_1.default({
+            name: index_1.default.string(),
+        });
+        const result = schema.describe();
+        expect(result).toEqual({
+            name: { type: 'string' },
+        });
+    });
+    it('should describe a string and number', () => {
+        const schema = new index_1.default({
+            name: index_1.default.string(),
+            age: index_1.default.number(),
+        });
+        const result = schema.describe();
+        expect(result).toEqual({
+            name: { type: 'string' },
+            age: { type: 'number' },
+        });
+    });
+});
+describe('Schema hydrate', () => {
+    it('should describe a string', () => {
+        const description = {
+            name: { type: 'string' },
+            age: { type: 'number' },
+        };
+        const schema = index_1.default.from(description);
+        const result = schema.describe();
+        expect(result).toEqual({
+            name: { type: 'string' },
+            age: { type: 'number' },
+        });
+    });
+});
+describe('Schema validation errors', () => {
+    it('should reject invalid string type', () => {
+        const schema = new index_1.default({
+            name: index_1.default.string(),
+        });
+        const result = schema.validate({
+            name: 123, // number instead of string
+        });
+        expect(result).toBe(false);
+    });
+    it('should reject invalid number type', () => {
+        const schema = new index_1.default({
+            age: index_1.default.number(),
+        });
+        const result = schema.validate({
+            age: 'not a number',
+        });
+        expect(result).toBe(false);
+    });
+});
+// describe('Schema optional fields', () => {
+//   it('should validate with missing optional field', () => {
+//     const schema = new Schema({
+//       name: Schema.string(),
+//       age: Schema.number().optional(),
+//     })
+//     const result = schema.validate({
+//       name: 'World',
+//     })
+//     expect(result).toBe(true)
+//   })
+// })
+describe('Schema arrays', () => {
+    it('should validate array of strings', () => {
+        const schema = new index_1.default({
+            tags: index_1.default.array(index_1.default.string()),
+        });
+        const result = schema.validate({
+            tags: ['tag1', 'tag2', 'tag3'],
+        });
+        expect(result).toBe(true);
+    });
+    it('should validate array of numbers', () => {
+        const schema = new index_1.default({
+            scores: index_1.default.array(index_1.default.number()),
+        });
+        const result = schema.validate({
+            scores: [1, 2, 3, 4, 5],
+        });
+        expect(result).toBe(true);
+    });
+    it('should reject invalid array types', () => {
+        const schema = new index_1.default({
+            tags: index_1.default.array(index_1.default.string()),
+        });
+        const result = schema.validate({
+            tags: ['tag1', 123, 'tag3'], // mixed types
+        });
+        expect(result).toBe(false);
+    });
+    it('should validate empty arrays', () => {
+        const schema = new index_1.default({
+            tags: index_1.default.array(index_1.default.string()),
+        });
+        const result = schema.validate({
+            tags: [],
+        });
+        expect(result).toBe(true);
+    });
+    it('should describe array schema', () => {
+        const schema = new index_1.default({
+            tags: index_1.default.array(index_1.default.string()),
+            scores: index_1.default.array(index_1.default.number()),
+        });
+        const result = schema.describe();
+        expect(result).toEqual({
+            tags: { type: 'array', items: { type: 'string' } },
+            scores: { type: 'array', items: { type: 'number' } },
+        });
+    });
+    it('should hydrate array schema from description', () => {
+        const description = {
+            tags: { type: 'array', items: { type: 'string' } },
+            scores: { type: 'array', items: { type: 'number' } },
+        };
+        const schema = index_1.default.from(description);
+        const result = schema.describe();
+        expect(result).toEqual({
+            tags: { type: 'array', items: { type: 'string' } },
+            scores: { type: 'array', items: { type: 'number' } },
+        });
+    });
+});
+describe('Schema custom validation', () => {
+    it('should validate with custom rules', () => {
+        const schema = new index_1.default({
+            age: index_1.default.number().min(0).max(120),
+            email: index_1.default.string().email(),
+        });
+        const result = schema.validate({
+            age: 25,
+            email: 'test@example.com',
+        });
+        expect(result).toBe(true);
+    });
+});

package/dist/test/optionals.test.d.ts

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

package/dist/test/optionals.test.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+describe('Schema Custom Validations', () => {
+    describe('Optional Fields', () => {
+        it('should handle optional string fields', () => {
+            const schema = index_1.Schema.from({
+                name: { type: 'string', optional: true },
+                age: { type: 'number' }
+            });
+            // Valid with optional field present
+            expect(schema.validate({ name: 'John', age: 30 })).toBe(true);
+            // Valid with optional field missing
+            expect(schema.validate({ age: 30 })).toBe(true);
+            // Invalid - missing required field
+            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' } }
+            });
+            // Valid with optional array present
+            expect(schema.validate({ tags: ['tag1', 'tag2'], scores: [1, 2, 3] })).toBe(true);
+            // Valid with optional array missing
+            expect(schema.validate({ scores: [1, 2, 3] })).toBe(true);
+            // Invalid - missing required array
+            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 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 });
+        });
+    });
+    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 description = originalSchema.describe();
+            const reconstructedSchema = index_1.Schema.from(description);
+            // Both schemas should validate the same data
+            const validData = { name: 'John', age: 30, tags: ['tag1'] };
+            const dataWithoutOptional = { age: 30 };
+            expect(originalSchema.validate(validData)).toBe(true);
+            expect(reconstructedSchema.validate(validData)).toBe(true);
+            expect(originalSchema.validate(dataWithoutOptional)).toBe(true);
+            expect(reconstructedSchema.validate(dataWithoutOptional)).toBe(true);
+        });
+    });
+});

package/dist/test/record.test.d.ts

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