@efebia/env-loader 0.0.1

package/lib/client.d.ts

@@ -0,0 +1,14 @@
+import { EnvSchema, EnvValues } from './utils';
+export type EnvironmentClientOptions = {
+    storage: object;
+    keyLoaders: (() => Record<string, unknown> | Promise<Record<string, unknown>>)[];
+};
+export default class EnvironmentClient {
+    storage: EnvironmentClientOptions['storage'];
+    keyLoaders: EnvironmentClientOptions['keyLoaders'];
+    constructor(opts?: Partial<EnvironmentClientOptions>);
+    loadKeys(): Promise<void>;
+    setEnv(key: string, value: unknown): void;
+    getEnv<Key extends keyof EnvSchema, Keys extends Key[] = Key[]>(...listKeys: Keys): EnvValues<Keys>;
+    getKey<Key extends keyof EnvSchema>(key: Key): any;
+}

package/lib/client.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("./utils");
+class EnvironmentClient {
+    constructor(opts) {
+        const options = Object.assign({
+            storage: {},
+            keyLoaders: []
+        }, opts);
+        this.storage = options.storage;
+        this.keyLoaders = options.keyLoaders;
+    }
+    async loadKeys() {
+        const loadedKeys = await Promise.all(this.keyLoaders.map(keyLoader => keyLoader()));
+        const keysObject = loadedKeys.reduce((acc, curr) => (Object.assign(Object.assign({}, acc), curr)), {});
+        Object.entries(keysObject).forEach(([key, value]) => this.setEnv(key, value));
+    }
+    setEnv(key, value) {
+        this.storage[key] = value;
+    }
+    getEnv(...listKeys) {
+        let values = {};
+        for (const key of listKeys) {
+            const value = this.getKey(key);
+            values = Object.assign(Object.assign({}, values), { [key]: value, [(0, utils_1.convertToCamelCase)(key)]: value });
+        }
+        return values;
+    }
+    ;
+    getKey(key) {
+        if (!Object.hasOwn(this.storage, key))
+            throw Error(`@efebia/env-loader: Missing environment key ${key}`);
+        return this.storage[key];
+    }
+}
+exports.default = EnvironmentClient;

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import EnvironmentClient from "./client";
+import ProcessEnvStorageEnvironmentClient from "./processEnv";
+import { EnvSchema } from "./utils";
+declare const jsonProcessEnvKeyLoader: (key: string) => () => any;
+declare const yamlFileKeyLoader: (filePath: string) => () => unknown;
+export { EnvironmentClient, ProcessEnvStorageEnvironmentClient, EnvSchema, jsonProcessEnvKeyLoader, yamlFileKeyLoader };

package/lib/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yamlFileKeyLoader = exports.jsonProcessEnvKeyLoader = exports.ProcessEnvStorageEnvironmentClient = exports.EnvironmentClient = void 0;
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const client_1 = __importDefault(require("./client"));
+exports.EnvironmentClient = client_1.default;
+const processEnv_1 = __importDefault(require("./processEnv"));
+exports.ProcessEnvStorageEnvironmentClient = processEnv_1.default;
+const jsonProcessEnvKeyLoader = (key) => () => JSON.parse(process.env[key]);
+exports.jsonProcessEnvKeyLoader = jsonProcessEnvKeyLoader;
+const yamlFileKeyLoader = (filePath) => () => js_yaml_1.default.load(filePath);
+exports.yamlFileKeyLoader = yamlFileKeyLoader;

package/lib/processEnv.d.ts

@@ -0,0 +1,7 @@
+import EnvironmentClient, { EnvironmentClientOptions } from "./client";
+import { EnvSchema } from "./utils";
+export default class ProcessEnvStorageEnvironmentClient extends EnvironmentClient {
+    constructor(opts?: Partial<Omit<EnvironmentClientOptions, 'storage'>>);
+    setEnv(key: string, value: unknown): void;
+    getKey<Key extends keyof EnvSchema>(key: Key): any;
+}

package/lib/processEnv.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const client_1 = __importDefault(require("./client"));
+const tryParseJSON = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const tryParseInt = (value) => {
+    if (/^\d+$/.test(value))
+        return parseInt(value);
+    return null;
+};
+const tryParseFloat = (value) => {
+    try {
+        return parseFloat(value);
+    }
+    catch (_a) {
+        return null;
+    }
+};
+const tryParseBoolean = (value) => {
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return null;
+};
+const tryParseDate = (value) => {
+    const parsed = Date.parse(value);
+    if (isNaN(parsed))
+        return null;
+    return new Date(parsed);
+};
+const parseValue = (value) => {
+    let parsed = tryParseJSON(value);
+    if (parsed !== null)
+        return parsed;
+    parsed = tryParseInt(value);
+    if (parsed !== null)
+        return parsed;
+    parsed = tryParseFloat(value);
+    if (parsed !== null)
+        return parsed;
+    parsed = tryParseBoolean(value);
+    if (parsed !== null)
+        return parsed;
+    parsed = tryParseDate(value);
+    if (parsed !== null)
+        return parsed;
+    return value;
+};
+class ProcessEnvStorageEnvironmentClient extends client_1.default {
+    constructor(opts) {
+        super(Object.assign(Object.assign({}, opts), { storage: process.env }));
+    }
+    setEnv(key, value) {
+        this.storage[key] = typeof value === 'object' ? JSON.stringify(value) : value;
+    }
+    getKey(key) {
+        const anyStorage = this.storage;
+        if (!Object.hasOwn(this.storage, key))
+            throw new Error(`@efebia/env-loader: Missing environment key ${key}`);
+        if (anyStorage[key].trim() === '')
+            throw new Error(`@efebia/env-loader: ${key} is empty`);
+        return parseValue(anyStorage[key]);
+    }
+}
+exports.default = ProcessEnvStorageEnvironmentClient;

package/lib/utils.d.ts

@@ -0,0 +1,16 @@
+export type ConvertToCamelCase<Key extends PropertyKey> = Key extends `${infer TFirst}_${infer TSecond}` ? `${TFirst}${Capitalize<ConvertToCamelCase<TSecond>>}` : Key;
+export declare const convertToCamelCase: (key: string) => string;
+export type EnvValues<TKeys extends [...(keyof EnvSchema)[]]> = TKeys extends [
+    infer TFirst,
+    ...infer TRest
+] ? TRest["length"] extends 0 ? TFirst extends keyof EnvSchema ? EnvSchema[TFirst] : never : {
+    [key in TRest[number] as key extends keyof EnvSchema ? key : never]: key extends keyof EnvSchema ? EnvSchema[key] : never;
+} & {
+    [key in TRest[number] as key extends `${string}_${string}` ? ConvertToCamelCase<key> : never]: key extends keyof EnvSchema ? EnvSchema[key] : never;
+} & {
+    [key in TFirst as key extends string ? ConvertToCamelCase<key> : never]: key extends keyof EnvSchema ? EnvSchema[key] : never;
+} : never;
+export interface EnvSchema {
+    test_key_1: string;
+    test_key_2: string;
+}

package/lib/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToCamelCase = void 0;
+const convertToCamelCase = (key) => {
+    return key
+        .toLowerCase()
+        .replace(/([_][a-z])/g, (group) => group.toUpperCase().replace("_", ""));
+};
+exports.convertToCamelCase = convertToCamelCase;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@efebia/env-loader",
+  "version": "0.0.1",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/jest": "^29.2.5",
+    "@types/js-yaml": "^4.0.5",
+    "@types/node": "^18.11.18",
+    "jest": "^29.3.1",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "js-yaml": "^4.1.0"
+  },
+  "files": [
+    "/lib"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "main": "./lib"
+}