Create TypeScript index type whose properties `[key of Y]: Partial<X>`, when each combined with a `default: Partial<X>` property, are not partials

Question

Consider the following type definitions in TypeScript:

enum Environment {
  Local = 'local',
  Prod = 'prod'
}

type EnvironmentConfig = {
  isCustomerFacing: boolean,
  serverUrl: string
}

type DefaultBaseConfig<T> = {
  default: T
}

type EnvironmentBaseConfig<T> = {
  [key in Environment]: T
}

type BaseConfig<T> = DefaultBaseConfig<T> | EnvironmentBaseConfig<T>;

// const baseConfig: ??? = {
const baseConfig: BaseConfig<Partial<EnvironmentConfig>> = {
  default: {
    isCustomerFacing: false
  },
  local: {
    serverUrl: 'https://local.example.com'
  },
  prod: {
    isCustomerFacing: true
  }
};

Notice the object at the end with const baseConfig: ??? and the Partial<> on the next line. What I really want is for baseConfig to allow each Environment-keyed property to be a Partial<EnvironmentConfig>, and to allow the default property to be the same, but also require that the intersection between default and each environment local and prod in turn must be a full (not Partial<>) EnvironmentConfig, thus fulfilling the requirements of some type along the lines of BaseConfig.

In the example case here, local would be valid because when combined with default it has both properties. But, prod would not be valid because no serverUrl has been declared between the intersection of default and prod.

Obviously, at a later time, this config object will be merged conditionally in some code that takes a BaseConfig and an environmentName and returns an EnvironmentConfig, and it will be guaranteed to work at runtime if it is given a static config object that has been inspected by Typescript to comply with the desired constraints.

I have been puzzling away at this for a while and am stuck. I know how to do conditional types and type constraints such as T extends U ? T : never, but can't seem to figure out how and where to apply that to this scenario.

How can I achieve this goal?

Here is my best attempt so far, but, of course it doesn't work:

type SplitWithDefault<
  TComplete,
  TDefault extends Partial<TComplete>,
  TSplit extends { default: TDefault, [key: string]: Partial<TComplete> }
> = { default: TDefault }
  & { [P in keyof Omit<TSplit, 'default'>]: (TSplit[P] & TDefault) extends TComplete ? TSplit[P] : never };

jcalz · Accepted Answer · 2020-09-28 01:48:50Z

2

Your desired BaseConfig is really more of a self-referential generic constraint than a specific type in TypeScript. That is, given a specific candidate type T, you can check if it is assignable to a BaseConfigConstraint<T> rule, but you'd find it hard/impossible to express "all types that adhere to this rule" in a single TypeScript object type.

In cases like this I usually write a helper identity function that takes a single argument and returns it, but only accepts arguments of a type T extends BaseConfigConstraint<T> for a suitable definition of BaseConfigConstraint<T>. Something like this:

const asBaseConfig = <T extends
  { default: Partial<EnvironmentConfig> } &
  Record<Environment,
    Partial<EnvironmentConfig> &
    Omit<EnvironmentConfig, keyof T['default']>
  >
>(baseConfig: T) => baseConfig;

Here we are saying that baseConfig must be of a type T with:

a default property of a subtype of Partial<EnvironmentConfig>, and
properties at Environment keys of subtypes of both:
- Partial<EnvironmentConfig>, and
- an object with any properties of EnvironmentConfig that are missing from the default property of T.

In other words, T must have keys from Environment as well as "default", all of which must have Partial<EnvironmentConfig> properties, but any properties missing from the default property must be present in the Environment ones.

Let's see how it works on your example:

const baseConfig = asBaseConfig({
  default: {
    isCustomerFacing: false
  },
  local: {
    serverUrl: 'https://local.example.com'
  },
  prod: { // error!
//~~~~ <-- Property 'serverUrl' is missing 
    isCustomerFacing: true,
  }
});

This is exactly the error you wanted. You can fix the error either by adding serverUrl to prod or to default. So that's good.

Note that having a constraint instead of a type means that any function or type which you were going to give a parameter or a property of type BaseConfig will now need to be a generic function or type with a type parameter corresponding to this constraint. This may or may not be something you're willing to do in your code base.

Playground link to code

answered Sep 28, 2020 at 1:48

jcalz

339k29 gold badges452 silver badges449 bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

ErikE Over a year ago

Thanks for the answer. This seems like a reasonable solution and I'm probably going to use it.

ErikE Over a year ago

This is almost working just as I need it. Is there a way to allow the default to not have to contain all possible properties, such that the environment-keyed config sections can add new properties that aren't in the default? Imagine local wants to define clientId: string, but there is no default for this in the default section. Can that be accommodated? If you do answer, please just add code, don't change the existing code, as it is quite instructive.

ErikE Over a year ago

Though, I just found an issue which makes this substantially more complicated. If the properties that need to be overridden exist farther down in subproperties of subproperties, the solution in your answer will fail, because it only looks at the first-level properties. I imagine this is possible, but will be quite difficult to get right. That's unfortunate. I was hoping!!! My fault for not providing an example that had sub-properties, and which led to the simpler assumption that all properties would be at the top level.

jcalz Over a year ago

Yeah, I wasn't thinking about subproperty merging. That would become more complicated. It might be possible but I'm not sure right now

Collectives™ on Stack Overflow

Create TypeScript index type whose properties `[key of Y]: Partial<X>`, when each combined with a `default: Partial<X>` property, are not partials

1 Answer 1

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related