嵌套类结构会导致编译器错误

Question

我有一个这样的类层次结构：

用户：

• 角色：角色[]

角色：

• 权限：权限

每个类都有一个构造函数，将 args 转换为其指定的类，例如 User 将角色转换为 Role 实例。 Role 将权限转换为 Permission 实例。

示例代码：

const user = new User({
        roles: [
            {role_name: 'admin', permissions: {'*': '*'}} 
        ]
    })

当我使用嵌套的权限对象为用户传递 JSON 时，我得到编译器错误，因为权限上有方法。 Property 'has' is missing in type '{ '*': string; }' but required in type 'Permission'.

如何避免这些问题？

编辑：

如何使 Roles 类接受作为对象的权限，以便它可以正确地将 JSON 强制转换为 Permission 类型？

// users.ts
export interface User extends BaseModel {
    createdAt?: string;
    updatedAt?: string;
    email?: string;
    username?: string;
    fullname?: string;
    microsoftId?: string;
    roles?: UserRole[];
}

export class User {
    constructor(props?: Partial<User>) {
        if(!props){
            props = {};
        }

        props.roles = props.roles?.map(role => new Role(role)) || [];
        
        Object.assign(this, props);
    }

    hasPermission(service: string, perm: PermissionType){
        for(let role of this.roles || []){
            const has = (role.permissions as Permission).has(service, perm);
            if(has){
                return has;
            }
        }

        return false;
    }
}

// roles.ts


export interface Permission {
    [key: string]: PermissionType[]|any;
}

export class Permission {
    constructor(props: Partial<Permission>){
        Object.assign(this, props);
    }

    has(service: keyof Permission, permName: PermissionType|undefined): boolean {
        //.....
    }
}
export interface Role extends BaseModel {
    createdAt?: string;
    updatedAt?: string;
    role_name?: string;
    description?: string;
    scopes?: string[];
    permissions: Permission;
}
export class Role {
    constructor(props?: Partial<Role>) {
        if(!props){
            props = {};
        }

        props.permissions = new Permission(props.permissions || {});
        
        if (!Array.isArray(props.scopes)) {
            props.scopes = [];
        }

        Object.assign(this, props);
    }
}

Answer 1

不要将接口命名为与类相同。您正在合并名称并创建一个坦率地相当尴尬的设置。为构造函数参数提供单独的接口。

export interface PlainPermission {
    [key: string]: PermissionType[]|any;
}

export class Permission implements PlainPermission {
    [key: string]: PermissionType[]|any;

    constructor(props: Partial<PlainPermission>){
        Object.assign(this, props);
    }

    has(service: keyof Permission, permName: PermissionType|undefined): boolean {
        //.....
    }
}

Role 和 User 也是如此。然后你有一个明显的区别：PlainPermission 是你传递给构造函数的“普通”Javascript 对象，Permission 是附加了所有漂亮、方便的方法的东西。

当您定义一个接口和一个具有相同名称的类时，它们会合并以创建一个更大的类，Permission 被定义为“任何具有接口中的东西的东西和 has 方法”，这不是你想要的。

您将不得不从类中的接口复制字段名称，但这是有道理的：接口是实现某些东西的承诺，而类是实际的实现。一个是合同，另一个做合同规定的工作。您可以使用implements PlainPermission 作为额外检查，以确保您正确实现了接口。