@forgehive/schema 0.1.3 → 0.2.0

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

@@ -2,21 +2,9 @@ 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
-        }
-      }
+    const schema = new Schema({
+      age: Schema.number().min(18).max(100),
+      score: Schema.number().min(0).max(100)
     })
 
     // Valid cases
@@ -31,37 +19,24 @@ describe('Schema Custom Number Validations', () => {
     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
-        }
-      }
+  it('should describe number validations as JSON Schema', () => {
+    const schema = new Schema({
+      age: Schema.number().min(18).max(100)
     })
 
     const description = schema.describe()
-    expect(description.age).toEqual({
+    expect(description.properties?.age).toEqual({
       type: 'number',
-      validations: {
-        min: 18,
-        max: 100
-      }
+      minimum: 18,
+      maximum: 100
     })
   })
 })
 
 describe('Schema Custom String Validations', () => {
   it('should validate string email format', () => {
-    const schema = Schema.from({
-      email: {
-        type: 'string',
-        validations: {
-          email: true
-        }
-      }
+    const schema = new Schema({
+      email: Schema.email()
     })
 
     // Valid cases
@@ -76,14 +51,8 @@ describe('Schema Custom String Validations', () => {
   })
 
   it('should validate string length constraints', () => {
-    const schema = Schema.from({
-      username: {
-        type: 'string',
-        validations: {
-          minLength: 3,
-          maxLength: 20
-        }
-      }
+    const schema = new Schema({
+      username: Schema.string().min(3).max(20)
     })
 
     // Valid cases
@@ -97,13 +66,8 @@ describe('Schema Custom String Validations', () => {
   })
 
   it('should validate string regex pattern', () => {
-    const schema = Schema.from({
-      username: {
-        type: 'string',
-        validations: {
-          regex: '^[a-zA-Z0-9_]+$'
-        }
-      }
+    const schema = new Schema({
+      username: Schema.string().regex(/^[a-zA-Z0-9_]+$/)
     })
 
     // Valid cases
@@ -117,58 +81,35 @@ describe('Schema Custom String Validations', () => {
     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
-        }
-      }
+  it('should describe string length validations as JSON Schema', () => {
+    const schema = new Schema({
+      email: Schema.email().min(5).max(100)
     })
 
     const description = schema.describe()
-    expect(description.email).toEqual({
+    expect(description.properties?.email).toMatchObject({
       type: 'string',
-      validations: {
-        email: true,
-        minLength: 5,
-        maxLength: 100
-      }
+      format: 'email',
+      minLength: 5,
+      maxLength: 100
     })
   })
 
-  it('should correctly describe string regex validation', () => {
-    const schema = Schema.from({
-      username: {
-        type: 'string',
-        validations: {
-          regex: '^[a-zA-Z0-9_]+$'
-        }
-      }
+  it('should describe string regex validation as a pattern', () => {
+    const schema = new Schema({
+      username: Schema.string().regex(/^[a-zA-Z0-9_]+$/)
     })
 
     const description = schema.describe()
-    expect(description.username).toEqual({
+    expect(description.properties?.username).toMatchObject({
       type: 'string',
-      validations: {
-        regex: '^[a-zA-Z0-9_]+$'
-      }
+      pattern: '^[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
-        }
-      }
+    const schema = new Schema({
+      username: Schema.string().regex(/^[a-zA-Z0-9_]+$/).min(3).max(20)
     })
 
     // Valid cases
@@ -185,13 +126,8 @@ describe('Schema Custom String Validations', () => {
   })
 
   it('should handle regex patterns containing forward slashes', () => {
-    const schema = Schema.from({
-      path: {
-        type: 'string',
-        validations: {
-          regex: '^/api/v[0-9]+/users/[0-9]+$'
-        }
-      }
+    const schema = new Schema({
+      path: Schema.string().regex(/^\/api\/v[0-9]+\/users\/[0-9]+$/)
     })
 
     // Valid cases
@@ -204,28 +140,20 @@ describe('Schema Custom String Validations', () => {
     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
+    // Verify the description preserves the pattern (regex source keeps escaped slashes)
     const description = schema.describe()
-    expect(description.path).toEqual({
+    expect(description.properties?.path).toMatchObject({
       type: 'string',
-      validations: {
-        regex: '^/api/v[0-9]+/users/[0-9]+$'
-      }
+      pattern: '^\\/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 schema = new Schema({
+      path: Schema.string().regex(/^\/api\/v[0-9]+\/users\/[0-9]+$/)
     })
 
     const description = schema.describe()
-
     const cloneSchema = Schema.from(description)
 
     // Valid cases
@@ -238,36 +166,21 @@ describe('Schema Custom String Validations', () => {
     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
+    // Verify the description preserves the pattern (regex source keeps escaped slashes)
     const cloneDescription = cloneSchema.describe()
-    expect(cloneDescription).toMatchObject(description)
+    expect(cloneDescription.properties?.path).toMatchObject({
+      type: 'string',
+      pattern: '^\\/api\\/v[0-9]+\\/users\\/[0-9]+$'
+    })
   })
 })
 
 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 originalSchema = new Schema({
+      age: Schema.number().min(18).max(100),
+      email: Schema.email(),
+      username: Schema.string().regex(/^[a-zA-Z0-9_]+$/).min(3).max(20)
     })
 
     const description = originalSchema.describe()

package/src/test/dates.test.ts

@@ -1,32 +1,42 @@
 import { Schema } from '../index'
 
+// Dates are represented as ISO 8601 date-time strings (Schema.date() ->
+// z.iso.datetime()), which are natively representable in JSON Schema.
+
 describe('Schema single date field', () => {
-  const schema = Schema.from({
-    createdAt: { type: 'date' }
+  const schema = new Schema({
+    createdAt: Schema.date()
   })
 
-  it('should validate a valid date', () => {
+  it('should validate a valid ISO date-time string', () => {
     const data = {
-      createdAt: new Date()
+      createdAt: new Date().toISOString()
     }
     expect(schema.validate(data)).toBe(true)
   })
 
-  it('should validate a valid date string', () => {
+  it('should validate a fixed ISO date-time string', () => {
     const data = {
-      createdAt: new Date('2024-03-20T12:00:00Z')
+      createdAt: '2024-03-20T12:00:00Z'
     }
     expect(schema.validate(data)).toBe(true)
   })
 
-  it('should reject invalid date', () => {
+  it('should reject an invalid date string', () => {
     const data = {
       createdAt: 'invalid-date'
     }
     expect(schema.validate(data)).toBe(false)
   })
 
-  it('should reject non-date value', () => {
+  it('should reject a Date instance (runtime type is a string now)', () => {
+    const data = {
+      createdAt: new Date()
+    }
+    expect(schema.validate(data)).toBe(false)
+  })
+
+  it('should reject a non-date value', () => {
     const data = {
       createdAt: 123
     }
@@ -35,32 +45,32 @@ describe('Schema single date field', () => {
 })
 
 describe('Schema array of dates', () => {
-  const schema = Schema.from({
-    timestamps: { type: 'array', items: { type: 'date' } }
+  const schema = new Schema({
+    timestamps: Schema.array(Schema.date())
   })
 
-  it('should validate an array of valid dates', () => {
+  it('should validate an array of valid ISO date-time strings', () => {
     const data = {
-      timestamps: [new Date(), new Date()]
+      timestamps: [new Date().toISOString(), new Date().toISOString()]
     }
     expect(schema.validate(data)).toBe(true)
   })
 
-  it('should validate an array of valid date strings', () => {
+  it('should validate an array of fixed ISO date-time strings', () => {
     const data = {
-      timestamps: [new Date('2024-03-20T12:00:00Z'), new Date('2024-03-21T12:00:00Z')]
+      timestamps: ['2024-03-20T12:00:00Z', '2024-03-21T12:00:00Z']
     }
     expect(schema.validate(data)).toBe(true)
   })
 
-  it('should reject array with invalid date', () => {
+  it('should reject an array with an invalid date string', () => {
     const data = {
-      timestamps: [new Date(), 'invalid-date']
+      timestamps: [new Date().toISOString(), 'invalid-date']
     }
     expect(schema.validate(data)).toBe(false)
   })
 
-  it('should reject non-array value', () => {
+  it('should reject a non-array value', () => {
     const data = {
       timestamps: 'not-an-array'
     }
@@ -69,17 +79,30 @@ describe('Schema array of dates', () => {
 })
 
 describe('Dates Schema description', () => {
-  it('should correctly describe date fields', () => {
+  it('should describe date fields as date-time formatted strings', () => {
     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' } }
+    expect(description.properties?.createdAt).toMatchObject({
+      type: 'string',
+      format: 'date-time'
+    })
+    expect(description.properties?.timestamps).toMatchObject({
+      type: 'array',
+      items: { type: 'string', format: 'date-time' }
     })
   })
-})
 
+  it('should round-trip date validation through describe/from', () => {
+    const schema = new Schema({
+      createdAt: Schema.date()
+    })
+
+    const clone = Schema.from(schema.describe())
+    expect(clone.validate({ createdAt: '2024-03-20T12:00:00Z' })).toBe(true)
+    expect(clone.validate({ createdAt: 'invalid-date' })).toBe(false)
+  })
+})

package/src/test/describe.test.ts

@@ -0,0 +1,190 @@
+import { Schema } from '../index'
+
+// `describe()` serializes a Schema to standard JSON Schema (draft 2020-12).
+// Each test builds a Schema with the Schema.* helpers and asserts the EXACT
+// JSON Schema it produces, so the wire format is obvious at a glance.
+
+const $schema = 'https://json-schema.org/draft/2020-12/schema'
+
+describe('Schema.describe() -> JSON Schema', () => {
+  it('basic types', () => {
+    const schema = new Schema({
+      name: Schema.string(),
+      age: Schema.number(),
+      active: Schema.boolean(),
+    })
+
+    expect(schema.describe()).toEqual({
+      $schema,
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        age: { type: 'number' },
+        active: { type: 'boolean' },
+      },
+      required: ['name', 'age', 'active'],
+      additionalProperties: false,
+    })
+  })
+
+  it('string validations', () => {
+    const schema = new Schema({
+      username: Schema.string().min(3).max(20).regex(/^[a-zA-Z0-9_]+$/),
+    })
+
+    expect(schema.describe()).toEqual({
+      $schema,
+      type: 'object',
+      properties: {
+        username: {
+          type: 'string',
+          minLength: 3,
+          maxLength: 20,
+          pattern: '^[a-zA-Z0-9_]+$',
+        },
+      },
+      required: ['username'],
+      additionalProperties: false,
+    })
+  })
+
+  it('number validations', () => {
+    const schema = new Schema({
+      age: Schema.number().min(18).max(100),
+    })
+
+    expect(schema.describe()).toEqual({
+      $schema,
+      type: 'object',
+      properties: {
+        age: { type: 'number', minimum: 18, maximum: 100 },
+      },
+      required: ['age'],
+      additionalProperties: false,
+    })
+  })
+
+  it('optional fields are omitted from `required`', () => {
+    const schema = new Schema({
+      name: Schema.string(),
+      age: Schema.number().optional(),
+    })
+
+    expect(schema.describe()).toEqual({
+      $schema,
+      type: 'object',
+      properties: {
+        name: { type: 'string' },
+        age: { type: 'number' },
+      },
+      required: ['name'], // age is optional, so it is not required
+      additionalProperties: false,
+    })
+  })
+
+  it('arrays', () => {
+    const schema = new Schema({
+      tags: Schema.array(Schema.string()),
+      scores: Schema.array(Schema.number()),
+    })
+
+    expect(schema.describe()).toEqual({
+      $schema,
+      type: 'object',
+      properties: {
+        tags: { type: 'array', items: { type: 'string' } },
+        scores: { type: 'array', items: { type: 'number' } },
+      },
+      required: ['tags', 'scores'],
+      additionalProperties: false,
+    })
+  })
+
+  it('records', () => {
+    const schema = new Schema({
+      strings: Schema.stringRecord(),
+      mixed: Schema.mixedRecord(),
+    })
+
+    expect(schema.describe()).toEqual({
+      $schema,
+      type: 'object',
+      properties: {
+        strings: {
+          type: 'object',
+          propertyNames: { type: 'string' },
+          additionalProperties: { type: 'string' },
+        },
+        mixed: {
+          type: 'object',
+          propertyNames: { type: 'string' },
+          additionalProperties: {
+            anyOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+          },
+        },
+      },
+      required: ['strings', 'mixed'],
+      additionalProperties: false,
+    })
+  })
+
+  it('nested objects', () => {
+    const schema = new Schema({
+      user: Schema.object({
+        name: Schema.string(),
+        age: Schema.number().optional(),
+      }),
+    })
+
+    expect(schema.describe()).toEqual({
+      $schema,
+      type: 'object',
+      properties: {
+        user: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            age: { type: 'number' },
+          },
+          required: ['name'],
+          additionalProperties: false,
+        },
+      },
+      required: ['user'],
+      additionalProperties: false,
+    })
+  })
+
+  it('element descriptions', () => {
+    const schema = new Schema({
+      name: Schema.string().describe('The name of the user'),
+    })
+
+    expect(schema.describe()).toEqual({
+      $schema,
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'The name of the user' },
+      },
+      required: ['name'],
+      additionalProperties: false,
+    })
+  })
+
+  it('string formats: email, uuid, url, date', () => {
+    const schema = new Schema({
+      email: Schema.email(),
+      id: Schema.uuid(),
+      site: Schema.url(),
+      when: Schema.date(),
+    })
+
+    // Format keywords are the stable part; the generated `pattern` strings are
+    // long and version-specific, so we assert the meaningful keys.
+    const properties = schema.describe().properties
+    expect(properties?.email).toMatchObject({ type: 'string', format: 'email' })
+    expect(properties?.id).toMatchObject({ type: 'string', format: 'uuid' })
+    expect(properties?.site).toMatchObject({ type: 'string', format: 'uri' })
+    expect(properties?.when).toMatchObject({ type: 'string', format: 'date-time' })
+  })
+})