@snow-tzu/type-config/dist/placeholder-resolver.js

Core configuration management system with Spring Boot-like features

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.PlaceholderResolver = void 0;
class PlaceholderResolver {
    constructor() {
        this.placeholderPattern = /\$\{([^}:]+)(?::([^}]*))?\}/g;
        this.escapedPattern = /\\\$\{([^}]+)\}/g;
    }
    hasPlaceholder(value) {
        if (typeof value !== 'string') {
            return false;
        }
        this.placeholderPattern.lastIndex = 0;
        return this.placeholderPattern.test(value);
    }
    resolve(value, envProvider = (key) => process.env[key]) {
        if (typeof value !== 'string') {
            return value;
        }
        const escapedPlaceholders = [];
        const tempValue = value.replace(this.escapedPattern, (match, content) => {
            const placeholder = `__ESCAPED_${escapedPlaceholders.length}__`;
            escapedPlaceholders.push(`\${${content}}`);
            return placeholder;
        });
        let foundPlaceholder = false;
        let allResolved = true;
        this.placeholderPattern.lastIndex = 0;
        const resolved = tempValue.replace(this.placeholderPattern, (match, varName, fallback) => {
            foundPlaceholder = true;
            const envValue = envProvider(varName.trim());
            if (envValue !== undefined) {
                return envValue;
            }
            else if (fallback !== undefined) {
                return fallback;
            }
            else {
                allResolved = false;
                return match;
            }
        });
        if (foundPlaceholder && !allResolved) {
            return undefined;
        }
        let finalValue = resolved;
        escapedPlaceholders.forEach((escaped, index) => {
            finalValue = finalValue.replace(`__ESCAPED_${index}__`, escaped);
        });
        return finalValue;
    }
    resolveObject(config, envProvider = (key) => process.env[key]) {
        if (!config || typeof config !== 'object') {
            return config;
        }
        if (Array.isArray(config)) {
            return config.map((item) => {
                if (typeof item === 'string') {
                    return this.resolve(item, envProvider);
                }
                else if (typeof item === 'object' && item !== null) {
                    return this.resolveObject(item, envProvider);
                }
                return item;
            });
        }
        const resolved = {};
        for (const [key, value] of Object.entries(config)) {
            if (typeof value === 'string') {
                const resolvedValue = this.resolve(value, envProvider);
                if (resolvedValue !== undefined) {
                    resolved[key] = resolvedValue;
                }
            }
            else if (typeof value === 'object' && value !== null) {
                resolved[key] = this.resolveObject(value, envProvider);
            }
            else {
                resolved[key] = value;
            }
        }
        return resolved;
    }
}
exports.PlaceholderResolver = PlaceholderResolver;