TypeScript泛型类型中字符串索引报错的解决方案咨询

问题重现 #

原始类型定义 #

export type CommandOptionType = string | number | boolean;
export type CommandOption = Record<string, CommandOptionType>;

export type LeafCommand<T extends CommandOption> = {
    name: string;
    handle: (
        interactionOptionValues: { [K in keyof T]: T[K] },
    ) => Promise<void>;
};

export type LeafCommandGroup = {
    name: string;
    commands: Record<string, LeafCommand<CommandOption>>;
};

export type RootCommand = {
    name: string;
    commands: Record<string, LeafCommandGroup | LeafCommand<CommandOption>>;
};

命令实现 #

type OPTIONS = {
    option1: "type1" | "type2" | "type3" | "type4";
    option2: string;
    option3: boolean;
};

const Type = {
    name: "type",
    handle: async (interactionOptionValues) => {
        // 业务逻辑
    },
} satisfies LeafCommand<OPTIONS>;

报错代码 #

const Root = {
    name: "root",
    commands: { // 错误发生在此处
        [Type.name]: Type,
    },
} satisfies RootCommand;

错误提示：

Type { [x: string]: CommandOptionType } is missing the following properties from type. option1, option2, option3

错误原因 #

RootCommand 中定义的 commands 要求值类型为 LeafCommand<CommandOption>，而 CommandOption 是任意键值对的 Record<string, CommandOptionType>。但你实现的 Type 是 LeafCommand<OPTIONS>，它的 handle 方法参数是更具体的 OPTIONS（包含固定的 option1/option2/option3 键）。

TypeScript 认为这种赋值不安全：如果允许将 LeafCommand<OPTIONS> 赋值给 LeafCommand<CommandOption>，外部调用时可能传入缺少必要键的 CommandOption 参数，导致业务逻辑出错。

解决方案 #

修改类型定义，支持任意泛型命令 #

将 RootCommand 改为泛型类型，让它自动推断 commands 中命令的具体类型，而非强制约束为固定的 LeafCommand<CommandOption>：

export type CommandOptionType = string | number | boolean;
export type CommandOption = Record<string, CommandOptionType>;

export type LeafCommand<T extends CommandOption> = {
    name: string;
    handle: (
        interactionOptionValues: { [K in keyof T]: T[K] },
    ) => Promise<void>;
};

export type LeafCommandGroup = {
    name: string;
    commands: Record<string, LeafCommand<CommandOption>>;
};

// 改为泛型类型，自动推断commands的具体结构
export type RootCommand<T extends Record<string, LeafCommandGroup | LeafCommand<CommandOption>> = Record<string, LeafCommandGroup | LeafCommand<CommandOption>>> = {
    name: string;
    commands: T;
};

修改后再创建 Root，TypeScript 会自动推断 commands 中 Type 的具体类型，不会再报错。

更优设计模式：用工厂函数创建命令 #

通过工厂函数封装命令创建逻辑，既能自动推断类型，又能保证类型安全，同时简化代码：

// 工厂函数：创建叶子命令
export function createLeafCommand<T extends CommandOption>(command: LeafCommand<T>) {
    return command;
}

// 工厂函数：创建命令组
export function createLeafCommandGroup(group: LeafCommandGroup) {
    return group;
}

// 工厂函数：创建根命令
export function createRootCommand<T extends Record<string, LeafCommandGroup | LeafCommand<CommandOption>>>(command: RootCommand<T>) {
    return command;
}

使用示例

type OPTIONS = {
    option1: "type1" | "type2" | "type3" | "type4";
    option2: string;
    option3: boolean;
};

// 自动推断handle参数类型为OPTIONS
const Type = createLeafCommand({
    name: "type",
    handle: async (interactionOptionValues) => {
        console.log(interactionOptionValues.option1); // 类型提示正常
    },
});

// 自动推断commands的类型，无报错
const Root = createRootCommand({
    name: "root",
    commands: {
        [Type.name]: Type,
    },
});

内容的提问来源于stack exchange，提问作者Bekir Nazmi Görkem