asm-env/dist/index.js

Package for load enviroment variables from .env.json file or AWS Secret manager

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.AsmEnv = exports.EnvTypes = void 0;
const path = require("path");
const fs = require("fs");
var EnvTypes;
(function (EnvTypes) {
    EnvTypes["dotenv"] = "dotenv";
    EnvTypes["asm"] = "asm";
})(EnvTypes = exports.EnvTypes || (exports.EnvTypes = {}));
class AsmEnv {
    constructor(env, type) {
        if (!EnvTypes[type] === undefined)
            throw new Error("Invalid Type");
        this.ENV = { env, type: EnvTypes[type] };
    }
    load(options) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.ENV.type == EnvTypes.dotenv.toString()) {
                this.dotenvJSON(options);
            }
            else {
                if (options.client && options.secretName) {
                    let { secret, decodedBinarySecret } = yield this.getSecretValue(options.client, options.secretName);
                    console.log({ secret, decodedBinarySecret });
                    this.putEnv(secret);
                }
                else {
                    console.error("ASM-ENV: client or secretName undefined");
                }
            }
        });
    }
    dotenvJSON(options) {
        const jsonFile = (options && options.path) || ".env.json";
        let jsonString;
        try {
            jsonString = fs.readFileSync(path.resolve(process.cwd(), jsonFile), {
                encoding: "utf8"
            });
            this.putEnv(jsonString);
        }
        catch (err) {
            console.error("ASM-ENV: Error while reading env file");
        }
    }
    putEnv(jsonString) {
        try {
            const envConfig = JSON.parse(jsonString);
            for (const key in envConfig) {
                process.env[key] = process.env[key] || envConfig[key];
            }
        }
        catch (err) {
            console.error(err);
        }
    }
    getSecretValue(client, secretName) {
        return __awaiter(this, void 0, void 0, function* () {
            let secret, decodedBinarySecret;
            return new Promise((resolve, reject) => {
                client.getSecretValue({ SecretId: secretName }, function (err, data) {
                    if (err) {
                        console.log("AWS ERROR:" + err.code, err.message);
                        reject(err);
                    }
                    else {
                        // Decrypts secret using the associated KMS CMK.
                        // Depending on whether the secret is a string or binary, one of these fields will be populated.
                        if ('SecretString' in data) {
                            secret = data.SecretString;
                        }
                        else {
                            let buff = Buffer.from(data.SecretBinary, 'base64');
                            decodedBinarySecret = buff.toString('ascii');
                        }
                    }
                    resolve({ secret, decodedBinarySecret });
                });
            });
        });
    }
}
exports.AsmEnv = AsmEnv;