refactor: code split and cleanup

Author: rohan-chaturvedi

src/index.ts

@@ -1,10 +1,4 @@
-import {
-  decryptEnvSecrets,
-  digest,
-  encryptEnvSecrets,
-  reconstructPrivateKey,
-  unwrapEnvKeys,
-} from "./utils/crypto";
+
 import axios from "axios";
 import {
   App,
@@ -21,8 +15,10 @@ import {
   normalizeKey,
   resolveSecretReferences,
   SecretFetcher,
-} from "./utils/secrets";
+} from "./utils/secretReferencing";
 import { LIB_VERSION } from "../version";
+import { reconstructPrivateKey, unwrapEnvKeys, digest, decryptEnvSecrets, encryptEnvSecrets } from "./utils/crypto";
+
 
 const DEFAULT_HOST = "https://console.phase.dev";
 
@@ -156,128 +152,82 @@ export default class Phase {
   async get(options: GetSecretOptions): Promise<Secret[]> {
     return new Promise<Secret[]>(async (resolve, reject) => {
       const cache = new Map<string, string>();
-
+  
       const app = this.apps.find((app) => app.id === options.appId);
       if (!app) {
-        reject("Invalid app id");
-        return;
+        return reject("Invalid app id");
       }
-
-      const env = app?.environments.find(
-        (env) => env.name.toLowerCase() === options.envName.toLowerCase()
+  
+      const env = app.environments.find(
+        (e) => e.name.toLowerCase() === options.envName.toLowerCase()
       );
       if (!env) {
-        reject(`Invalid environment name: ${options.envName}`);
-        return;
+        return reject(`Invalid environment name: ${options.envName}`);
       }
-
+  
       try {
         const queryHeaders = {
           environment: env.id,
           path: options.path || "/",
-          keyDigest: null,
+          keyDigest: options.key
+            ? await digest(options.key.toUpperCase(), env.salt)
+            : null,
         };
-
-        if (options.key) {
-          const keyDigest = await digest(options.key.toUpperCase(), env.salt);
-          queryHeaders.keyDigest = keyDigest;
-        }
-
-        const res = await axios({
-          url: `${this.host}/service/secrets/`,
-          method: "get",
-          headers: {
-            ...queryHeaders,
-            ...this.getAuthHeaders(),
-          },
+  
+        const res = await axios.get(`${this.host}/service/secrets/`, {
+          headers: { ...queryHeaders, ...this.getAuthHeaders() },
         });
-
-        let secretsToDecrypt = res.data
-          .filter((secret: Secret) =>
-            options.path ? secret.path === options.path : true
-          )
-          .filter((secret: Secret) =>
-            options.tags
-              ? secret.tags.some((tag) => options.tags?.includes(tag))
-              : true
-          );
-
-        // Decrypt fetched secrets
+  
+        const secretsToDecrypt = res.data.filter(
+          (secret: Secret) =>
+            (!options.path || secret.path === options.path) &&
+            (!options.tags || secret.tags.some((tag) => options.tags?.includes(tag)))
+        );
+  
         const secrets = await decryptEnvSecrets(secretsToDecrypt, env.keypair);
-
+  
+        // Create lookup map
         const secretLookup = new Map<string, Secret>(
           secrets.map((s) => [normalizeKey(env.name, s.path, s.key), s])
         );
-
-        // 🛠 Fetch local and cross-environment secrets as needed
-        const fetcher: SecretFetcher = async (
-          envName: string,
-          path: string,
-          key: string
-        ) => {
+  
+        // Fetcher for resolving references
+        const fetcher: SecretFetcher = async (envName, path, key) => {
           const cacheKey = normalizeKey(envName, path, key);
-
+  
           if (cache.has(cacheKey)) {
-            return {
-              id: "",
-              key,
-              value: cache.get(cacheKey)!,
-              comment: "",
-              environment: envName,
-              folder: undefined,
-              path,
-              tags: [],
-              keyDigest: "",
-              createdAt: undefined,
-              updatedAt: new Date().toISOString(),
-              version: 1,
-            };
+            return { id: "", key, value: cache.get(cacheKey)!, comment: "", environment: envName, folder: undefined, path, tags: [], keyDigest: "", createdAt: undefined, updatedAt: new Date().toISOString(), version: 1 };
           }
-
+  
           let secret = secretLookup.get(cacheKey);
-
           if (!secret) {
-            // 🔄 Fetch cross-environment secret dynamically
-            const crossEnvSecrets = await this.get({
-              ...options,
-              envName,
-              path,
-              tags: undefined,
-            });
-
+            const crossEnvSecrets = await this.get({ ...options, envName, path, tags: undefined });
             secret = crossEnvSecrets.find((s) => s.key === key);
-            if (!secret)
-              throw new Error(`Missing secret: ${envName}:${path}:${key}`);
-
-            // Store for future lookups
+            if (!secret) throw new Error(`Missing secret: ${envName}:${path}:${key}`);
+  
             secretLookup.set(cacheKey, secret);
           }
-
+  
           cache.set(cacheKey, secret.value);
           return secret;
         };
-
-        // Resolve references in secret values
+  
+        // Resolve references
         const resolvedSecrets = await Promise.all(
           secrets.map(async (secret) => ({
             ...secret,
-            value: await resolveSecretReferences(
-              secret.value,
-              options.envName,
-              options.path || "/",
-              fetcher,
-              cache
-            ),
+            value: await resolveSecretReferences(secret.value, options.envName, options.path || "/", fetcher, cache),
           }))
         );
-
+  
         resolve(resolvedSecrets);
       } catch (err) {
-        console.log(`Error fetching secrets: ${err}`);
+        console.error(`Error fetching secrets: ${err}`);
         reject(err);
       }
     });
   }
+