varlock 0.1.6 → 0.2.1

package/dist/{chunk-OOBWRTIS.js → chunk-OKNWYS57.js}

@@ -1,13 +1,13 @@
 import { redactString } from './chunk-FGMXIEFA.js';
 import { __commonJS, __name, __toESM } from './chunk-XN24GZXQ.js';
 import process2 from 'process';
-import { exec } from 'child_process';
-import { promisify } from 'util';
 import fs, { accessSync } from 'fs';
 import fs2, { access } from 'fs/promises';
+import os from 'os';
 import path2 from 'path';
 import { ParsedEnvSpecFunctionCall, ParsedEnvSpecStaticValue, ParsedEnvSpecFunctionArgs, ParsedEnvSpecKeyValuePair, parseEnvSpecDotEnvFile } from '@env-spec/parser';
-import os from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
 import crypto from 'crypto';
 import https from 'https';
 import semver from 'semver';
@@ -1097,30 +1097,6 @@ async function tryCatch(tryFn, catchFn) {
   }
 }
 __name(tryCatch, "tryCatch");
-var asyncExec = promisify(exec);
-
-// ../utils/src/git-utils.ts
-async function checkIsFileGitIgnored(path4, warnIfNotGitRepo = false) {
-  try {
-    await asyncExec(`git check-ignore ${path4} -q`);
-    return true;
-  } catch (err) {
-    const stderr = err.stderr;
-    if (err.status === 127 || stderr.includes("not found") || stderr.includes("not recognized")) {
-      return void 0;
-    }
-    if (err.code === "ENOENT") return void 0;
-    if (stderr === "") return false;
-    if (stderr.includes("not a git repository")) {
-      if (warnIfNotGitRepo) {
-        console.log("\u{1F536} Your code is not currently in a git repository - run `git init` to initialize a new repo.");
-      }
-      return false;
-    }
-    throw err;
-  }
-}
-__name(checkIsFileGitIgnored, "checkIsFileGitIgnored");
 async function pathExists(p) {
   try {
     await access(p);
@@ -1713,6 +1689,10 @@ var builtInItemDecorators = [
   {
     name: "sensitive"
   },
+  {
+    name: "public",
+    incompatibleWith: ["sensitive"]
+  },
   {
     name: "type",
     useFnArgsResolver: true
@@ -2976,17 +2956,19 @@ var ConfigItem = class {
   async processSensitive() {
     const sensitiveFromDataType = this.dataType?.isSensitive;
     for (const def of this.defs) {
-      const sensitiveDec = def.itemDef.decorators?.find((d) => d.name === "sensitive");
+      const sensitiveDecs = def.itemDef.decorators?.filter((d) => d.name === "sensitive" || d.name === "public") || [];
+      const sensitiveDec = sensitiveDecs[0];
       if (sensitiveDec) {
+        const usingPublic = sensitiveDec.name === "public";
         const sensitiveDecValue = await sensitiveDec.resolve();
         if (sensitiveDec.schemaErrors.length) {
           return;
         }
         if (![true, false, void 0].includes(sensitiveDecValue)) {
-          throw new SchemaError("@sensitive must resolve to a boolean or undefined");
+          throw new SchemaError("@sensitive/@public must resolve to a boolean or undefined");
         }
         if (sensitiveDecValue !== void 0) {
-          this._isSensitive = sensitiveDecValue;
+          this._isSensitive = usingPublic ? !sensitiveDecValue : sensitiveDecValue;
           return;
         }
       }
@@ -3301,7 +3283,7 @@ async function registerPluginInGraph(graph, plugin, pluginDecorator) {
 }
 __name(registerPluginInGraph, "registerPluginInGraph");
 async function downloadPlugin(url) {
-  const exec3 = promisify(exec);
+  const exec2 = promisify(exec);
   const cacheDir = path2.join(os.homedir(), ".varlock", "plugins-cache");
   const indexPath = path2.join(cacheDir, "index.json");
   await fs2.mkdir(cacheDir, { recursive: true });
@@ -3332,7 +3314,7 @@ async function downloadPlugin(url) {
   });
   const tmpExtractDir = path2.join(cacheDir, `tmp-extract-${crypto.randomBytes(8).toString("hex")}`);
   await fs2.mkdir(tmpExtractDir);
-  await exec3(`tar -xzf ${tmpTgz} -C ${tmpExtractDir}`);
+  await exec2(`tar -xzf ${tmpTgz} -C ${tmpExtractDir}`);
   let pkgJsonPath = path2.join(tmpExtractDir, "package", "package.json");
   let pluginRoot = path2.join(tmpExtractDir, "package");
   if (!await fs2.stat(pkgJsonPath).then(() => true, () => false)) {
@@ -3594,19 +3576,27 @@ var EnvGraphDataSource4 = class {
       this._loadingError = new Error("Cannot use both @currentEnv and @envFlag decorators");
     }
     let envFlagItemKey;
+    let skipCurrentEnvProcessing = false;
     if (currentEnvDec) {
-      await currentEnvDec.process();
-      if (!currentEnvDec.decValueResolver) {
-        throw new Error("No resolver found for @currentEnv decorator");
-      }
-      if (currentEnvDec.decValueResolver.fnName !== "ref") {
-        throw new Error("Expected @currentEnv decorator to be set to direct reference - ie `$APP_ENV`");
+      const parsedValue = currentEnvDec.parsedDecorator.value;
+      if (parsedValue instanceof ParsedEnvSpecFunctionCall && parsedValue.name === "ref") {
+        const args = parsedValue.simplifiedArgs;
+        if (Array.isArray(args) && args.length > 0 && typeof args[0] === "string") {
+          envFlagItemKey = args[0];
+          if (this.isPartialImport && !this.importKeys?.includes(envFlagItemKey)) {
+            skipCurrentEnvProcessing = true;
+          }
+        }
       }
-      const refArgValue = currentEnvDec.decValueResolver.arrArgs?.[0]?.staticValue;
-      if (!refArgValue || !my_dash_default.isString(refArgValue)) {
-        throw new Error("@currentEnv ref must be set to a string");
+      if (!skipCurrentEnvProcessing) {
+        await currentEnvDec.process();
+        if (!currentEnvDec.decValueResolver) {
+          throw new Error("No resolver found for @currentEnv decorator");
+        }
+        if (currentEnvDec.decValueResolver.fnName !== "ref") {
+          throw new Error("Expected @currentEnv decorator to be set to direct reference - ie `$APP_ENV`");
+        }
       }
-      envFlagItemKey = refArgValue;
     } else if (envFlagDec) {
       await envFlagDec.process();
       if (!envFlagDec.decValueResolver) throw new Error("@envFlag resolver not set");
@@ -3631,74 +3621,112 @@ var EnvGraphDataSource4 = class {
     const importDecs = this.getRootDecFns("import");
     if (importDecs.length) {
       for (const importDec of importDecs) {
-        const importArgs = await importDec.resolve();
-        const importPath = importArgs.arr[0];
-        const importKeys = importArgs.arr.slice(1);
-        if (!importKeys.every(my_dash_default.isString)) {
-          throw new Error("expected @import keys to all be strings");
-        }
-        if (importPath.startsWith("./") || importPath.startsWith("../")) {
-          if (!(this instanceof FileBasedDataSource)) {
-            throw new Error("@import of files can only be used from a file-based data source");
-          }
-          const fullImportPath = path2.resolve(this.fullPath, "..", importPath);
-          const fileName = path2.basename(fullImportPath);
-          if (this.graph.virtualImports) {
-            if (importPath.endsWith("/")) {
-              if (!Object.keys(this.graph.virtualImports).some((p) => p.startsWith(fullImportPath))) {
-                this._loadingError = new Error(`Virtual directory import ${fullImportPath} not found`);
-                return;
-              }
-              await this.addChild(new DirectoryDataSource(fullImportPath), {
-                isImport: true,
-                importKeys
-              });
-            } else {
-              if (!this.graph.virtualImports[fullImportPath]) {
-                this._loadingError = new Error(`Virtual import ${fullImportPath} not found`);
-                return;
+        try {
+          await importDec.process();
+          if (importDec.decValueResolver?.objArgs?.enabled) {
+            const enabledResolver = importDec.decValueResolver.objArgs.enabled;
+            const enabledDeps = enabledResolver.deps;
+            for (const depKey of enabledDeps) {
+              const depItem = this.graph.configSchema[depKey];
+              if (!depItem) {
+                throw new Error(`@import enabled parameter depends on non-existent item: ${depKey}`);
               }
-              const source = new DotEnvFileDataSource(fullImportPath, {
-                overrideContents: this.graph.virtualImports[fullImportPath]
-              });
-              await this.addChild(source, { isImport: true, importKeys });
+              await depItem.earlyResolve();
             }
-          } else {
-            const fsStat = await tryCatch(async () => fs2.stat(fullImportPath), (_err) => {
-            });
-            if (!fsStat) {
-              this._loadingError = new Error(`Import path does not exist: ${fullImportPath}`);
-              return;
+          }
+          const importArgs = await importDec.resolve();
+          const importPath = importArgs.arr[0];
+          const importKeys = importArgs.arr.slice(1);
+          if (!importKeys.every(my_dash_default.isString)) {
+            throw new Error("expected @import keys to all be strings");
+          }
+          let fullImportPath;
+          if (importPath.startsWith("./") || importPath.startsWith("../")) {
+            if (!(this instanceof FileBasedDataSource)) {
+              throw new Error("@import of files can only be used from a file-based data source");
             }
-            if (importPath.endsWith("/")) {
-              if (fsStat.isDirectory()) {
+            fullImportPath = path2.resolve(this.fullPath, "..", importPath);
+          } else if (importPath.startsWith("~/") || importPath === "~") {
+            fullImportPath = path2.join(os.homedir(), importPath.slice(1));
+          } else if (importPath.startsWith("/")) {
+            fullImportPath = importPath;
+          }
+          const enabledValue = importArgs.obj.enabled ?? true;
+          if (!my_dash_default.isBoolean(enabledValue)) {
+            throw new Error("expected @import enabled parameter to be a boolean");
+          }
+          if (!enabledValue) continue;
+          const allowMissing = importArgs.obj.allowMissing ?? false;
+          if (!my_dash_default.isBoolean(allowMissing)) {
+            throw new Error("expected @import allowMissing parameter to be a boolean");
+          }
+          if (fullImportPath) {
+            const fileName = path2.basename(fullImportPath);
+            if (this.graph.virtualImports) {
+              if (importPath.endsWith("/")) {
+                const dirExists = Object.keys(this.graph.virtualImports).some((p) => p.startsWith(fullImportPath));
+                if (!dirExists && allowMissing) continue;
+                if (!dirExists) {
+                  this._loadingError = new Error(`Virtual directory import ${fullImportPath} not found`);
+                  return;
+                }
                 await this.addChild(new DirectoryDataSource(fullImportPath), {
                   isImport: true,
                   importKeys
                 });
               } else {
-                this._loadingError = new Error(`Imported path ending with "/" is not a directory: ${fullImportPath}`);
-                return;
+                const fileExists = this.graph.virtualImports[fullImportPath];
+                if (!fileExists && allowMissing) continue;
+                if (!fileExists) {
+                  this._loadingError = new Error(`Virtual import ${fullImportPath} not found`);
+                  return;
+                }
+                const source = new DotEnvFileDataSource(fullImportPath, {
+                  overrideContents: this.graph.virtualImports[fullImportPath]
+                });
+                await this.addChild(source, { isImport: true, importKeys });
               }
             } else {
-              if (fsStat.isDirectory()) {
-                this._loadingError = new Error('Imported path is a directory, add trailing "/" to import');
-                return;
-              } else if (!fileName.startsWith(".env.")) {
-                this._loadingError = new Error("imported file must be a .env.* file");
+              const fsStat = await tryCatch(async () => fs2.stat(fullImportPath), (_err) => {
+              });
+              if (!fsStat && allowMissing) continue;
+              if (!fsStat) {
+                this._loadingError = new Error(`Import path does not exist: ${fullImportPath}`);
                 return;
               }
-              await this.addChild(new DotEnvFileDataSource(fullImportPath), { isImport: true, importKeys });
+              if (importPath.endsWith("/")) {
+                if (fsStat.isDirectory()) {
+                  await this.addChild(new DirectoryDataSource(fullImportPath), {
+                    isImport: true,
+                    importKeys
+                  });
+                } else {
+                  this._loadingError = new Error(`Imported path ending with "/" is not a directory: ${fullImportPath}`);
+                  return;
+                }
+              } else {
+                if (fsStat.isDirectory()) {
+                  this._loadingError = new Error('Imported path is a directory, add trailing "/" to import');
+                  return;
+                } else if (!fileName.startsWith(".env.")) {
+                  this._loadingError = new Error("imported file must be a .env.* file");
+                  return;
+                }
+                await this.addChild(new DotEnvFileDataSource(fullImportPath), { isImport: true, importKeys });
+              }
             }
+          } else if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
+            this._loadingError = new Error("http imports not supported yet");
+            return;
+          } else if (importPath.startsWith("npm:")) {
+            this._loadingError = new Error("npm imports not supported yet");
+            return;
+          } else {
+            this._loadingError = new Error("unsupported import type");
+            return;
           }
-        } else if (importPath.startsWith("http://") || importPath.startsWith("https://")) {
-          this._loadingError = new Error("http imports not supported yet");
-          return;
-        } else if (importPath.startsWith("npm:")) {
-          this._loadingError = new Error("npm imports not supported yet");
-          return;
-        } else {
-          this._loadingError = new Error("unsupported import type");
+        } catch (err) {
+          this._loadingError = err;
           return;
         }
       }
@@ -3758,7 +3786,6 @@ var FileBasedDataSource = class extends EnvGraphDataSource4 {
   static {
     __name(this, "FileBasedDataSource");
   }
-  isGitIgnored;
   fullPath;
   fileName;
   rawContents;
@@ -3782,7 +3809,6 @@ var FileBasedDataSource = class extends EnvGraphDataSource4 {
     this.relativePath = path2.relative(process.cwd(), fullPath);
     if (opts?.overrideContents) {
       this.rawContents = opts.overrideContents;
-      this.isGitIgnored = opts.overrideGitIgnored;
     }
     if (this.fileName.startsWith(".env")) {
       const fileNameParts = this.fileName.substring(1).split(".");
@@ -3813,7 +3839,6 @@ var FileBasedDataSource = class extends EnvGraphDataSource4 {
         this._loadingError = new Error(`File does not exist: ${this.fullPath}`);
         return;
       }
-      this.isGitIgnored = await checkIsFileGitIgnored(this.fullPath);
       this.rawContents = await fs2.readFile(this.fullPath, "utf8");
     }
     if (this.rawContents) await this._parseContents();
@@ -3894,25 +3919,49 @@ var DirectoryDataSource = class extends EnvGraphDataSource4 {
       this.schemaDataSource = this.children[this.children.length - 1];
     }
     await this.addAutoLoadedFile(".env.local");
-    const currentEnv = await this.resolveCurrentEnv() || this.envFlagValue;
+    let currentEnv;
+    if (this.schemaDataSource?._envFlagKey) {
+      const envFlagKey = this.schemaDataSource._envFlagKey;
+      if (this.isPartialImport && !this.importKeys?.includes(envFlagKey)) {
+        this._loadingError = new Error(
+          `Imported directory has @currentEnv set to $${envFlagKey}, but "${envFlagKey}" is not included in the import list. Add "${envFlagKey}" to the @import() arguments.`
+        );
+        return;
+      }
+      const envFlagItem = this.graph.configSchema[envFlagKey];
+      if (envFlagItem) {
+        if (!envFlagItem.resolvedValue) await envFlagItem.earlyResolve();
+        currentEnv = envFlagItem.resolvedValue?.toString();
+      }
+    }
+    currentEnv ||= (await this.resolveCurrentEnv())?.toString() || this.envFlagValue?.toString();
     if (currentEnv) {
       await this.addAutoLoadedFile(`.env.${currentEnv}`);
       await this.addAutoLoadedFile(`.env.${currentEnv}.local`);
     }
   }
 };
-
-// src/env-graph/lib/loader.ts
 async function loadEnvGraph(opts) {
   const graph = new EnvGraph2();
-  graph.basePath = opts?.basePath ?? process.cwd();
-  if (opts?.afterInit) {
-    await opts.afterInit(graph);
-  }
-  if (opts?.currentEnvFallback) {
-    graph.envFlagFallback = opts.currentEnvFallback;
+  if (opts?.entryFilePath) {
+    const resolvedPath = path2.resolve(opts.entryFilePath);
+    if (opts.entryFilePath.endsWith("/") || opts.entryFilePath.endsWith(path2.sep)) {
+      graph.basePath = resolvedPath;
+      if (opts?.afterInit) await opts.afterInit(graph);
+      if (opts?.currentEnvFallback) graph.envFlagFallback = opts.currentEnvFallback;
+      await graph.setRootDataSource(new DirectoryDataSource(resolvedPath));
+    } else {
+      graph.basePath = path2.dirname(resolvedPath);
+      if (opts?.afterInit) await opts.afterInit(graph);
+      if (opts?.currentEnvFallback) graph.envFlagFallback = opts.currentEnvFallback;
+      await graph.setRootDataSource(new DotEnvFileDataSource(resolvedPath));
+    }
+  } else {
+    graph.basePath = opts?.basePath ?? process.cwd();
+    if (opts?.afterInit) await opts.afterInit(graph);
+    if (opts?.currentEnvFallback) graph.envFlagFallback = opts.currentEnvFallback;
+    await graph.setRootDataSource(new DirectoryDataSource(graph.basePath));
   }
-  await graph.setRootDataSource(new DirectoryDataSource(graph.basePath));
   await graph.finishLoad();
   return graph;
 }
@@ -4007,6 +4056,6 @@ function getItemSummary(item) {
 __name(getItemSummary, "getItemSummary");
 //! these are probably not relevant anymore, or needs to move to a plugin layer?
 
-export { CoercionError, ConfigLoadError, DotEnvFileDataSource, EnvGraph2 as EnvGraph, FileBasedDataSource, ResolutionError, SchemaError, ValidationError, VarlockError, ansis_default, asyncExitHook, checkIsFileGitIgnored, getItemSummary, gracefulExit, joinAndCompact, loadEnvGraph, my_dash_default, pathExists, pathExistsSync, tryCatch };
-//# sourceMappingURL=chunk-OOBWRTIS.js.map
-//# sourceMappingURL=chunk-OOBWRTIS.js.map
+export { CoercionError, ConfigLoadError, DotEnvFileDataSource, EnvGraph2 as EnvGraph, FileBasedDataSource, ResolutionError, SchemaError, ValidationError, VarlockError, ansis_default, asyncExitHook, getItemSummary, gracefulExit, joinAndCompact, loadEnvGraph, my_dash_default, pathExists, pathExistsSync, tryCatch };
+//# sourceMappingURL=chunk-OKNWYS57.js.map
+//# sourceMappingURL=chunk-OKNWYS57.js.map