How to check if a given value is in a union type array

The biggest problem is how to handle all possible values that are not ConfigurationKeys without explicitly checking each one. I named them Configuration as it's very common scenario.

You can hide logic behind your own guard function that tells compiler: I can handle type checks, trust me. It's recognized by value is ConfigurationKeys return type.

Code example (live):

type ConfigurationKeys = "foo" | "bar";

function isConfiguration(value: string): value is ConfigurationKeys {
    const allowedKeys: string[] = ["foo", "bar"];
    
    return allowedKeys.indexOf(value) !== -1;
}

const key: string = "alien" // Rather: some random function

if (isConfiguration(key)) { 
    // key => ConfigurationKeys
} else { 
    // key => string
}

I found writing own guard functions as very clean solution to work with Union types. Sometimes type casting is still needed, but here you hide casting and logic within single piece of code.

Reference:

• User defined Type Guards
• TypeScript doc: Type Guards and Differentiating Types

The accepted answer uses type assertions/casting but from the comments it appears the OP went with a solution using find that works differently. I prefer that solution also, so here's how that can work:

const configKeys = ['foo', 'bar'] as const;
type ConfigKey = typeof configKeys[number]; // "foo" | "bar"

// Return a typed ConfigKey from a string read at runtime (or throw if invalid).
function getTypedConfigKey(maybeConfigKey: string): ConfigKey {
    const configKey = configKeys.find((validKey) => validKey === maybeConfigKey);
    if (configKey) {
        return configKey;
    }
    throw new Error(`String "${maybeConfigKey}" is not a valid config key.`);
}

Note that this can guarantee that a string is a valid ConfigKey both at runtime and compile time.