chore(lib): Improve types (#21)

* chore(lib): improve types

* chore(lib): correct README

README.md

@@ -31,7 +31,7 @@ const exampleSchema = v.object({
     v.min(new Date('2021/01/01')),
     v.max(new Date()),
   ]),
-  tags: v.array(string())
+  tags: v.array(v.string())
 });
 
 // If the input data matches the schema, nothing will happen,

packages/validathor/src/core/validateModifiers.ts

@@ -1,5 +1,5 @@
 import type { Modifier } from '@/types'
 
 export const validateModifiers = <T>(value: T, modifiers?: Modifier<T>[]) => {
-  modifiers?.forEach((arg) => arg.validate(value))
+  modifiers?.forEach((modifier) => modifier.validate(value))
 }

packages/validathor/src/guards/index.ts

@@ -0,0 +1,21 @@
+import { Parser } from '@/types'
+
+export const isParser = <T>(input: unknown): input is T => {
+  return input !== null && typeof input === 'object' && 'parse' in input && 'name' in input
+}
+
+export const isParserRecords = <T extends Record<string, Parser<unknown>>>(
+  input: unknown,
+): input is T =>
+  input instanceof Object &&
+  !(input instanceof Array) &&
+  !(input instanceof Boolean) &&
+  !(input instanceof Date) &&
+  !(input instanceof Error) &&
+  !(input instanceof Function) &&
+  !(input instanceof Number) &&
+  !(input instanceof RegExp) &&
+  !(input instanceof String)
+// && Object.values(input).every((value) => isParser(value))
+// 'parse' in input &&
+// 'name' in input

packages/validathor/src/modifiers/email.ts

@@ -21,7 +21,7 @@ export const email = (
 ): Email => {
   return {
     name: 'email' as const,
-    validate: (value: string) => {
+    validate: (value) => {
       const emailRegex = new RegExp(/^[^\s@]+@[^\s@]+\.[^\s@]+$/)
       // Type checks
       assert(

packages/validathor/src/modifiers/enumerator.ts

@@ -20,7 +20,7 @@ export function enumerator<T extends string | number>(
 ): Enumerator<T> {
   return {
     name: 'enumerator' as const,
-    validate: (value: T) => {
+    validate: (value) => {
       // Type checks
       assert(
         input.includes(value),

packages/validathor/src/modifiers/index.ts

@@ -1,5 +1,5 @@
 export { custom, type Custom } from './custom'
-export { min, type Min } from './min'
-export { max, type Max } from './max'
 export { email, type Email } from './email'
 export { enumerator, type Enumerator } from './enumerator'
+export { max, type Max } from './max'
+export { min, type Min } from './min'

packages/validathor/src/modifiers/max.ts

@@ -21,7 +21,7 @@ export function max<T extends Input>(
 ): Max<T> {
   return {
     name: 'max' as const,
-    validate: (value: T) => {
+    validate: (value) => {
       assert(
         typeof value === 'number' ||
           typeof value === 'string' ||

packages/validathor/src/modifiers/min.ts

@@ -21,7 +21,7 @@ export function min<T extends Input>(
 ): Min<T> {
   return {
     name: 'min' as const,
-    validate: (value: T) => {
+    validate: (value) => {
       assert(
         typeof value === 'number' ||
           typeof value === 'string' ||

packages/validathor/src/schemas/__tests__/array.test.ts

@@ -1,6 +1,6 @@
 import { parse } from '@/core/parse'
 import { max, min } from '@/modifiers'
-import { boolean, string, number, object } from '@/schemas'
+import { boolean, string, number, object, date } from '@/schemas'
 
 import { array } from '../array'
 
@@ -47,14 +47,38 @@ describe('array()', () => {
     const schema1 = array(string())
     const schema2 = array(number())
     const schema3 = array(boolean())
+    const schema4 = array(date())
+    const schema5 = array(object({ name: string() }))
+    const schema6 = array(array([number()]))
 
     expect(parse(schema1, ['hello', 'world'])).toEqual(['hello', 'world'])
     expect(parse(schema2, [1, 2, 3])).toEqual([1, 2, 3])
     expect(parse(schema3, [true, false])).toEqual([true, false])
+    expect(
+      parse(schema4, [new Date('2018-03-06T09:00:00.000Z'), new Date('2024-11-16T17:07:39.128Z')]),
+    ).toEqual([new Date('2018-03-06T09:00:00.000Z'), new Date('2024-11-16T17:07:39.128Z')])
+    expect(parse(schema5, [{ name: 'Obi-Wan Kenobi' }, { name: 'Anakin Skywalker' }])).toEqual([
+      { name: 'Obi-Wan Kenobi' },
+      { name: 'Anakin Skywalker' },
+    ])
+    expect(
+      parse(schema6, [
+        [1, 2, 3],
+        [4, 5, 6],
+        [7, 8, 9],
+      ]),
+    ).toEqual([
+      [1, 2, 3],
+      [4, 5, 6],
+      [7, 8, 9],
+    ])
 
     expect(parse(schema1, [])).toEqual([])
     expect(parse(schema2, [])).toEqual([])
     expect(parse(schema3, [])).toEqual([])
+    expect(parse(schema4, [])).toEqual([])
+    expect(parse(schema5, [])).toEqual([])
+    expect(parse(schema6, [])).toEqual([])
   })
 
   it('should work with modifiers', () => {
@@ -101,10 +125,11 @@ describe('array()', () => {
   })
 })
 
-describe('[FUTURE]', () => {
-  it.fails('should work with mixed schemas', () => {
-    const schema = array<string | number>([string(), number()])
-
+describe('[FUTURE] mixed schemas', () => {
+  it.fails.each([
+    array<string | number>([string(), number()]),
+    array<number | string>([number(), string()]),
+  ])('should work with mixed schemas', (schema) => {
     expect(parse(schema, ['hello', 'world', 123])).toEqual(['hello', 'world', 123])
     expect(() => parse(schema, ['foo', true, 'baz'])).toThrowError(
       new TypeError('Value must be at most 2 x long'),

packages/validathor/src/schemas/array.ts

@@ -7,32 +7,72 @@ import { ERROR_CODES } from '@/utils/errors/errorCodes'
 /** An array of the accepted modifier types */
 export type ArraySchemaModifiers = (Min<number[]> | Max<number[]> | Custom<unknown>)[]
 
-export const array = <T>(
-  schema: MaybeArray<Parser<T>>,
+type AcceptedParserPrimitives =
+  | string
+  | number
+  | boolean
+  | Date
+  | object
+  | AcceptedParserPrimitives[]
+
+type ParserMap = {
+  string: Parser<string>
+  number: Parser<number>
+  boolean: Parser<boolean>
+  Date: Parser<Date>
+  object: Parser<object>
+  Array: Parser<AcceptedParserPrimitives[]>
+}
+
+type PrimitiveTypeMap = {
+  string: 'string'
+  number: 'number'
+  boolean: 'boolean'
+  Date: 'Date'
+  object: 'object'
+}
+
+// Ensure PrimitiveTypeName returns only valid keys of ParserMap
+type PrimitiveTypeName<T extends AcceptedParserPrimitives> = T extends keyof PrimitiveTypeMap
+  ? PrimitiveTypeMap[T]
+  : never
+
+// Now, define the GetParser type function that retrieves the correct parser based on T
+type GetParser<T extends AcceptedParserPrimitives> = T extends (infer U)[]
+  ? Parser<U[]>
+  : PrimitiveTypeName<T> extends keyof ParserMap
+  ? ParserMap[PrimitiveTypeName<T>] extends Parser<infer U>
+    ? Parser<U>
+    : never
+  : never
+
+type MixedParser<T extends AcceptedParserPrimitives> = GetParser<T>
+
+export const array = <T extends AcceptedParserPrimitives>(
+  schema: MaybeArray<MixedParser<T>>,
   modifiers: ArraySchemaModifiers = [],
   message?: { type_error?: string },
 ): Parser<T[]> => {
   const _schema = Array.isArray(schema) ? schema : [schema]
 
-  assert(
-    Array.isArray(_schema),
-    new TypeError(message?.type_error || ERROR_CODES.ERR_VAL_8000.message()),
-  )
-
   return {
     name: 'array' as const,
-    parse: (value: unknown): T[] => {
+    parse: (value): T[] => {
       assert(
         Array.isArray(value),
         new TypeError(message?.type_error || ERROR_CODES.ERR_VAL_8000.message()),
       )
 
       validateModifiers(value, modifiers)
 
-      return value.reduce((result: T[], item: unknown) => {
-        _schema.forEach((s) => result.push(s.parse(item)))
-        return result
+      // Use reduce to ensure the type is correctly inferred
+      const result: T[] = value.reduce((acc: unknown[], item: AcceptedParserPrimitives, index) => {
+        const parser = _schema[index % _schema.length] // Handle cyclic schema application
+        acc.push(parser.parse(item))
+        return acc
       }, [])
+
+      return result
     },
   }
 }

packages/validathor/src/schemas/object.ts

@@ -1,18 +1,8 @@
+import { isParserRecords } from '@/guards'
 import type { InferSchemaType, Parser } from '@/types'
 import { assert, assertType, TypeError } from '@/utils'
 import { ERROR_CODES } from '@/utils/errors/errorCodes'
 
-const isRecord = <T>(input: unknown): input is T =>
-  input instanceof Object &&
-  !(input instanceof Array) &&
-  !(input instanceof Boolean) &&
-  !(input instanceof Date) &&
-  !(input instanceof Error) &&
-  !(input instanceof Function) &&
-  !(input instanceof Number) &&
-  !(input instanceof RegExp) &&
-  !(input instanceof String)
-
 export const object = <T extends Record<string, Parser<unknown>>>(
   schema: T,
   message?: {
@@ -27,7 +17,7 @@ export const object = <T extends Record<string, Parser<unknown>>>(
     )
     assertType<Record<string, unknown>>(
       value,
-      isRecord<T>,
+      isParserRecords<T>,
       new TypeError(message?.type_error || ERROR_CODES.ERR_TYP_5000.message()),
     )
 

packages/validathor/src/schemas/tuple.ts

@@ -1,11 +1,8 @@
+import { isParser } from '@/guards'
 import type { Parser } from '@/types'
 import { assert, assertType, TypeError } from '@/utils'
 import { ERROR_CODES } from '@/utils/errors/errorCodes'
 
-const isParser = <T>(input: unknown): input is T => {
-  return input !== null && typeof input === 'object' && 'parse' in input
-}
-
 export const tuple = <T extends Parser<unknown>[]>(
   schema: T,
   message?: {