@pallad/app-env/compiled/Factory.js

Detects environment (production, staging, test, development, ci) and helps making decision based on that

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Factory = void 0;
const StandardEnvName_1 = require("./StandardEnvName");
const isCI_1 = require("./isCI");
const NoEnvironmentNameFoundError_1 = require("./error/NoEnvironmentNameFoundError");
const Builder_1 = require("./Builder");
const DEFAULT_ENV_NAME_ENV_KEYS = ['APP_ENV', 'NODE_ENV'];
const DEFAULT_ENV_ID_ENV_KEYS = ['APP_ENV_ID'];
class Factory {
    config;
    constructor(config) {
        this.config = config;
        if (this.config.envName) {
            this.config.envName = this.config.envName.map(name => name.toLowerCase());
        }
    }
    get supportedEnvNames() {
        return this.config.envName ?? StandardEnvName_1.StandardEnvNameList;
    }
    isValidEnvName(name) {
        return this.supportedEnvNames.includes(name);
    }
    isValidEnvId(id) {
        if (this.config.validateEnvId) {
            return this.config.validateEnvId(id);
        }
        return id === undefined || typeof id === 'string';
    }
    createFromProcessEnv(env = process.env) {
        return this.create(this.getEnvNameFromProcess(env), this.getEnvIdFromProcess(env));
    }
    getEnvNameFromProcess(env = process.env) {
        const envKeyNames = this.config.envNameEnvKeys ?? DEFAULT_ENV_NAME_ENV_KEYS;
        for (const envKey of envKeyNames) {
            const candidate = (env[envKey] ?? '').trim().toLowerCase();
            if (candidate && this.isValidEnvName(candidate)) {
                return candidate;
            }
        }
        if ((0, isCI_1.isCI)(env) && this.isValidEnvName('ci')) {
            return 'ci';
        }
        if (this.isValidEnvName('development')) {
            return 'development';
        }
        throw NoEnvironmentNameFoundError_1.NoEnvironmentNameFoundError.fromConfig(envKeyNames, this.supportedEnvNames.slice());
    }
    getEnvIdFromProcess(env = process.env) {
        const envKeyNames = this.config.envIdEnvKeys ?? DEFAULT_ENV_ID_ENV_KEYS;
        for (const envKey of envKeyNames) {
            const candidate = (env[envKey] ?? '').trim().toLowerCase();
            if (candidate && this.isValidEnvId(candidate)) {
                return candidate;
            }
        }
    }
    create(env, envId) {
        const is = (...names) => {
            return names.includes(env);
        };
        const forEnv = (...names) => {
            const func = (value, defaultValue) => {
                if (is(...names)) {
                    return value;
                }
                return defaultValue;
            };
            return func;
        };
        const info = {
            name: env,
            id: envId,
            forEnv,
            forProduction: forEnv('production'),
            forStaging: forEnv('staging'),
            forCi: forEnv('ci'),
            forCI: forEnv('ci'),
            forDevelopment: forEnv('development'),
            forTest: forEnv('test'),
            forPreview: forEnv('preview'),
            is,
            isProduction: is('production'),
            isStaging: is('staging'),
            isCi: is('ci'),
            isCI: is('ci'),
            isDevelopment: is('development'),
            isTest: is('test'),
            isPreview: is('preview'),
            isEnv: is,
            build() {
                return new Builder_1.Builder(info);
            },
            isEnvId: (...names) => {
                return names.includes(envId);
            }
        };
        return info;
    }
}
exports.Factory = Factory;