@shushed/helpers 0.0.23 → 0.0.24

package/dist/index.d.ts

@@ -28715,19 +28715,20 @@ declare class Runtime {
     constructor(opts: Opts);
 }
 
+type Level = 'env' | 'workflow' | 'trigger';
 declare class EnvEngine extends Runtime {
-    docRef: DocumentReference;
+    docRef: Record<Level, DocumentReference>;
     private store;
     constructor(opts: Opts, firestore: Firestore);
     set(envs: Array<{
         name: string;
         value: string;
-    }>): Promise<undefined>;
+    }>, level?: Level, encryptWithValue?: string): Promise<undefined>;
     private initializeIfNeeded;
-    get<T extends ReadonlyArray<string>>(keys: T): Promise<{
+    get<T extends ReadonlyArray<string>>(keys: T, level?: Level, decryptWithValue?: string): Promise<{
         [K in T[number]]: string;
     }>;
-    get(key: string): Promise<string>;
+    get(key: string, level?: Level, decryptWithValue?: string): Promise<string>;
 }
 
 declare class PubSubHelper extends Runtime {

package/dist/index.js

@@ -346,6 +346,9 @@ var sanitize = new import_deep_redact.DeepRedact({
   replaceStringByLength: true
 });
 
+// src-public/env.ts
+var crypto = __toESM(require("crypto"));
+
 // src-public/runtime.ts
 var DEFAULT_BRANCH = "migratedprod";
 var Runtime = class {
@@ -373,20 +376,39 @@ var Runtime = class {
 // src-public/env.ts
 var EnvEngine = class extends Runtime {
   docRef;
-  store = {};
+  store;
   constructor(opts, firestore) {
     super(opts);
-    this.docRef = firestore?.doc(`${this.workflowId}/${this.triggerId}/${this.envName}`);
+    this.docRef = {
+      env: firestore?.doc(`0/0/${this.envName}`),
+      workflow: firestore?.doc(`${this.workflowId}/0/${this.envName}`),
+      trigger: firestore?.doc(`${this.workflowId}/${this.triggerId}/${this.envName}`)
+    };
+    this.store = {
+      env: null,
+      workflow: null,
+      trigger: null
+    };
   }
-  async set(envs) {
-    await this.initializeIfNeeded();
+  async set(envs, level = "trigger", encryptWithValue) {
+    await this.initializeIfNeeded(level);
+    let aes = null;
+    if (encryptWithValue) {
+      aes = new AES256GCM(Buffer.from(encryptWithValue, "utf8"));
+    }
     const obj = envs.filter((env) => env.name).reduce(
-      (prev, curr) => ({ ...prev, [curr.name]: curr.value }),
+      (prev, curr) => {
+        let value = curr.value;
+        if (aes) {
+          value = aes.encrypt(curr.value);
+        }
+        return { ...prev, [curr.name]: value };
+      },
       {}
     );
-    if (this.docRef) {
+    if (this.docRef[level]) {
       try {
-        await this.docRef.set(
+        await this.docRef[level].set(
           obj,
           { merge: true }
         );
@@ -394,36 +416,104 @@ var EnvEngine = class extends Runtime {
         throw new Error(`Failed to set the ${envs.map((x) => x.name).join(", ")}. Error: ${err.message}`);
       }
     }
-    Object.assign(this.store, obj);
+    Object.assign(this.store[level], obj);
     return void 0;
   }
-  async initializeIfNeeded() {
-    if (!this.store) {
-      if (this.docRef) {
-        const docSnapshot = await this.docRef.get();
+  async initializeIfNeeded(level = "trigger") {
+    if (!this.store[level]) {
+      if (this.docRef[level]) {
+        const docSnapshot = await this.docRef[level].get();
         const data = docSnapshot.data();
-        this.store = {};
+        this.store[level] = {};
         for (const k in data) {
           const v = data[k];
-          this.store[k] = typeof v !== "string" ? `${v === null || typeof v === "undefined" ? "" : `${v}`}` : v;
+          this.store[level][k] = typeof v !== "string" ? `${v === null || typeof v === "undefined" ? "" : `${v}`}` : v;
         }
       } else {
-        this.store = {};
+        this.store[level] = {};
       }
     }
   }
-  async get(keys) {
-    await this.initializeIfNeeded();
+  async get(keys, level = "trigger", decryptWithValue) {
+    await this.initializeIfNeeded(level);
+    let aes = null;
+    if (decryptWithValue) {
+      aes = new AES256GCM(Buffer.from(decryptWithValue, "utf8"));
+    }
     if (typeof keys === "string") {
-      return this.store?.[keys] || "";
+      try {
+        if (aes) {
+          return aes.decrypt(this.store[level]?.[keys] || "");
+        }
+      } catch (err) {
+        return "";
+      }
+      return this.store[level]?.[keys] || "";
     }
     return keys.reduce((acc, k) => {
-      const v = this.store?.[k];
-      acc[k] = typeof v !== "string" ? `${v === null || typeof v === "undefined" ? "" : `${v}`}` : v;
+      const v = this.store[level]?.[k];
+      if (aes && typeof v === "string") {
+        try {
+          acc[k] = aes.decrypt(v);
+        } catch (err) {
+          acc[k] = "";
+        }
+      } else {
+        acc[k] = typeof v !== "string" ? `${v === null || typeof v === "undefined" ? "" : `${v}`}` : v;
+      }
       return acc;
     }, {});
   }
 };
+var AES256GCM = class {
+  normalizedKey;
+  constructor(key) {
+    this.normalizedKey = crypto.createHash("sha256").update(key).digest().slice(0, 32);
+  }
+  // Pad payload to a multiple of 8 bytes
+  pad(payload) {
+    const padLength = 8 - payload.length % 8;
+    return Buffer.concat([payload, Buffer.alloc(padLength, padLength)]);
+  }
+  getNormalizedKey() {
+    return this.getNormalizedKey;
+  }
+  // Wrapping function
+  encrypt(payload) {
+    const normalizedWrappingKey = this.normalizedKey;
+    const paddedPayload = this.pad(Buffer.from(payload));
+    const iv = crypto.randomBytes(12);
+    const cipher = crypto.createCipheriv(
+      "aes-256-gcm",
+      normalizedWrappingKey,
+      iv
+    );
+    const encryptedPayload = Buffer.concat([
+      cipher.update(paddedPayload),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return encryptedPayload.toString("base64") + "." + iv.toString("base64") + "." + authTag.toString("base64");
+  }
+  decrypt(payload) {
+    const [encryptedKey64, iv64, authTag64] = payload.split(".");
+    const encryptedPayload = Buffer.from(encryptedKey64, "base64");
+    const iv = Buffer.from(iv64, "base64");
+    const authTag = Buffer.from(authTag64, "base64");
+    const decipher = crypto.createDecipheriv(
+      "aes-256-gcm",
+      this.normalizedKey,
+      iv
+    );
+    decipher.setAuthTag(authTag);
+    const paddedKey = Buffer.concat([
+      decipher.update(encryptedPayload),
+      decipher.final()
+    ]);
+    const padLength = paddedKey[paddedKey.length - 1];
+    return paddedKey.slice(0, -padLength).toString();
+  }
+};
 var env_default = EnvEngine;
 
 // src-public/pubsub.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shushed/helpers",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "author": "",
   "license": "UNLICENSED",
   "description": "",