@shushed/helpers 0.0.23 → 0.0.25

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 {
@@ -28832,6 +28833,152 @@ declare const validateGoogleAuth: (opts: Opts & {
     serviceAccount?: string | null;
 }, headers: Record<string, string>, firestore: Firestore) => Promise<void>;
 
+type TriggerOnExecuteOptions = {
+    req: {
+        status?: number;
+        body?: string;
+        throw: (status: number, body: string) => void;
+    };
+    request: {
+        headers: Record<string, string>;
+        method: 'POST' | 'GET' | 'PUT' | 'PATCH';
+        body: undefined;
+        path: string;
+        query: Record<string, string>;
+        host: string;
+        hostname: string;
+        originalUrl: string;
+        ip: string;
+        ips: [];
+        querystring: string;
+        subdomains: Array<string>;
+        secure: boolean;
+        protocol: 'http' | 'https';
+        params: undefined;
+    };
+    nodeReq: Request;
+    state: Record<string, string>;
+    root: {
+        state: Record<string, string>;
+    };
+    workflowExecutionId: string;
+    logging: {
+        log: (...x: Array<any>) => void;
+        warn: (...x: Array<any>) => void;
+        error: (...x: Array<any>) => void;
+    };
+    terminate: (status: number, message: string) => void;
+    env: {
+        set: (args: {
+            name: string;
+            value: string;
+        }[], level: 'workflow' | 'project') => Promise<void>;
+        get: (name: string, level: 'workflow' | 'project') => string | null;
+        triggerEnv: any;
+        workflowId: string;
+    };
+    auth: {
+        getToken: (forceRefresh: boolean) => any;
+        getKey: (options: {
+            ignoreMissingKey?: boolean;
+        }) => any;
+    };
+    getBuildShipFile: (x: any) => any;
+    trigger: {
+        meta: {
+            fileUploadLimit: boolean;
+            name: string;
+            description: string;
+            id: string;
+            payloadLimit: boolean;
+            icon: {
+                type: 'SVG';
+            };
+        };
+        script: string;
+        defaultValues: {
+            path: string;
+            inputs: string;
+        };
+        lifeCycleFunctions: Array<'onExecution' | 'onCreate' | 'onResponse' | 'onUpdate' | 'getData'>;
+        id: string;
+        _libRef: {
+            integrity: string;
+            libNodeRefId: string;
+            libType: string;
+            isDirty: boolean;
+            version: string;
+            src: string;
+        };
+        label: string;
+        description: string;
+        envs: Record<string, any>;
+        env: any;
+    };
+    workflow: {
+        id: string;
+    };
+};
+type TriggerOnCreateOptions = {
+    runtimeUrl: string;
+    workflowId: string;
+    auth: {
+        getToken: (forceRefresh: boolean) => any;
+        getKey: (options: {
+            ignoreMissingKey?: boolean;
+        }) => any;
+    };
+    trigger: {
+        meta: {
+            fileUploadLimit: boolean;
+            name: string;
+            description: string;
+            id: string;
+            payloadLimit: boolean;
+            icon: {
+                type: 'SVG';
+            };
+        };
+        script: string;
+        response: any;
+        dependencies: Record<string, string>;
+        type: string;
+        data: any;
+        config: any;
+        usage: string;
+        defaultValues: {
+            path: string;
+            inputs: string;
+        };
+        lifeCycleFunctions: Array<'onExecution' | 'onCreate' | 'onResponse' | 'onUpdate' | 'getData'>;
+        id: string;
+        _libRef: {
+            integrity: string;
+            libNodeRefId: string;
+            libType: string;
+            isDirty: boolean;
+            version: string;
+            src: string;
+        };
+        label: string;
+        description: string;
+        envs: Record<string, any>;
+        env: any;
+    };
+    workflow: {
+        id: string;
+    };
+    env: {
+        set: (args: {
+            name: string;
+            value: string;
+        }[], level: 'workflow' | 'project') => Promise<void>;
+        get: (name: string, level: 'workflow' | 'project') => string | null;
+        triggerEnv: any;
+        workflowId: string;
+    };
+};
+
 type index_EnvEngine = EnvEngine;
 declare const index_EnvEngine: typeof EnvEngine;
 type index_JWKSHelper = JWKSHelper;
@@ -28844,6 +28991,8 @@ type index_SchedulerHelper = SchedulerHelper;
 declare const index_SchedulerHelper: typeof SchedulerHelper;
 type index_Secrets = Secrets;
 declare const index_Secrets: typeof Secrets;
+type index_TriggerOnCreateOptions = TriggerOnCreateOptions;
+type index_TriggerOnExecuteOptions = TriggerOnExecuteOptions;
 declare const index_isCronMessage: typeof isCronMessage;
 declare const index_isPubSubRequest: typeof isPubSubRequest;
 declare const index_sanitize: typeof sanitize;
@@ -28851,7 +29000,7 @@ declare const index_sanitizeToString: typeof sanitizeToString;
 declare const index_validate: typeof validate;
 declare const index_validateGoogleAuth: typeof validateGoogleAuth;
 declare namespace index {
-  export { index_EnvEngine as EnvEngine, index_JWKSHelper as JWKSHelper, index_PubSubHelper as PubSubHelper, index_Runtime as Runtime, index_SchedulerHelper as SchedulerHelper, index_Secrets as Secrets, index_isCronMessage as isCronMessage, index_isPubSubRequest as isPubSubRequest, index_sanitize as sanitize, index_sanitizeToString as sanitizeToString, index_validate as validate, index_validateGoogleAuth as validateGoogleAuth };
+  export { index_EnvEngine as EnvEngine, index_JWKSHelper as JWKSHelper, index_PubSubHelper as PubSubHelper, index_Runtime as Runtime, index_SchedulerHelper as SchedulerHelper, index_Secrets as Secrets, type index_TriggerOnCreateOptions as TriggerOnCreateOptions, type index_TriggerOnExecuteOptions as TriggerOnExecuteOptions, index_isCronMessage as isCronMessage, index_isPubSubRequest as isPubSubRequest, index_sanitize as sanitize, index_sanitizeToString as sanitizeToString, index_validate as validate, index_validateGoogleAuth as validateGoogleAuth };
 }
 
 export { index as lib, index$9 as schema, index$1 as types };

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.25",
   "author": "",
   "license": "UNLICENSED",
   "description": "",