@dotenvx/primitives 0.11.0 → 1.0.1

package/dist/index.cjs

@@ -6198,7 +6198,22 @@ var require_keyring = __commonJS({
     var fs = require("fs");
     var derive2 = require_derive();
     var scan2 = require_scan();
-    function keysFromFile(filepath = ".env.keys") {
+    async function keysFromFile(filepath = ".env.keys") {
+      try {
+        const src = await fs.promises.readFile(filepath, "utf8");
+        const { parsed } = scan2(src);
+        const result = [];
+        for (const name in parsed) {
+          if (name.startsWith("DOTENV_PRIVATE_KEY")) {
+            result.push(parsed[name][parsed[name].length - 1]);
+          }
+        }
+        return result;
+      } catch (_e) {
+        return [];
+      }
+    }
+    function keysFromFileSync(filepath = ".env.keys") {
       try {
         const src = fs.readFileSync(filepath, "utf8");
         const { parsed } = scan2(src);
@@ -6213,13 +6228,47 @@ var require_keyring = __commonJS({
         return [];
       }
     }
-    function keyring2(options = {}) {
+    async function keyring2(options = {}) {
+      const ring = options.ring || {};
+      const provider = options.provider;
+      const processEnv = options.processEnv || process.env;
+      const keysFilepaths = Array.isArray(options.fk) ? options.fk : [options.fk || ".env.keys"];
+      const privateKeyValues = [];
+      for (const filepath of keysFilepaths) {
+        privateKeyValues.push(...await keysFromFile(filepath));
+      }
+      for (const name in processEnv) {
+        if (name.startsWith("DOTENV_PRIVATE_KEY")) {
+          privateKeyValues.push(processEnv[name]);
+        }
+      }
+      for (const privateKeyHex of privateKeyValues) {
+        try {
+          const publicKeyHex = derive2(privateKeyHex);
+          ring[publicKeyHex] = privateKeyHex;
+        } catch (_e) {
+        }
+      }
+      if (typeof provider === "function") {
+        for (const publicKeyHex in ring) {
+          if (ring[publicKeyHex]) {
+            continue;
+          }
+          const privateKeyHex = await provider(publicKeyHex);
+          if (privateKeyHex) {
+            ring[publicKeyHex] = privateKeyHex;
+          }
+        }
+      }
+      return ring;
+    }
+    function keyringSync2(options = {}) {
       const ring = options.ring || {};
       const provider = options.provider;
       const processEnv = options.processEnv || process.env;
       const keysFilepaths = Array.isArray(options.fk) ? options.fk : [options.fk || ".env.keys"];
       const privateKeyValues = keysFilepaths.reduce((acc, filepath) => {
-        return acc.concat(keysFromFile(filepath));
+        return acc.concat(keysFromFileSync(filepath));
       }, []);
       for (const name in processEnv) {
         if (name.startsWith("DOTENV_PRIVATE_KEY")) {
@@ -6247,6 +6296,7 @@ var require_keyring = __commonJS({
       return ring;
     }
     module2.exports = keyring2;
+    module2.exports.sync = keyringSync2;
   }
 });
 
@@ -6273,6 +6323,7 @@ var require_parse = __commonJS({
   "src/parse.js"(exports2, module2) {
     var decrypt2 = require_decrypt();
     var keyring2 = require_keyring();
+    var keyringSync2 = require_keyring().sync;
     var encrypted2 = require_encrypted();
     var evaluate2 = require_evaluate();
     var expand2 = require_expand();
@@ -6305,23 +6356,41 @@ var require_parse = __commonJS({
       }
       return value;
     }
-    function parse2(src, options = {}) {
+    async function parse2(src, options = {}) {
+      const { overload, processEnv, fk, provider, publicKeyHexes, ring: initialRing } = keyringOptions(src, options);
+      const ring = await keyring2({ processEnv, ring: initialRing, fk, provider });
+      return parseWithRing(src, { overload, processEnv, ring, publicKeyHexes });
+    }
+    function parseSync2(src, options = {}) {
+      const { overload, processEnv, fk, provider, publicKeyHexes, ring: initialRing } = keyringOptions(src, options);
+      const ring = keyringSync2({ processEnv, ring: initialRing, fk, provider });
+      return parseWithRing(src, { overload, processEnv, ring, publicKeyHexes });
+    }
+    function keyringOptions(src, options = {}) {
       const overload = options.overload;
       const processEnv = options.processEnv || process.env;
       const fk = options.fk;
       const provider = options.provider;
       const publicKeyHexes = publickeys2(src);
-      let ring = {};
+      const ring = {};
       for (const publicKeyHex of publicKeyHexes) {
         ring[publicKeyHex] = "";
       }
-      ring = keyring2({ processEnv, ring, fk, provider });
+      return { overload, processEnv, fk, provider, publicKeyHexes, ring };
+    }
+    function parseWithRing(src, options = {}) {
+      const overload = options.overload;
+      const processEnv = options.processEnv || process.env;
+      const ring = options.ring || {};
+      const publicKeyHexes = options.publicKeyHexes || [];
       function inProcessEnv(name) {
         return Object.prototype.hasOwnProperty.call(processEnv, name);
       }
       const runningParsed = {};
       const literals = {};
       const parsed = {};
+      const injected = {};
+      const existed = {};
       scan2(src, ({ name, value, quote }) => {
         let parsedValue = value;
         if (!overload && inProcessEnv(name)) {
@@ -6341,7 +6410,7 @@ var require_parse = __commonJS({
           }
         }
         if (!encryptedPrefixed && !evaled && quote !== "'" && (!processEnv[name] || overload)) {
-          parsedValue = resolveEscapeSequences(expand2(parsedValue, { processEnv, runningParsed, literals }));
+          parsedValue = resolveEscapeSequences(expand2(parsedValue, { overload, processEnv, runningParsed, literals }));
         }
         if (quote === "'") {
           literals[name] = parsedValue;
@@ -6349,15 +6418,20 @@ var require_parse = __commonJS({
         runningParsed[name] = parsedValue;
         parsed[name] = parsedValue;
         if (Object.prototype.hasOwnProperty.call(processEnv, name) && !overload) {
+          existed[name] = processEnv[name];
         } else {
+          injected[name] = parsed[name];
         }
         return parsedValue;
       });
       return {
-        parsed
+        parsed,
+        injected,
+        existed
       };
     }
     module2.exports = parse2;
+    module2.exports.sync = parseSync2;
   }
 });
 
@@ -6393,7 +6467,9 @@ var evaluate = require_evaluate();
 var expand = require_expand();
 var keypair = require_keypair();
 var keyring = require_keyring();
+var keyringSync = require_keyring().sync;
 var parse = require_parse();
+var parseSync = require_parse().sync;
 var publickeys = require_publickeys();
 var scan = require_scan();
 var sealed = require_sealed();
@@ -6406,7 +6482,9 @@ module.exports = {
   expand,
   keypair,
   keyring,
+  keyringSync,
   parse,
+  parseSync,
   publickeys,
   scan,
   sealed

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.11.0",
+  "version": "1.0.1",
   "name": "@dotenvx/primitives",
   "description": "a secure dotenv–from the creator of `dotenv`",
   "author": "@motdotla",