feat: unix timestamps and datetime

Author: glennmichael123

src/types.ts

@@ -3,11 +3,13 @@ import type { ArrayValidator } from './validators/arrays'
 import type { BooleanValidator } from './validators/booleans'
 import type { CustomValidator } from './validators/custom'
 import type { DateValidator } from './validators/dates'
+import type { DatetimeValidator } from './validators/datetimes'
 import type { EnumValidator } from './validators/enums'
 import type { NumberValidator } from './validators/numbers'
 import type { ObjectValidator } from './validators/objects'
 import type { StringValidator } from './validators/strings'
-import type { TimestampValidator } from './validators/timestamp'
+import type { TimestampValidator } from './validators/timestamps'
+import type { UnixValidator } from './validators/unix'
 
 export interface ValidationError {
   message: string
@@ -252,7 +254,9 @@ export interface ValidationInstance {
   boolean: () => BooleanValidator
   enum: <T extends string | number>(values: readonly T[]) => EnumValidator<T>
   date: () => DateValidator
+  datetime: () => DatetimeValidator
   object: <T extends Record<string, any>>() => ObjectValidator<T>
   custom: <T>(validationFn: (value: T) => boolean, message: string) => CustomValidator<T>
   timestamp: () => TimestampValidator
+  unix: () => UnixValidator
 }

src/validation.ts

@@ -3,11 +3,13 @@ import { array } from './validators/arrays'
 import { boolean } from './validators/booleans'
 import { custom } from './validators/custom'
 import { date } from './validators/dates'
+import { datetime } from './validators/datetimes'
 import { enum_ } from './validators/enums'
 import { number } from './validators/numbers'
 import { object } from './validators/objects'
 import { string } from './validators/strings'
-import { timestamp } from './validators/timestamp'
+import { timestamp } from './validators/timestamps'
+import { unix } from './validators/unix'
 
 export const v: ValidationInstance = {
   string,
@@ -16,7 +18,9 @@ export const v: ValidationInstance = {
   boolean,
   enum: enum_,
   date,
+  datetime,
   object,
   custom,
   timestamp,
+  unix,
 }

src/validators/dates.ts

@@ -9,28 +9,6 @@ export class DateValidator extends BaseValidator<Date> {
       message: 'Must be a valid date',
     })
   }
-
-  timestamp(): this {
-    return this.addRule({
-      name: 'timestamp',
-      test: (value: Date) => {
-        const timestamp = value.getTime()
-        return timestamp >= 0 && timestamp <= Number.MAX_SAFE_INTEGER
-      },
-      message: 'Must be a valid timestamp',
-    })
-  }
-
-  datetime(): this {
-    return this.addRule({
-      name: 'datetime',
-      test: (value: Date) => {
-        const timestamp = value.getTime()
-        return timestamp >= 0 && timestamp <= Number.MAX_SAFE_INTEGER
-      },
-      message: 'Must be a valid datetime',
-    })
-  }
 }
 
 export function date(): DateValidator {

src/validators/datetimes.ts

@@ -0,0 +1,29 @@
+import { BaseValidator } from './base'
+
+export class DatetimeValidator extends BaseValidator<Date> {
+  constructor() {
+    super()
+    this.addRule({
+      name: 'datetime',
+      test: (value: unknown): value is Date => {
+        if (!(value instanceof Date)) {
+          return false
+        }
+
+        // MySQL DATETIME range: 1000-01-01 to 9999-12-31
+        const year = value.getFullYear()
+        if (year < 1000 || year > 9999) {
+          return false
+        }
+
+        // Check if the date is valid
+        return !Number.isNaN(value.getTime())
+      },
+      message: 'Must be a valid datetime between 1000-01-01 and 9999-12-31',
+    })
+  }
+}
+
+export function datetime(): DatetimeValidator {
+  return new DatetimeValidator()
+}

src/validators/timestamp.ts

@@ -0,0 +1,42 @@
+import { BaseValidator } from './base'
+
+export class TimestampValidator extends BaseValidator<number | string> {
+  constructor() {
+    super()
+    this.addRule({
+      name: 'timestamp',
+      test: (value: number | string) => {
+        // Check if it's a valid number
+        const num = Number(value)
+        if (Number.isNaN(num)) {
+          return false
+        }
+
+        // MySQL TIMESTAMP range: 1970-01-01 to 2038-01-19
+        const minTimestamp = 0 // 1970-01-01 00:00:00 UTC
+        const maxTimestamp = 2147483647 // 2038-01-19 03:14:07 UTC
+
+        // First check if it's within the valid range
+        if (num < minTimestamp || num > maxTimestamp) {
+          return false
+        }
+
+        // For string inputs, check if the length is valid (10-13 digits)
+        if (typeof value === 'string') {
+          const timestampStr = value.toString()
+          const length = timestampStr.length
+          if (length < 10 || length > 13) {
+            return false
+          }
+        }
+
+        return true
+      },
+      message: 'Must be a valid timestamp between 1970-01-01 and 2038-01-19',
+    })
+  }
+}
+
+export function timestamp(): TimestampValidator {
+  return new TimestampValidator()
+}

src/validators/timestamps.ts

@@ -0,0 +1,34 @@
+import { BaseValidator } from './base'
+
+export class UnixValidator extends BaseValidator<number | string> {
+  constructor() {
+    super()
+    this.addRule({
+      name: 'unix',
+      test: (value: number | string) => {
+        // Check if it's a valid number
+        const num = Number(value)
+        if (Number.isNaN(num)) {
+          return false
+        }
+
+        // For string inputs, check if the length is valid (10-13 digits)
+        if (typeof value === 'string') {
+          const timestampStr = value.toString()
+          const length = timestampStr.length
+          if (length < 10 || length > 13) {
+            return false
+          }
+        }
+
+        // Unix timestamp must be a positive number
+        return num >= 0
+      },
+      message: 'Must be a valid Unix timestamp (10-13 digits)',
+    })
+  }
+}
+
+export function unix(): UnixValidator {
+  return new UnixValidator()
+}

src/validators/unix.ts

@@ -205,21 +205,24 @@ describe('Validation Library', () => {
       expect(validator.test('2023-01-01' as any)).toBe(false)
       expect(validator.test(123 as any)).toBe(false)
     })
+  })
 
-    test('timestamp validation', () => {
-      const validator = v.date().timestamp()
-      expect(validator.test(new Date(1683912345000))).toBe(true)
-      expect(validator.test(new Date(0))).toBe(true)
-      expect(validator.test(new Date(-1))).toBe(false)
-      expect(validator.test(new Date(Number.MAX_SAFE_INTEGER + 1))).toBe(false)
-    })
-
+  describe('Datetime Validator', () => {
     test('datetime validation', () => {
-      const validator = v.date().datetime()
-      expect(validator.test(new Date(1683912345000))).toBe(true)
-      expect(validator.test(new Date(0))).toBe(true)
-      expect(validator.test(new Date(-1))).toBe(false)
-      expect(validator.test(new Date(Number.MAX_SAFE_INTEGER + 1))).toBe(false)
+      const validator = v.datetime()
+      // Valid dates within MySQL DATETIME range
+      expect(validator.test(new Date('1000-01-01'))).toBe(true)
+      expect(validator.test(new Date('2023-01-01'))).toBe(true)
+      expect(validator.test(new Date('9999-12-31'))).toBe(true)
+
+      // Invalid dates outside MySQL DATETIME range
+      expect(validator.test(new Date('0999-12-31'))).toBe(false)
+      expect(validator.test(new Date('10000-01-01'))).toBe(false)
+
+      // Invalid inputs
+      expect(validator.test('2023-01-01' as any)).toBe(false)
+      expect(validator.test(123 as any)).toBe(false)
+      expect(validator.test(new Date('invalid'))).toBe(false)
     })
   })
 
@@ -422,29 +425,41 @@ describe('Validation Library', () => {
   })
 
   describe('Timestamp Validator', () => {
-    test('basic timestamp validation', () => {
+    test('timestamp validation', () => {
       const validator = v.timestamp()
-      expect(validator.test(1683912345)).toBe(true) // 10 digits
-      expect(validator.test('1683912345')).toBe(true) // 10 digits string
-      expect(validator.test(1683912345678)).toBe(true) // 13 digits
-      expect(validator.test('1683912345678')).toBe(true) // 13 digits string
-    })
+      // Valid timestamps within MySQL TIMESTAMP range
+      expect(validator.test(0)).toBe(true) // 1970-01-01 00:00:00 UTC
+      expect(validator.test(1683912345)).toBe(true)
+      expect(validator.test(2147483647)).toBe(true) // 2038-01-19 03:14:07 UTC
 
-    test('invalid timestamp validation', () => {
-      const validator = v.timestamp()
-      expect(validator.test(123456789)).toBe(false) // 9 digits (too short)
-      expect(validator.test('123456789')).toBe(false) // 9 digits string
-      expect(validator.test(12345678901234)).toBe(false) // 14 digits (too long)
-      expect(validator.test('abc')).toBe(false) // invalid string
-      expect(validator.test(-1683912345)).toBe(false) // negative number
+      // Invalid timestamps outside MySQL TIMESTAMP range
+      expect(validator.test(-1)).toBe(false)
+      expect(validator.test(2147483648)).toBe(false)
+
+      // Invalid inputs
+      expect(validator.test('abc')).toBe(false)
+      expect(validator.test('123456789')).toBe(false) // too short
+      expect(validator.test('12345678901234')).toBe(false) // too long
     })
+  })
 
-    test('timestamp validation error messages', () => {
-      const validator = v.timestamp()
-      const result = validator.validate('invalid')
-      expect(result.valid).toBe(false)
-      expect(result.errors).toHaveLength(1)
-      expect(result.errors[0].message).toBe('Must be a valid timestamp (10-13 digits)')
+  describe('Unix Validator', () => {
+    test('unix timestamp validation', () => {
+      const validator = v.unix()
+      // Valid Unix timestamps (seconds)
+      expect(validator.test(0)).toBe(true) // 1970-01-01 00:00:00 UTC
+      expect(validator.test(1683912345)).toBe(true)
+      expect(validator.test('1683912345')).toBe(true)
+
+      // Valid Unix timestamps (milliseconds)
+      expect(validator.test(1683912345000)).toBe(true)
+      expect(validator.test('1683912345000')).toBe(true)
+
+      // Invalid Unix timestamps
+      expect(validator.test(-1)).toBe(false) // negative
+      expect(validator.test('123456789')).toBe(false) // too short
+      expect(validator.test('12345678901234')).toBe(false) // too long
+      expect(validator.test('abc')).toBe(false) // invalid string
     })
   })
 })