Infer types using own properties

Question

I'm trying to find out if there is a way to infer types in an interface from an implementation's properties.

Simplified example:

interface Options {
  type: 'string' | 'number'
  demanded?: boolean
}

interface Command {
  // The parameter options will contain the interpreted version of the options property
  callback: (options: InferOptionTypings<this>) => void
  options: { [key: string]: Options }
}

// Infer the options
// { type: 'string, demanded: false} | { type: 'string' }   => string | undefined
// { type: 'string, demanded: true }                        => string
// { type: 'number', demanded: false} | { type: 'number }   => number | undefined
// { type: 'number, demanded: true }                        => number
type InferOptionTypings<_ extends Command> = ... // here i've been stuck for very long

I've read the typings of yargs (and this is obviously inspired by yargs), but I've not figured out how to make it work in this style or what I'm missing/if this even is possible.

Example use case:

let command: Command = {
  callback: (options) => {
    options.a // string
    options.b // number | undefined
    options.c // string | undefined
    options.d // error
  },
  options: {
    a: {
      type: 'string',
      demanded: true,
    },
    b: {
      type: 'number',
    },
    a: {
      type: 'string',
    },
  },
}

Can you give an example of how you would use `Command.callback`? — Connor Low, Aug 05 '21 at 16:00
Of course i can! (Example now in edited question). Though I am not sure, if this is what you meant — Tony Borchert, Aug 05 '21 at 16:09
@TonyBorchert btw, are working on some library or smth else? Here https://stackoverflow.com/questions/68676771/how-can-i-create-a-type-from-a-schema-that-describes-it/68677920?noredirect=1#comment121373805_68677920 is a very similar question. I just want to write an article dedicated to this problem and I don't kno how to name this usecase — captain-yossarian from Ukraine, Aug 06 '21 at 09:37
Im not writing a library its just some typings for some commands, but thanks for the extra information in the link and if you have the article ill gladly read it, though i can't think of any name for this type of issue — Tony Borchert, Aug 06 '21 at 10:24

captain-yossarian from Ukraine · Accepted Answer · 2021-08-05T17:39:34.700

It is possible, but in order to infer it you should create a function.

interface Option {
  type: 'string' | 'number'
  demanded?: boolean
}

/**
 * Translates string type name to actual type
 * Logic is pretty straitforward
 */
type TranslateType<T extends Option> =
  T['type'] extends 'string'
  ? string
  : T['type'] extends 'number'
  ? number
  : never;

/**
 * Check if demanded exists
 * if true - apply never, because union of T|never produces T
 * if false - apply undefined
 */
type ModifierType<T extends Option> =
  T extends { demanded: boolean }
  ? T['demanded'] extends true
  ? never
  : T['demanded'] extends false
  ? undefined
  : never
  : undefined

/**
 * Apply TranslateType 'string' -> string
 * Apply ModifierType {demanded:fale} -> undefined or never
 */
type TypeMapping<T extends Option> = TranslateType<T> | ModifierType<T>

/**
 * Apply all conditions to each option
 */
type Mapping<T> = T extends Record<string, Option> ? {
  [Prop in keyof T]: TypeMapping<T[Prop]>
} : never

type Data<Options> = {
  callback: (options: Mapping<Options>) => void,
  options: Options
}
const command = <
  /**
   * Infer each option
   */
  Options extends Record<string, Option>
>(data: Data<Options>) => data

const result = command({
  callback: (options) => {
    type a = typeof options.a
    type b = typeof options.b
    type c = typeof options.c

    options.a // string
    options.b // number | undefined
    options.c // string | undefined
    options.d // error
  },
  options: {
    a: {
      type: 'string',
      demanded: true,
    },
    b: {
      type: 'number',
      demanded: false
    },
    c: {
      type: 'string',
    },
  },
})

I left the comments under each type utility

Playground

UPDATE Without function:

type WithoutFunction = Data<{
  a: {
    type: 'string',
    demanded: true,
  },
  b: {
    type: 'number',
    demanded: false
  },
  c: {
    type: 'string',
  },
}>

Very helpful and I'm definitely gonna use this/do it this way, but out of pure curiosity, can this be done without any function (I didn't really understand the first sentence of your answer/if it is possible or if you have to do it with a function) — Tony Borchert, Aug 05 '21 at 17:04
While this isn't like in my example, it is still without a function and probably the best possible and definitely is good enough (in my opinion the function is better than just having an interface) so thanks for the help, even after me asking another dumb question — Tony Borchert, Aug 05 '21 at 21:26
it is no dimb question. unfortunatelly it is impossible to do it without function — captain-yossarian from Ukraine, Aug 05 '21 at 21:43

Infer types using own properties

1 Answers1

Linked