@forgehive/schema 0.1.0

package/src/test/custom-validations.test.ts

@@ -0,0 +1,293 @@
+import { Schema } from '../index'
+
+describe('Schema Custom Number Validations', () => {
+  it('should validate number min/max constraints', () => {
+    const schema = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = Schema.from({
+      path: {
+        type: 'string',
+        validations: {
+          regex: '^/api/v[0-9]+/users/[0-9]+$'
+        }
+      }
+    })
+
+    const description = schema.describe()
+
+    const cloneSchema = 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 = 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 = 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/src/test/dates.test.ts

@@ -0,0 +1,85 @@
+import { Schema } from '../index'
+
+describe('Schema single date field', () => {
+  const schema = 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 = 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 Schema({
+      createdAt: Schema.date(),
+      timestamps: Schema.array(Schema.date())
+    })
+
+    const description = schema.describe()
+    expect(description).toEqual({
+      createdAt: { type: 'date' },
+      timestamps: { type: 'array', items: { type: 'date' } }
+    })
+  })
+})
+

package/src/test/index.test.ts

@@ -0,0 +1,205 @@
+import Schema, { type SchemaDescription } from '../index'
+
+describe('Schema basic types', () => {
+  it('should validate a string', () => {
+    const schema = new Schema({
+      name: Schema.string(),
+    })
+
+    const result = schema.validate({
+      name: 'World',
+    })
+
+    expect(result).toBe(true)
+  })
+
+  it('should validate a string and number', () => {
+    const schema = new Schema({
+      name: Schema.string(),
+      age: Schema.number(),
+    })
+
+    const result = schema.validate({
+      name: 'World',
+      age: 20,
+    })
+
+    expect(result).toEqual(true)
+  })
+})
+
+describe('Schema description', () => {
+  it('should describe a string', () => {
+    const schema = new Schema({
+      name: Schema.string(),
+    })
+
+    const result = schema.describe()
+    expect(result).toEqual({
+      name: { type: 'string' },
+    })
+  })
+
+  it('should describe a string and number', () => {
+    const schema = new Schema({
+      name: Schema.string(),
+      age: Schema.number(),
+    })
+
+    const result = schema.describe()
+    expect(result).toEqual({
+      name: { type: 'string' },
+      age: { type: 'number' },
+    })
+  })
+})
+
+describe('Schema hydrate', () => {
+  it('should describe a string', () => {
+    const description: SchemaDescription = {
+      name: { type: 'string' },
+      age: { type: 'number' },
+    }
+    const schema = Schema.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 Schema({
+      name: Schema.string(),
+    })
+
+    const result = schema.validate({
+      name: 123, // number instead of string
+    })
+
+    expect(result).toBe(false)
+  })
+
+  it('should reject invalid number type', () => {
+    const schema = new Schema({
+      age: Schema.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 Schema({
+      tags: Schema.array(Schema.string()),
+    })
+
+    const result = schema.validate({
+      tags: ['tag1', 'tag2', 'tag3'],
+    })
+
+    expect(result).toBe(true)
+  })
+
+  it('should validate array of numbers', () => {
+    const schema = new Schema({
+      scores: Schema.array(Schema.number()),
+    })
+
+    const result = schema.validate({
+      scores: [1, 2, 3, 4, 5],
+    })
+
+    expect(result).toBe(true)
+  })
+
+  it('should reject invalid array types', () => {
+    const schema = new Schema({
+      tags: Schema.array(Schema.string()),
+    })
+
+    const result = schema.validate({
+      tags: ['tag1', 123, 'tag3'], // mixed types
+    })
+
+    expect(result).toBe(false)
+  })
+
+  it('should validate empty arrays', () => {
+    const schema = new Schema({
+      tags: Schema.array(Schema.string()),
+    })
+
+    const result = schema.validate({
+      tags: [],
+    })
+
+    expect(result).toBe(true)
+  })
+
+  it('should describe array schema', () => {
+    const schema = new Schema({
+      tags: Schema.array(Schema.string()),
+      scores: Schema.array(Schema.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: SchemaDescription = {
+      tags: { type: 'array', items: { type: 'string' } },
+      scores: { type: 'array', items: { type: 'number' } },
+    }
+    const schema = Schema.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 Schema({
+      age: Schema.number().min(0).max(120),
+      email: Schema.string().email(),
+    })
+
+    const result = schema.validate({
+      age: 25,
+      email: 'test@example.com',
+    })
+
+    expect(result).toBe(true)
+  })
+})

package/src/test/optionals.test.ts

@@ -0,0 +1,73 @@
+import { Schema } from '../index'
+
+describe('Schema Custom Validations', () => {
+  describe('Optional Fields', () => {
+    it('should handle optional string fields', () => {
+      const schema = 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 = 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 = 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 = Schema.from({
+        name: { type: 'string', optional: true },
+        age: { type: 'number' },
+        tags: { type: 'array', items: { type: 'string' }, optional: true }
+      })
+
+      const description = originalSchema.describe()
+      const reconstructedSchema = 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)
+    })
+  })
+})