shoooe/derive

Library to derive a TypeScript type from another.

derive's Issues

Expand documentation for merging shapes + practical examples in React

We should expand the documentation by:

• Adding a section about combining merging shapes via & to make it clear that that's possible and recommended
• Practical tips & tricks to use in React (also what we recommend in terms of exporting / re-using shapes).

Support for GraphQL-esque aliases

Problem

GraphQL supports aliases in the form:

query ($startOfWeek: DateTime!, $startOfLastWeek: DateTime!) {
    something {
        id
        startOfWeekValue: valueAt(at: $startOfWeek)
        startOfLastWeekValue: valueAt(at: $startOfLastWeek)
    }
}

Currently there's no good way to alias another field. If the field you are trying to alias is a scalar type then you can make it work via:

type Result = Derive<Something, {
    id: Auto;
    startOfWeekValue: Something["valueAt"];
    startOfLastWeekValue: Something["valueAt"];
}

but this won't work well with arrays and nested objects. It also doesn't infer optionality correctly because you are forced to specify the field as non optional.

You can probably make it work via a nested Derive for arrays and objects (haven't tried it yet), but that's cumbersome at best.

What happens and what should happen when combining two shapes with different values for the same key?

Example:

type A = Shape<X, { name: Auto; }>;
type B = Shape<X, { name: Alias<X, 'surname', Auto>; }>;
type X = A & B;

Shapes shouldn't require at least 1 field from the base type

With the introduction of aliases it does sometimes make sense for a shape to only have non-base-type fields.
The following should but currently doesn't compile:

type User = { id: number; }
type SomeShape = Shape<User, {}>; // doesn't compile
type SomeOtherShape = Shape<User, { extra: Alias<User, 'id'> }>; // also doesn't compile

Investigate why `any` is throwing

where:

Is there a better way to combine two shapes?

Use case

Say component A has a user definition:

type UserProp = Derive<User, { ... }>;

and the parent component wants to reuse that shape in its own type definition:

type BookProp = Derive<Book, {
    id: Auto;
    ...
    author: [HERE];
}>

Current solution

The current solution looks like this:

export type UserShape = Shape<User, { ... }>;
type UserProp = Derive<User, UserShape>;

and the parent component wants to reuse that shape in its own type definition:

type BookShape = Shape<Book, {
    id: Auto;
    ...
    author: UserShape & {
        id: Auto; // optional expansion
    };
}>
type BookProp = Derive<Book, BookShape>;

Problem

The solution might seem ok, but in practice this makes everything very verbose because for each type you want to derive you have to have 2 types (a shape and the actual derived type).

This is quite annoying to work with.
Ideally components should only have to export derived types and not share shapes around.

Possible solution 1

Declare a Combine shape field type that combines an arbitrary derived object with a shape.
Implementation wise Combine<Derived, Shape> would derive Shape into Derived2 and then return Derived & Derived2.

// Child component
export type UserProp = Derive<User, { ... }>;

// Parent component
type BookProp = Shape<Book, {
    id: Auto;
    ...
    author: Combine<UserProp, {
        id: Auto; // optional expansion
    }>;
}>

Issues

The problem with this solution is that it's unclear what would happen when combining something like:

type UserProp = Derive<User, { name: Auto; }>;
type BookProp = {
    author: Combine<UserProp, { name: Alias<User, 'fullName', Auto>; }>;
};

As you can see the two name properties for User might get resolved to two completely different types.

To be fair with the current solution you'd get never which is also not ideal.

Asymmetry wrt to extending a field

Currently we allow adding undefined or null to a field but we don't allow removing undefined or null.

We are not exactly type safe

We are too flexible in that we don't warn against weird states like:

type User  = { id: number }
type SomeShape = Shape<User, {
    id: Auto;
    extra: Auto;
}>;