index.ts

import { URL } from 'url';

export const Url = Symbol.for('Url');
export const IpAddress = Symbol.for('IpAddress');
export const Nothing = Symbol.for('Nothing');
export type IpAddressMask = `${number}.${number}.${number}.${number}`;

export interface TypeEnvyArgument {
    key: string;
    keyExists: boolean;
    value?: string;
    error?: (error: string | Error) => void;
    warn?: (warning: string | Error) => void;
    toString: () => string;
}

export type VariablesType<T> = {
    [P in keyof T]: T[P] extends (arg: TypeEnvyArgument) => infer R
        ? R
        : T[P] extends readonly (infer U)[]
        ? U extends StringConstructor
            ? string
            : U extends BooleanConstructor
            ? boolean
            : U extends NumberConstructor
            ? number
            : U extends symbol
            ? U
            : U extends typeof Nothing
            ? typeof Nothing
            : U
        : T[P] extends typeof Url
        ? URL
        : T[P] extends typeof IpAddress
        ? IpAddressMask
        : never;
};

/*  eslint-disable @typescript-eslint/no-explicit-any */
export type VariableTemplate =
    | {
          [key: string]:
              | ((arg: TypeEnvyArgument) => any)
              | typeof Url
              | typeof IpAddress
              | string
              | StringConstructor
              | BooleanConstructor
              | NumberConstructor
              | readonly (
                    | typeof Nothing
                    | string
                    | number
                    | boolean
                    | StringConstructor
                    | BooleanConstructor
                    | NumberConstructor
                    | undefined
                )[]
              | never;
      }
    | never;

function toUnderscored(s: string): string {
    return s.includes('_') ? s : s === s.toUpperCase() ? s : s.replace(/(.)([A-Z]+)/g, '$1_$2').toUpperCase();
}

function Requires<I extends Record<string, unknown>, Variable extends VariableTemplate>(
    input: I,
    variable: Variable,
    validator?: (variable: VariablesType<Variable>) => boolean,
) {
    const output = Object.keys(variable).reduce(
        (a, c) => ({ ...a, [c]: input[c] || input[toUnderscored(c)] }),
        {},
    ) as VariablesType<Variable>;
    if (validator) {
        const valid = validator(output);
        if (!valid) {
            throw new Error('Invalid Environment Variables');
        }
    } else {
        Object.keys(variable).forEach((key) => {
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            const validatePrimitive = (key: string, value: any, type: any): unknown => {
                if (type === String) {
                    const ok = value === String(value); // ?
                    if (!ok) {
                        throw new Error(
                            `Could not safely convert required value ${key} from ${value || '<empty>'} to String.`,
                        );
                    }
                    return value;
                } else if (type === Boolean) {
                    const isTrue = ['yes', 'true', 'on', 'y', '1'].indexOf(value?.toLowerCase()) >= 0;
                    const isFalse = ['no', 'false', 'off', 'n', '0'].indexOf(value?.toLowerCase()) >= 0;
                    if (!isTrue && !isFalse) {
                        throw new Error(
                            `Could not safely convert required value ${key} from ${value || '<empty>'} to Boolean.`,
                        );
                    }
                    return isTrue;
                } else if (type === Number) {
                    const ok = !isNaN(parseFloat(value?.toString()));
                    if (!ok) {
                        throw new Error(
                            `Could not safely convert required value ${key} from ${value || '<empty>'} to Number.`,
                        );
                    }
                    return parseFloat(value as string);
                } else if (type === Url) {
                    try {
                        const url = new URL(value);
                        return url;
                    } catch (e) {
                        throw new Error(
                            `Could not safely convert required value ${key} from ${value || '<empty>'} to URL.`,
                        );
                    }
                } else if (type === IpAddress) {
                    const ok = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(
                        value,
                    );
                    if (!ok) {
                        throw new Error(
                            `Could not safely convert required value ${key} from ${value || '<empty>'} to IpAddress.`,
                        );
                    }
                    return value.toString();
                } else if (type === Nothing) {
                    [type, value]; // ?
                    if (value) {
                        throw new Error(Nothing.toString());
                    }
                    return Nothing;
                } else if (type === undefined) {
                    [type, value]; // ?
                    if (value) {
                        throw new Error('undefined');
                    }
                    return undefined;
                } else if (typeof type === 'function') {
                    try {
                        const ok = (type as (x: TypeEnvyArgument) => boolean)({
                            key: key,
                            keyExists: value !== undefined,
                            value: value,
                            toString: (): string => (value ? value : 'undefined').toString(),
                            // TODO: error/warning callback
                        });
                        return ok;
                    } catch (e) {
                        throw new Error(e instanceof Error ? e.message : (e as { toString: () => string }).toString());
                    }
                } else {
                    if (typeof type === 'string' || typeof type === 'boolean' || typeof type === 'number') {
                        const ok = type.toString() === value?.toString();
                        if (!ok) {
                            throw new Error(
                                `Could not safely convert required value ${key} from ${value || '<empty>'} to ${type}`,
                            );
                        }
                        return validatePrimitive(
                            key,
                            value,
                            {
                                string: String,
                                boolean: Boolean,
                                number: Number,
                                bigint: BigInt,
                                undefined: undefined,
                                function: Function,
                                object: Object,
                                symbol: Symbol,
                            }[typeof type],
                        );
                    }
                }
            };
            const realValue = output[key];
            const keyType = variable[key];
            if (Array.isArray(keyType)) {
                const ok = keyType.map((otherType) => {
                    try {
                        return validatePrimitive(key, realValue, otherType);
                    } catch (e) {
                        return e;
                    }
                });
                if (ok.find((e) => !(e instanceof Error))) {
                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
                    (output as any)[key] = ok.find((e) => !(e instanceof Error));
                } else {
                    const firstError = ok.find(
                        (e) => e instanceof Error && e.message !== Nothing.toString() && e.message !== 'undefined',
                    );
                    if (firstError) {
                        throw firstError;
                    }
                }
            } else {
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                (output as any)[key] = validatePrimitive(key, realValue, keyType);
            }
        });
    }
    return output;
}
interface TypeEnvyTypes {
    IpAddress: typeof IpAddress;
    Url: typeof Url;
    Nothing: typeof Nothing;
}

export function TypeEnvy<R extends VariableTemplate>(types: ((types: TypeEnvyTypes) => R) | R): VariablesType<R> {
    return fromAny(process.env).toType(types);
}

export function fromAny<T extends Record<string, unknown>>(
    value: T,
): { toType: <R extends VariableTemplate>(types: ((types: TypeEnvyTypes) => R) | R) => VariablesType<R> } {
    return {
        toType: <R extends VariableTemplate>(types: ((types: TypeEnvyTypes) => R) | R): VariablesType<R> => {
            return Requires(
                value,
                typeof types === 'function'
                    ? types({
                          IpAddress,
                          Url,
                          Nothing,
                      })
                    : types,
            );
        },
    };
}

export const Common = {
    not: (f: (...args: any[]) => boolean) => (x: any) => !f(x),
    StringOr: (s: string) => (x: TypeEnvyArgument) => x.value || s,
    StringOrError: (err: string) => (x: TypeEnvyArgument) => {
        if (x.value) {
            return x.value;
        } else {
            throw {
                name: x.key,
                error: err,
            };
        }
    },
    NumberOr: (s: number) => (x: TypeEnvyArgument) => [Number(x.value), s].find(Common.not(isNaN))!,
    TrueOr: (s: boolean) => (x: TypeEnvyArgument) =>
        x.value ? ['1', 'yes', 'true', 'on'].includes(x.value.toLowerCase()) : s,
    FalseOr: (s: boolean) => (x: TypeEnvyArgument) =>
        x.value ? ['0', 'no', 'false', 'off'].includes(x.value.toLowerCase()) : s,
    ConstantString: (s: string) => (x: TypeEnvyArgument) => {
        if (x.value && s !== x.value) {
            throw `"${x.value}" does not equal expected constant "${s}" for ${x.key}`;
        }
        return s;
    },
};