@efebia/env-loader 0.0.1 → 0.0.2

package/lib/client.d.ts

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

package/lib/client.js

@@ -5,16 +5,35 @@ class EnvironmentClient {
     constructor(opts) {
         const options = Object.assign({
             storage: {},
-            keyLoaders: []
+            syncKeyLoaders: [],
+            asyncKeyLoaders: [],
+            loadSyncKeysAtStartup: true
         }, opts);
         this.storage = options.storage;
-        this.keyLoaders = options.keyLoaders;
+        this.syncKeyLoaders = options.syncKeyLoaders;
+        this.asyncKeyLoaders = options.asyncKeyLoaders;
+        if (options.loadSyncKeysAtStartup) {
+            this.loadSyncKeys();
+        }
     }
-    async loadKeys() {
-        const loadedKeys = await Promise.all(this.keyLoaders.map(keyLoader => keyLoader()));
+    async loadAsyncKeys() {
+        if (!this.asyncKeyLoaders)
+            return;
+        const loadedKeys = await Promise.all(this.asyncKeyLoaders.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));
     }
+    loadSyncKeys() {
+        if (!this.syncKeyLoaders)
+            return;
+        const loadedKeys = this.syncKeyLoaders.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));
+    }
+    async loadKeys() {
+        await this.loadAsyncKeys();
+        this.loadSyncKeys();
+    }
     setEnv(key, value) {
         this.storage[key] = value;
     }
@@ -27,6 +46,18 @@ class EnvironmentClient {
         return values;
     }
     ;
+    getOptionalEnv(...listKeys) {
+        let values = {};
+        for (const key of listKeys) {
+            try {
+                const value = this.getKey(key);
+                values = Object.assign(Object.assign({}, values), { [key]: value, [(0, utils_1.convertToCamelCase)(key)]: value });
+            }
+            catch (_a) { }
+        }
+        return values;
+    }
+    ;
     getKey(key) {
         if (!Object.hasOwn(this.storage, key))
             throw Error(`@efebia/env-loader: Missing environment key ${key}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efebia/env-loader",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "MIT",
   "devDependencies": {
     "@types/jest": "^29.2.5",