Infer nested function parameter types from containing object

I've got myself hitting a bit of a brick wall with Typescript. I am attempting to build a command-parsing utility, and would like to add type hints within configuration objects.

Consider the following;

interface Argument {
  type: 'string' | 'number'
}

interface Command {
  label: string
  arguments: Record<string, Argument>
}

// --

export default {
  label: 'execute-task',
  arguments: {
    'task_name': {
      type: 'string'
    }
  },
} as Command

Now consider that I would like to add a 'handler' function within this object;

type HandlerOptions<...> = ...

interface Command {
  label: string
  arguments: Record<string, Argument>
  handler: (options: HandlerOptions<...>) => void
}

// --

export default {
  label: 'execute-task',
  arguments: {
    'task_name': {
      type: 'string'
    }
  },
  handler(options) {
    console.log(options)
  },
} as Command

I would like to get type inference on the options object at console.log(options) line above, such that;

• to begin with; typeof options resolves { task_name: unknown } or similar
• in a more advanced version, it resolves to { task_name: string }, though I expect this will be simple once my previous goal is achieved.

What I'm struggling with is defining the HandlerOptions<...> type in the above example, such that it resolves the actual object properties, instead of the Command generic, which returns an empty record.

Looking at the docs, the primary direction I've been trying is variations of the following (indexed types);

type HandlerOptions<C extends Command> = {
  [key in keyof C['arguments']]: ...
}

Attempted with ThisType<Command>, 'rebuilding' the type using utility types, and wrapping the configuration object in a function that returns a computed type... but that doesn't help for type hinting in the original object itself.

The closest I have been with this resolves to { [x: string]: ... } or an empty object.

I'm therefore wondering;

• Is this even possible?
• If yes, what's the nugget that I'm missing here?
• If not, what would be a possible alternative for similar developer experience?

Thank you!

So I think I understand what you're looking for, but I apologize if I got it wrong. I modified your types and added a generic createCommand helper method that allows the type of options to be inferred:

interface Argument {
  type: "string" | "number";
}

type HandlerOptions<Args extends Record<string, Argument>> = {
  [key in keyof Args]: any;
};

interface Command<Label extends string, Args extends Record<string, Argument>> {
  label: Label;
  arguments: Args;
  handler: (options: HandlerOptions<Args>) => void;
}

function createCommand<Label extends string, Args extends Record<string, Argument>>(
  label: Label,
  args: Args,
  handler: (options: HandlerOptions<Args>) => void
): Command<Label, Args> {
  return {
    label,
    arguments: args,
    handler,
  };
}

const testCommand = createCommand("execute-task", { task_name: { type: "string" } }, (options) => {
  console.log(options.task_name);
});

When writing the function I passed as the handler argument to createCommand, the type of options was inferred - Intellisense suggested task_name after typing "options.".

Currently, there is no way to do that directly with the type you want. Instead, we should add a generic parameter to Command interface, which will represent the arguments:

interface Command<
  T extends Record<string, Argument> = Record<string, Argument>
> {
  label: string;
  arguments: T;
  handler: (options: HandlerOptions<T>) => void;
}

For the HandlerOptions we will need a map to convert string literal of the argument to the actual type:

type TypeMap = {
  string: string;
  number: number;
};

In HandlerOptions we are going to use mapped types to achieve the desired type:

type HandlerOptions<T extends Record<string, Argument>> = {
  [K in keyof T]: TypeMap[T[K]["type"]];
}

Example:

// type Example = {
//   argument1: string;
// }
type Example = HandlerOptions<{ argument1: { type: "string" } }>;

We will also need a some function that would accept a command and return it. The only purpose of this function will be to infer the type of the arguments:

const getCommand = <T extends Record<string, Argument>>(command: Command<T>) =>
  command;

Usage:

getCommand({
  label: "execute-task",
  arguments: {
    task_name: {
      type: "string",
    },
  },
  handler(options) {
    // HandlerOptions<{
    //  task_name: {
    //     type: "string";
    //  };
    // }>
    options;
  },
});

To make the type of the options more readable we may use the the following utility type:

type Prettify<T> = T extends infer R ? { [K in keyof R]: R[K] } : never;

type HandlerOptions<T extends Record<string, Argument>> = Prettify<{
  [K in keyof T]: TypeMap[T[K]["type"]];
}>;

With this the type of the option for the previous case will be:

{  
  task_name: string;
}

playground