@krauters/environment/dist/src/environment.js

A TypeScript utility library that provides a fluent, type-safe API for defining, transforming, and managing environment variable configurations in applications.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EnvironmentBuilder = void 0;
const dotenv_1 = require("dotenv");
const utils_1 = require("./utils");
(0, dotenv_1.configDotenv)();
class EnvironmentBuilder {
    info;
    constructor(info) {
        this.info = info;
    }
    static create(...requiredKeys) {
        const initialInfo = {
            defaultValues: {},
            optionalKeys: [],
            prefix: '',
            requiredKeys,
            transforms: {},
        };
        return new EnvironmentBuilder(initialInfo);
    }
    defaults(defaultValues = {}) {
        const updatedInfo = { ...this.info, defaultValues };
        return new EnvironmentBuilder(updatedInfo);
    }
    environment(keys = process.env) {
        const optionalEnvs = this.processOptionalKeys(keys);
        const requiredEnvs = this.processRequiredKeys(keys);
        const allEnvs = { ...optionalEnvs, ...requiredEnvs.requiredValues };
        const errors = requiredEnvs.errors;
        if (errors.length > 0) {
            const message = `The following environment variables are required but not set: ${JSON.stringify(errors)}`;
            throw new Error(message);
        }
        return allEnvs;
    }
    optionals(...vars) {
        const updatedInfo = { ...this.info, optionalKeys: [...this.info.optionalKeys, ...vars] };
        return new EnvironmentBuilder(updatedInfo);
    }
    transform(transform, ...vars) {
        const updatedTransforms = vars.reduce((acc, key) => ({
            ...acc,
            [key]: transform,
        }), this.info.transforms);
        return new EnvironmentBuilder({
            ...this.info,
            transforms: updatedTransforms,
        });
    }
    withPrefix(prefix) {
        (0, utils_1.debug)(`Using environment variable prefix [${prefix}]`);
        const exampleKeys = [...this.info.requiredKeys, ...this.info.optionalKeys];
        const examples = exampleKeys.map((key) => `${prefix}${key.toUpperCase()}=example_value`);
        if (examples.length > 0) {
            (0, utils_1.debug)(`Example usage: [${examples.join(', ')}]`);
        }
        else {
            (0, utils_1.debug)(`Example usage: ${prefix}VARIABLE_NAME=example_value`);
        }
        const updatedInfo = { ...this.info, prefix };
        return new EnvironmentBuilder(updatedInfo);
    }
    applyTransform(key, value) {
        const transformFunction = this.info.transforms[key];
        if (typeof transformFunction === 'function' && value !== undefined) {
            return transformFunction(value);
        }
        return value;
    }
    prefixedKey(key) {
        const prefixed = this.info.prefix ? `${this.info.prefix}${key}` : key;
        return prefixed;
    }
    processOptionalKeys(environment) {
        (0, utils_1.debug)('Processing optional keys');
        const optionalValues = {};
        for (const key of this.info.optionalKeys) {
            const envKey = this.prefixedKey(key);
            const envValue = environment[envKey];
            const transformedValue = this.applyTransform(key, envValue);
            optionalValues[key] = transformedValue;
            (0, utils_1.debug)('Resolved optional key', [key], 'value', [envValue], 'transformed', [transformedValue]);
        }
        (0, utils_1.debug)('Final optional values', [optionalValues]);
        return optionalValues;
    }
    processRequiredKeys(environment) {
        (0, utils_1.debug)('Processing required keys');
        const result = { errors: [], requiredValues: {} };
        for (const key of this.info.requiredKeys) {
            const envKey = this.prefixedKey(key);
            const envValue = environment[envKey];
            const defaultValue = this.info.defaultValues[key];
            const finalValue = envValue ?? defaultValue;
            if (finalValue !== undefined) {
                result.requiredValues[key] = this.applyTransform(key, finalValue);
                (0, utils_1.debug)('Resolved required key', [key], 'value', [finalValue]);
            }
            else {
                result.errors.push(key);
                (0, utils_1.debug)('Missing required key', [key]);
            }
        }
        (0, utils_1.debug)('Final required values', [result.requiredValues], 'errors', [result.errors]);
        return result;
    }
}
exports.EnvironmentBuilder = EnvironmentBuilder;
//# sourceMappingURL=environment.js.map