Type-safe config loading

config.ts

// TODO: We need an overload for a default value so it doesn't throw
function env(name: string): string;
function env<T>(name: string, transformer: (dirty: string) => T): T;
function env<T>(name: string, transformer?: (dirty: string) => T): T | string {
    const value = process.env[name];

    if (value == undefined) {
        // todo: should null be allowed? it might be a valid value for some
        // consumers instead of defaulting to an empty string.
        throw new Error(`Missing environment variable: ${name}`);
    }

    if (typeof transformer === 'function') {
        return transformer(value);
    }

    return value;
}

interface ApplicationConfiguration {
    environment: 'production' | 'development';
    debug: boolean;
    logLevel: false | number;
    connection: Connection;
}

type Connection = RedisConnection | DynamoDbConnection | MemoryConnection

interface RedisConnection {
    type: 'redis';
    options: {
        host: string;
        port: number;
        databaseId: number;
    };
}

interface DynamoDbConnection {
    type: 'dynamodb';
    options: {
        region: string;
        accessKeyId: string;
        secretAccessKey: string;
        tableName: string;
    };
}

interface MemoryConnection {
    type: 'memory';
}



const config: ApplicationConfiguration = {
    environment: env('NODE_ENV', getValidNodeEnvironment),
    debug: true,
    logLevel: env('LOG_LEVEL', getLogLevel),
    connection: env('CONNECTION_DRIVER', getConnectionOptions),
};

function getValidNodeEnvironment(env: string) {
    if (env === 'production' || env === 'development') {
        return env;
    }

    throw new Error(`Bad NODE_ENV value: ${env}`);
}

function getLogLevel(level: string) {
    const num = parseInt(level);

    if (num === 0) {
        return false;
    }

    return num;
}

function getConnectionOptions(driver: string): Connection {
    if (driver === 'memory') {
        return { type: 'memory' };
    } else if (driver === 'dynamodb') {
        return { type: 'dynamodb', options: {
            region: env('DYNAMODB_REGION'),
            accessKeyId: env('AWS_ACCESS_KEY_ID'),
            secretAccessKey: env('AWS_SECRET_ACCESS_KEY'),
            tableName: env('DYNAMODB_TABLE'),
        }};
    } else if (driver === 'redis') {
        return { type: 'redis', options: {
            host: env('REDIS_HOST'),
            port: env('REDIS_PORT', parseInt),
            databaseId: env('REDIS_DB', parseInt),
        }};
    }

    throw new Error(`Invalid connection driver: ${driver}`);
}

export { config };