How to Transform a Object into an Ordered Set of Discriminated Unions

Question

given the following type definition

type MailStatus = {
    InvoiceSent?: Date;
    ReminderSent?: { 
        date: Date;
        recipient: string;
    }
    FinalReminderSent?: {
        date: Date;
        recipient: string;
        text: string;
    }
}

I'd like to have type where I can define the "order" in which a property is required and which creates a discriminated union which have ever more required properties.

For example

type OrderedMailStatus = MagicType<MailStatus, "InvoiceSent" | "ReminderSent" | "FinalReminderSent">
//or this
type OrderedMailStatus = MagicType<MailStatus, ["InvoiceSent", "ReminderSent","FinalReminderSent"]>

should yield the following type

type OrderedMailStatus =
| {
    kind: "InvoiceSentRequired";
    InvoiceSent: Date;          //InvoiceSent now required
    ReminderSent?: { 
        date: Date;
        recipient: string;
    };
    FinalReminderSent?: {
        date: Date;
        recipient: string;
        text: string;
    };
  }
| {
    kind: "ReminderSentRequired";
    InvoiceSent: Date;          //InvoiceSent required
    ReminderSent: {             //ReminderSent also required
        date: Date;
        recipient: string;
    };
    FinalReminderSent?: {
        date: Date;
        recipient: string;
        text: string;
    };
  }
| {
    kind: "FinalReminderSentRequired";
    InvoiceSent: Date;          //all
    ReminderSent: {             //3 properties
        date: Date;
        recipient: string;
    };
    FinalReminderSent: {       //are required
        date: Date;
        recipient: string;
        text: string;
    };
  }

so that I could do the following assignments

const s1 = {
    kind: "InvoiceSentRequired",
    InvoiceSent: new Date()
} //OK

const s2 = {
    kind: "ReminderSentRequired",
    InvoiceSent: new Date(),
    ReminderSent: {
        date: new Date(),
        recipient: "Somebody@somewhere.com"
    }
} //OK

const s3 = {
    kind: "FinalReminderSentRequired",
    ReminderSent: {
        date: new Date(),
        recipient: "Somebody@somewhere.com"
    },
    FinalReminderSent: {
        date: new Date(),
        recipient: "Somebody@somewhere.com",
        text: "YOU HAVE TO PAY!"
    }

} //FAILS because it is missing the property InvoiceSent

Also important: The types of the properties should be automatically taken what ever they are in the original MailStatus. So even in this expanded example you can not make any assumptions which property has which type.

The principle idea behind this question is something along the lines of a Workflow. Where in the beginning you have a type whose properties are all optional. As this type travels across the system more and more properties become mandatory

Answer 1

First of all it worth creating a tuple with expected order of keys:

type Keys = ["InvoiceSent", "ReminderSent", "FinalReminderSent"]

Now we need to create an utility type which will iterate through Keys tuple and create expected union.

type Union<
    Tuple extends any[],
    Result extends {} = never
    > =
    // Obtain first element from the Tuple
    (Tuple extends [infer Head, ...infer Rest]
        // Check whether this element extends allowed keys
        ? (Head extends keyof MailStatus
            // call Union recursively with Rest
            // and unionize previous Result with newly created discriminated union
            ? Union<Rest, Result | MailStatus & Record<Head, Date> & { kind: `${Head}Required` }>
            : never)
        : Result)

Playground

Lets test it:

type Result = Union<Keys>

// ok
const result: Result = {
    kind: 'InvoiceSentRequired',
    InvoiceSent: new Date()
}

// expected error
const result2: Result = {
    kind: 'InvoiceSentRequired',
}

// ok
const result3: Result = {
    kind: 'FinalReminderSentRequired',
    FinalReminderSent: new Date
}

Looks like it works

P.S. Don't rely on keyof operator if you are interested in some particular order. See this issue and my question

Answer 2

Here's my solution to this problem:

type Id<T> = {} & { [P in keyof T]: T[P] }

type PickIfNotPrimitive<T, K extends keyof T, V = T[K]> = 
    V extends Date | string | number | bigint | boolean 
        ? Record<K, V>
        : Pick<T, K>
        
type Accumulate<T, Keys extends string[], B = {}, R = never> =
    Keys extends [infer Head, ...infer Tail] ? 
        Tail extends string[]
            ? Accumulate<
                T, 
                Tail,
                Required<PickIfNotPrimitive<T, Head & keyof T>> & B, 
                // New result
                    | R & Partial<PickIfNotPrimitive<T, Head & keyof T>> // Add new partial values
                    | Required<PickIfNotPrimitive<T, Head & keyof T>> & B & { type: `${Head & string}Required` }>
            : never
        :Id<R>

type X =  Accumulate<MailStatus, [
    "InvoiceSent", 
    "ReminderSent",
    "FinalReminderSent"
]>

Playground Link

We build up in R the result one by one. B represents the fields that are already required.

I use Id just to pretty up the types. Can be removed, but the results are unreadable without it.

Not sure I would recommend actually using this, but it is fun