feat: add j.tuple

Author: mrnagydavid

packages/nodejs-lib/src/validation/ajv/ajv.validations.test.ts

@@ -2090,6 +2090,40 @@ describe('array', () => {
   })
 })
 
+describe('tuple', () => {
+  test('should work correctly with type inference', () => {
+    const schema = j.tuple([j.string().nullable(), j.number(), j.boolean()])
+
+    const [err, result] = AjvSchema.create(schema).getValidationResult(['foo', 1, true])
+
+    expect(err).toBeNull()
+    expect(result).toEqual(['foo', 1, true])
+    expectTypeOf(result).toExtend<[string | null, number, boolean]>()
+  })
+
+  test('should accept valid data', () => {
+    const schema = j.tuple([j.string().minLength(3).nullable(), j.number(), j.boolean()])
+    const ajvSchema = AjvSchema.create(schema)
+
+    const testCases: any[] = [
+      ['foo', 1, true],
+      [null, 2, false],
+    ]
+    testCases.forEach(input => {
+      const [err, result] = ajvSchema.getValidationResult(input)
+
+      expect(err, String(input)).toBeNull()
+      expect(result).toEqual(input)
+    })
+
+    const invalidCases: any[] = [[undefined, 1, true], ['fo', 1, true], 'foo', 0, true, {}, []]
+    invalidCases.forEach(input => {
+      const [err] = ajvSchema.getValidationResult(input)
+      expect(err, String(input)).not.toBeNull()
+    })
+  })
+})
+
 describe('set', () => {
   test('should work correctly with type inference', () => {
     const schema = j.set(j.string())

packages/nodejs-lib/src/validation/ajv/jsonSchemaBuilder.test.ts

@@ -613,6 +613,18 @@ describe('array', () => {
   })
 })
 
+describe('tuple', () => {
+  test('should correctly infer the type', () => {
+    const schema1 = j.tuple([j.string(), j.number(), j.boolean()])
+    expectTypeOf(schema1.in).toEqualTypeOf<[string, number, boolean]>()
+    expectTypeOf(schema1.out).toEqualTypeOf<[string, number, boolean]>()
+
+    const schema2 = j.tuple([j.string().optional(), j.number(), j.boolean()])
+    expectTypeOf(schema2.in).toEqualTypeOf<[string | undefined, number, boolean]>()
+    expectTypeOf(schema2.out).toEqualTypeOf<[string | undefined, number, boolean]>()
+  })
+})
+
 describe('enum', () => {
   test('should correctly infer the type - for NumberEnums', () => {
     enum Foo {

packages/nodejs-lib/src/validation/ajv/jsonSchemaBuilder.ts

@@ -126,6 +126,12 @@ export const j = {
     return new JsonSchemaArrayBuilder(itemSchema)
   },
 
+  tuple<const S extends JsonSchemaAnyBuilder<any, any, any>[]>(
+    items: S,
+  ): JsonSchemaTupleBuilder<S> {
+    return new JsonSchemaTupleBuilder<S>(items)
+  },
+
   set<IN, OUT, Opt>(
     itemSchema: JsonSchemaAnyBuilder<IN, OUT, Opt>,
   ): JsonSchemaSet2Builder<IN, OUT, Opt> {
@@ -1139,6 +1145,23 @@ export class JsonSchemaEnumBuilder<
   }
 }
 
+export class JsonSchemaTupleBuilder<
+  ITEMS extends JsonSchemaAnyBuilder<any, any, any>[],
+> extends JsonSchemaAnyBuilder<TupleIn<ITEMS>, TupleOut<ITEMS>, false> {
+  private readonly _items: ITEMS
+
+  constructor(items: ITEMS) {
+    super({
+      type: 'array',
+      prefixItems: items.map(i => i.build()),
+      minItems: items.length,
+      maxItems: items.length,
+    })
+
+    this._items = items
+  }
+}
+
 type EnumBaseType = 'string' | 'number' | 'other'
 
 export interface JsonSchema<IN = unknown, OUT = IN> {
@@ -1156,6 +1179,7 @@ export interface JsonSchema<IN = unknown, OUT = IN> {
 
   type?: string | string[]
   items?: JsonSchema
+  prefixItems?: JsonSchema[]
   properties?: {
     [K in keyof IN & keyof OUT]: JsonSchema<IN[K], OUT[K]>
   }
@@ -1421,3 +1445,11 @@ type SchemaIn<S> = S extends JsonSchemaAnyBuilder<infer IN, any, any> ? IN : nev
 type SchemaOut<S> = S extends JsonSchemaAnyBuilder<any, infer OUT, any> ? OUT : never
 type SchemaOpt<S> =
   S extends JsonSchemaAnyBuilder<any, any, infer Opt> ? (Opt extends true ? true : false) : false
+
+type TupleIn<T extends readonly JsonSchemaAnyBuilder<any, any, any>[]> = {
+  [K in keyof T]: T[K] extends JsonSchemaAnyBuilder<infer I, any, any> ? I : never
+}
+
+type TupleOut<T extends readonly JsonSchemaAnyBuilder<any, any, any>[]> = {
+  [K in keyof T]: T[K] extends JsonSchemaAnyBuilder<any, infer O, any> ? O : never
+}