In Typescript, object strings can be enforced to be used from the parent object similar to

Question

In Typescript, object strings can be enforced to be used from the parent object similar to

I am currently developing an API wrapper for a lower level library that utilizes enums to map human readable keys to internal values. In order to enhance security, I want to only use the enum keys and not the underlying values in any logging or other functions. I am seeking a way to dynamically create an object that mirrors the original enum but with keys/values that are identical. Additionally, I want to ensure that the parent object keys are passed as parameters similar to an enum, rather than allowing direct use of the string value.

enum Colors {
    red = '$r5',
    green = '$g2',
    lightBlue = '$b9',
    darkBlue = '$b1',
}

function getColor(color: Colors) {
    return color;
}


getColor(Colors.darkBlue); // succeeds
getColor('darkBlue'); // fails as expected

function createKeyEnum<E>(e: E): {[k in keyof E]: k extends keyof E ? k : never} {
    return Object.keys(e).reduce((p, v) => {
        (p as any)[v] = v;
        return p;
    }, {} as {[k in keyof E]: k extends keyof E ? k : never});
}

const NewColors = createKeyEnum(Colors);
type NewColors = keyof typeof NewColors;


// forward mapping
function getOldColor(color: NewColors) {
    return Colors[color];
}

// reverse mapping
function getNewColor(color: Colors) {
    const reverse: any = {};
    Object.entries(Colors).forEach(([k, v]) => reverse[v] = k);
    return reverse[color] as NewColors;
}

getOldColor(NewColors.darkBlue); // succeeds
getOldColor('darkBlue'); // succeeds, but should fail like an enum
const color = getNewColor(Colors.darkBlue);
// typeof color == 'red' | 'green' | 'lightBlue' | 'darkBlue'
// should be: typeof color == NewColors

Is it possible to achieve this functionality with advanced typings, or are enums a unique feature that cannot be replicated using other TypeScript typings? In the code snippet provided, my NewColors types only result in a union of literal key strings. While this serves its purpose, it does permit users to utilize the string value directly. How can I associate it with the parent symbol NewColors and ensure that values are strictly derived from it like in an enum?

typescript enums

Answer 1

Answer №1

To ensure the object generated by createKeyEnum() has properties with values that are nominally typed, it is important to distinguish between similar values based on their names or declaration sites. While NewColors.darkBlue may be the same as "darkBlue" during runtime, the compiler should treat them as distinct entities due to their names.

In TypeScript, most of the type system is structural, meaning two types can be considered compatible even if they have different names or declaration sites. There has been a long-standing request for official support for nominal typing in TypeScript, which is yet to be addressed.

While enums in TypeScript offer some semblance of nominal typing, it is not feasible to generate an enum programmatically. This limitation necessitates a different approach.

To achieve nominal typing in TypeScript, a string literal type can be "branded" by intersecting it with a nominal or nominal-ish type. This branding serves to simulate nominal types within the type system, allowing for the desired behavior.

By using an intersection, the branded type can be assigned to the string literal type but not vice versa. This ensures type safety in the code base and prevents unintended errors.

Depending on the intersected type, a type assertion may be required within the implementation of createKeyEnum() to convince the compiler of the expected type. This helps in maintaining the integrity and consistency of the nominal typing.

One possible implementation involves defining a type alias Brand<T, U> that brands T with a type dependent on U. The specifics of how Brand is defined can vary, but the overarching goal remains the same.

With the proposed implementation of Brand, createKeyEnum() can be structured in a way that enforces nominal typing and prevents unintended type violations.

By utilizing a _tag property, nominal typing can be simulated within the TypeScript type system, safeguarding against potential misuse or type inconsistencies. The use of structural typing in this context helps maintain type safety.

In scenarios where a higher level of type security is needed, utilizing a class with a private member can further enhance the nominal typing mechanism. This approach restricts the creation and manipulation of instances, reducing the likelihood of type errors.

By leveraging the private nature of the _tag member and constructor, the BrandClass type can be treated as nominal in nature, enhancing the overall type safety of the code base.

Overall, implementing nominal typing in TypeScript involves a combination of structural and private member approaches to ensure type integrity and prevent unintended type violations.

Answer 2