[Feature] Input & output type infer about banditypes

[jordan-boyer]

We finally solved this problem with another approach.

import { object, number, string, optional, Banditype } from 'banditypes'

type Simplify<T> = T extends Object ? { [K in keyof T]: T[K] } : T;

const personSchema = object({
    name: string().or(optional()),
    age: number(),
    profession: string().or(optional()),
})

function withDefault<Schema extends object, Inputs extends Schema, Defaults extends Partial<Schema>> (
    schema: Banditype<Schema>,
    inputs: Inputs,
    defaults: Defaults & { [K in keyof Defaults]: K extends keyof Schema ? Schema[K] : never },
  ) {
    const data = schema(inputs);
    const result = {
        ...defaults,
        ...data,
    }
    return result as Simplify<typeof result>;
}


const input = { age: 12 }
const person1 = withDefault(personSchema, input, { profession: 'John Doe' });
const person2 = withDefault(personSchema, input, { name: 'John Doe', foobar: 'azerty' }); // 1
const person3 = withDefault(personSchema, input, { name: 'John Doe' });

function showName(name: string) { console.log(name) }

showName(person1.name) // 2
showName(person2.name) // 3
showName(person3.name) // 4

1. An error because foobar is not a key of personSchema
2. An error because name was not provided in input nor in defaults
3. No error because name was provided in defaults
4. Same as 3

We hope this can help anyone which want to achieve this using banditypes =)

[thoughtspile]

Ah yes, I am playing with this idea. It enables quite a few data transformation scenarios, from one with a default value that you suggested to exhausive type normalization:

array(string())
  .or(string().map(s => [s]))
  .or(set(string()).map(s => [...s]))

Besides, I suppose it would help us to make proper union types with objectLoose({ x: string() }).or(objectLoose({ y: string })), where objectLoose could be generic WRT the input of the or.

I'm not yet sure how to implement it, or what the most convenient API would be for declaring narrow input types, so let's have it sit here for a while.