varlock 0.0.2 → 0.0.3

package/dist/{chunk-G4BD2BPH.js → chunk-TYL3Q4QG.js}

@@ -779,17 +779,12 @@ __name(tryCatch, "tryCatch");
 // ../env-graph/src/lib/errors.ts
 var VarlockError = class extends Error {
   constructor(errOrMessage, more) {
-    var __super = (...args) => {
-      super(...args);
-      this.more = more;
-      return this;
-    };
+    super(my_dash_default.isError(errOrMessage) ? errOrMessage.message : errOrMessage);
+    this.more = more;
     if (my_dash_default.isError(errOrMessage)) {
-      __super(errOrMessage.message);
       this.originalError = errOrMessage;
       this.icon = "\u{1F4A5}";
     } else {
-      __super(errOrMessage);
       this.originalError = more?.err;
     }
     if (my_dash_default.isArray(more?.tip)) more.tip = more.tip.join("\n");
@@ -937,7 +932,7 @@ var Resolver = class {
   _schemaErrors = [];
   _depsObj = {};
   get childResolvers() {
-    return my_dash_default.isArray(this.fnArgs) ? this.fnArgs : my_dash_default.values(this.fnArgs);
+    return this.fnArgs.flatMap((r) => my_dash_default.isPlainObject(r) ? my_dash_default.values(r) : r);
   }
   get schemaErrors() {
     return [
@@ -1032,19 +1027,19 @@ var ConcatResolver = class extends Resolver {
   icon = "material-symbols:join";
   inferredType = "string";
   async _process() {
-    if (!Array.isArray(this.fnArgs)) {
-      throw new SchemaError("concat() expects an array of arguments, not a key-value object");
+    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
+      throw new SchemaError("concat() does not support key-value arguments");
     }
     if (this.fnArgs.length < 2) {
       throw new SchemaError("concat() expects at least two arguments");
     }
   }
   async _resolve() {
-    if (!Array.isArray(this.fnArgs)) {
-      throw new Error("concat() expects an array of arguments, not a key-value object");
-    }
     const resolvedValues = [];
     for (const arg of this.fnArgs) {
+      if (my_dash_default.isPlainObject(arg)) {
+        throw new Error("concat() does not support key-value arguments");
+      }
       const resolvedChildValue = await arg.resolve();
       resolvedValues.push(String(resolvedChildValue ?? ""));
     }
@@ -1059,18 +1054,16 @@ var FallbackResolver = class extends Resolver {
   label = "fallback";
   icon = "memory:table-top-stairs-up";
   async _process() {
-    if (!Array.isArray(this.fnArgs)) {
-      throw new SchemaError("fallback() expects an array of arguments, not a key-value object");
+    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
+      throw new SchemaError("fallback() does not support key-value arguments");
     }
     if (this.fnArgs.length < 2) {
       throw new SchemaError("fallback() expects at least two arguments");
     }
   }
   async _resolve() {
-    if (!Array.isArray(this.fnArgs)) {
-      throw new Error("concat() expects an array of arguments, not a key-value object");
-    }
     for (const arg of this.fnArgs) {
+      if (my_dash_default.isPlainObject(arg)) throw new Error("fallback() does not support key-value arguments");
       const resolvedChildValue = await arg.resolve();
       if (resolvedChildValue !== void 0 && resolvedChildValue !== "") {
         return resolvedChildValue;
@@ -1086,18 +1079,16 @@ var ExecResolver = class _ExecResolver extends Resolver {
   label = "exec";
   icon = "iconoir:terminal";
   async _process() {
-    if (!Array.isArray(this.fnArgs)) {
-      throw new SchemaError("exec() expects a single child arg, not a key-value object");
-    }
     if (this.fnArgs.length !== 1) {
       throw new SchemaError("exec() expects a single child arg");
     }
+    if (this.fnArgs.some((arg) => my_dash_default.isPlainObject(arg))) {
+      throw new SchemaError("exec() does not support key-value arguments");
+    }
   }
   static execQueue = new SimpleQueue();
   async _resolve() {
-    if (!Array.isArray(this.fnArgs) || this.fnArgs.length !== 1) {
-      throw new Error("exec() expects a single child arg");
-    }
+    if (my_dash_default.isPlainObject(this.fnArgs[0])) throw new Error("exec() does not support key-value arguments");
     const commandStr = await this.fnArgs[0].resolve();
     if (typeof commandStr !== "string") {
       throw new ResolutionError("exec() expects a string child arg");
@@ -1120,9 +1111,6 @@ var RefResolver = class extends Resolver {
   icon = "mdi-light:content-duplicate";
   refKey;
   async _process() {
-    if (!Array.isArray(this.fnArgs)) {
-      throw new SchemaError("ref() expects a single child arg, not a key-value object");
-    }
     if (this.fnArgs.length !== 1) {
       throw new SchemaError("ref() expects a single child arg");
     }
@@ -1141,11 +1129,79 @@ var RefResolver = class extends Resolver {
     return this.getDepValue(this.refKey);
   }
 };
+var RegexResolver = class extends Resolver {
+  static {
+    __name(this, "RegexResolver");
+  }
+  static fnName = "regex";
+  label = "regex";
+  icon = "mdi:regex";
+  regex;
+  async _process() {
+    if (this.fnArgs.length !== 1) {
+      throw new SchemaError("regex() expects a single child arg");
+    }
+    if (!(this.fnArgs[0] instanceof StaticValueResolver)) {
+      throw new SchemaError("regex() expects a single static value passed in");
+    }
+    const regexStr = this.fnArgs[0].staticValue;
+    if (typeof regexStr !== "string") {
+      throw new SchemaError("regex() expects a string");
+    }
+    this.regex = new RegExp(regexStr);
+  }
+  async _resolve() {
+    if (!this.regex) throw new Error("expected regex to be set");
+    return this.regex;
+  }
+};
+var RemapResolver = class extends Resolver {
+  static {
+    __name(this, "RemapResolver");
+  }
+  static fnName = "remap";
+  label = "remap";
+  icon = "codicon:replace";
+  remappings;
+  async _process() {
+    if (my_dash_default.isPlainObject(this.fnArgs[0])) {
+      throw new SchemaError("remap() expects the first arg to be the value to remap");
+    }
+    if (!my_dash_default.isPlainObject(this.fnArgs[1])) {
+      throw new SchemaError("remap() expects the all args after the first to be key-value pairs of remappings");
+    }
+    if (this.fnArgs.length !== 2) {
+      throw new SchemaError("remap() should not have any additional non key-value args after remappings");
+    }
+    this.remappings = this.fnArgs[1];
+  }
+  async _resolve() {
+    if (my_dash_default.isPlainObject(this.fnArgs[0])) {
+      throw new SchemaError("remap() expects the first arg to be the value to remap");
+    }
+    if (!my_dash_default.isPlainObject(this.fnArgs[1])) {
+      throw new SchemaError("remap() expects the all args after the first to be key-value pairs of remappings");
+    }
+    const originalValue = await this.fnArgs[0].resolve();
+    if (!this.remappings) throw new Error("expected remappings to be set");
+    for (const [remappedVal, matchValResolver] of Object.entries(this.remappings)) {
+      const matchVal = await matchValResolver.resolve();
+      if (matchVal instanceof RegExp && originalValue !== void 0) {
+        if (matchVal.test(String(originalValue))) return remappedVal;
+      } else {
+        if (matchVal === originalValue) return remappedVal;
+      }
+    }
+    return originalValue;
+  }
+};
 var BaseResolvers = [
   ConcatResolver,
   FallbackResolver,
   RefResolver,
-  ExecResolver
+  ExecResolver,
+  RemapResolver,
+  RegexResolver
 ];
 
 // ../env-graph/src/lib/data-source.ts
@@ -1204,7 +1260,8 @@ var ProcessEnvDataSource = class _ProcessEnvDataSource extends EnvGraphDataSourc
     __name(this, "ProcessEnvDataSource");
   }
   type = "overrides";
-  label = "Process Environment Variables";
+  typeLabel = "process";
+  label = "process.env";
   ignoreNewDefs = true;
   static processEnvValues;
   // ? do we want to set decorator values from env vars here? -- ex: _ENV_FLAG_KEY
@@ -1241,10 +1298,14 @@ var FileBasedDataSource = class extends EnvGraphDataSource {
   fullPath;
   fileName;
   rawContents;
-  format;
+  get typeLabel() {
+    return this.constructor.format;
+  }
   get label() {
-    return `File: ${this.fullPath}`;
+    return this.fileName;
   }
+  static format = "unknown";
+  // no abstract static
   static validFileExtensions = [];
   get validFileExtensions() {
     return this.constructor.validFileExtensions;
@@ -1295,7 +1356,7 @@ var DotEnvFileDataSource = class extends FileBasedDataSource {
   static {
     __name(this, "DotEnvFileDataSource");
   }
-  static format = "dotenv";
+  static format = ".env";
   static validFileExtensions = [];
   // no extension for dotenv files!
   parsedFile;
@@ -1311,19 +1372,21 @@ var DotEnvFileDataSource = class extends FileBasedDataSource {
         return new ErrorResolver(new SchemaError(`Unknown resolver function: ${value.name}()`));
       }
       const argsFromParser = value.data.args.values;
-      if (argsFromParser.length && argsFromParser.every((arg) => arg instanceof ParsedEnvSpecKeyValuePair)) {
-        const argsAsResolversObj = {};
-        for (const arg of argsFromParser) {
-          argsAsResolversObj[arg.key] = this.convertParserValueToResolvers(arg.value);
+      let keyValueArgs;
+      const argsAsResolversArray = [];
+      for (const arg of argsFromParser) {
+        if (arg instanceof ParsedEnvSpecKeyValuePair) {
+          keyValueArgs ??= {};
+          keyValueArgs[arg.key] = this.convertParserValueToResolvers(arg.value);
+        } else {
+          if (keyValueArgs) {
+            return new ErrorResolver(new SchemaError("After switching to key-value function args, cannot switch back"));
+          }
+          argsAsResolversArray.push(this.convertParserValueToResolvers(arg));
         }
-        return new ResolverFnClass(argsAsResolversObj);
-      } else {
-        const argsAsResolversArray = argsFromParser.map((arg) => {
-          if (arg instanceof ParsedEnvSpecKeyValuePair) throw new Error("KeyValuePair not supported as a function argument");
-          return this.convertParserValueToResolvers(arg);
-        });
-        return new ResolverFnClass(argsAsResolversArray);
       }
+      if (keyValueArgs) argsAsResolversArray.push(keyValueArgs);
+      return new ResolverFnClass(argsAsResolversArray);
     } else {
       throw new Error("Unknown value type");
     }
@@ -1415,6 +1478,10 @@ var ConfigItem = class {
     return this.valueResolver?.schemaErrors || [];
   }
   async process() {
+    const finalOverrideDef = this.envGraph.finalOverridesDataSource?.configItemDefs[this.key];
+    if (finalOverrideDef) {
+      this.defs.unshift({ itemDef: finalOverrideDef, source: this.envGraph.finalOverridesDataSource });
+    }
     for (const def of this.defs) {
       await def.itemDef.resolver?.process(this);
     }
@@ -1445,11 +1512,32 @@ var ConfigItem = class {
     for (const def of this.defs) {
       const defDecorators = def.itemDef.decorators || {};
       if ("required" in defDecorators) {
-        return defDecorators.required.simplifiedValue;
-      } else if ("optional" in defDecorators) {
-        return !defDecorators.optional.simplifiedValue;
-      } else if ("defaultRequired" in def.source.decorators) {
-        return def.source.decorators.defaultRequired.simplifiedValue;
+        const val = defDecorators.required.simplifiedValue;
+        if (typeof val === "boolean") return val;
+        if (typeof val === "string") return val === "true";
+        return Boolean(val);
+      }
+      if ("optional" in defDecorators) {
+        const val = defDecorators.optional.simplifiedValue;
+        if (typeof val === "boolean") return !val;
+        if (typeof val === "string") return val !== "true";
+        return !val;
+      }
+      if ("defaultRequired" in def.source.decorators) {
+        const val = def.source.decorators.defaultRequired.simplifiedValue;
+        if (val === "infer") {
+          if (def.source.type === "schema") {
+            const resolver = def.itemDef.resolver;
+            if (resolver instanceof StaticValueResolver) {
+              return resolver.staticValue !== void 0 && resolver.staticValue !== "";
+            } else {
+              return true;
+            }
+          } else {
+            continue;
+          }
+        }
+        return val;
       }
     }
     return true;
@@ -1460,7 +1548,16 @@ var ConfigItem = class {
       if ("sensitive" in defDecorators) {
         return defDecorators.sensitive.simplifiedValue;
       } else if ("defaultSensitive" in def.source.decorators) {
-        return def.source.decorators.defaultSensitive.simplifiedValue;
+        const dec = def.source.decorators.defaultSensitive;
+        if (dec.value instanceof ParsedEnvSpecFunctionCall && dec.value.name === "inferFromPrefix") {
+          const args = dec.value.simplifiedArgs;
+          const prefix = Array.isArray(args) && args.length > 0 ? args[0] : void 0;
+          if (typeof prefix === "string" && this.key.startsWith(prefix)) {
+            return false;
+          }
+          return true;
+        }
+        return dec.simplifiedValue;
       }
     }
     return true;
@@ -1494,17 +1591,19 @@ var ConfigItem = class {
   async resolve() {
     if (this.schemaErrors.length) return;
     if (this.resolverSchemaErrors.length) return;
-    if (!this.valueResolver) {
-      this.resolvedRawValue = void 0;
+    if (!this.valueResolver) throw new Error("Expected a resolver to be set");
+    if (this.isResolved) {
       return;
     }
-    if (this.isResolved) throw new Error("item already resolved");
     try {
       this.resolvedRawValue = await this.valueResolver.resolve();
     } catch (err) {
       this.resolutionError = new ResolutionError(`error resolving value: ${err}`);
       this.resolutionError.cause = err;
     }
+    if (this.resolvedRawValue instanceof RegExp) {
+      this.resolutionError = new ResolutionError("regex() is meant to be used within function args, not as a final resolved value");
+    }
     if (this.resolutionError) return;
     this.isResolved = true;
     if (this.resolvedRawValue === void 0 || this.resolvedRawValue === "") {
@@ -2052,12 +2151,24 @@ async function generateTsTypesSrc(graph) {
   }
   tsSrc.push("};\n");
   tsSrc.push(`
-declare module 'varlock' {
+declare module 'varlock/env' {
   export interface TypedEnvSchema extends CoercedEnvSchema {}
-  
   export interface PublicTypedEnvSchema extends Pick<CoercedEnvSchema, '${exposedNonSensitiveKeys.join("' | '")}'> {}
 }
 `);
+  tsSrc.push(`
+export type EnvSchemaAsStrings = {
+  [Property in keyof CoercedEnvSchema]:
+    CoercedEnvSchema[Property] extends string ? CoercedEnvSchema[Property]
+      : (CoercedEnvSchema[Property] extends boolean ? ('true' | 'false') : string)
+};
+`);
+  tsSrc.push(`
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv extends EnvSchemaAsStrings {}
+  }
+}`);
   return tsSrc.join("\n");
 }
 __name(generateTsTypesSrc, "generateTsTypesSrc");
@@ -2081,6 +2192,7 @@ var EnvGraph = class {
   basePath;
   /** array of data sources */
   dataSources = [];
+  finalOverridesDataSource;
   /** config item key of env flag (toggles env-specific data sources enabled) */
   envFlagKey;
   /** current value of the environment flag */
@@ -2140,36 +2252,51 @@ var EnvGraph = class {
         }
       }
       if (source.applyForEnv) {
-        if (!this.envFlagValue) {
-          if (!this.envFlagKey) {
-            throw new Error("You must specify the @envFlag in your schema to load any env-specific files");
-          }
-          if (!this.configSchema[this.envFlagKey]) {
-            throw new Error(`@envFlag key ${this.envFlagKey} not found in schema`);
-          }
-          if (process.env[this.envFlagKey]) {
-            this.envFlagValue = process.env[this.envFlagKey];
-          } else {
-            const envFlagResolver = this.configSchema[this.envFlagKey].valueResolver;
-            if (envFlagResolver instanceof StaticValueResolver) {
-              if (!my_dash_default.isString(envFlagResolver.staticValue)) throw new Error("expected a static string value for envFlag");
-              this.envFlagValue = envFlagResolver.staticValue;
-            } else {
-              throw new Error("envFlag value must be a static string");
-            }
-          }
-        }
         if (source.applyForEnv && this.envFlagValue !== source.applyForEnv) {
           source.disabled = true;
           continue;
         }
       }
+      if (source.decorators?.disable && source.decorators.disable.simplifiedValue) {
+        source.disabled = true;
+        continue;
+      }
       for (const itemKey in source.configItemDefs) {
         if (source.ignoreNewDefs && !this.configSchema[itemKey]) continue;
         const itemDef = source.configItemDefs[itemKey];
         this.configSchema[itemKey] ??= new ConfigItem(this, itemKey);
         this.configSchema[itemKey].addDef(itemDef, source);
       }
+      if (source.type === "schema" && this.envFlagKey) {
+        if (!this.configSchema[this.envFlagKey]) {
+          throw new Error(`@envFlag key ${this.envFlagKey} not found in schema`);
+        }
+        const envFlagItem = this.configSchema[this.envFlagKey];
+        await envFlagItem.process();
+        for (const depKey of envFlagItem.valueResolver?.deps || []) {
+          const depItem = this.configSchema[depKey];
+          if (!depItem) {
+            throw new Error(`envFlag resolver is using non-existant dependency: ${depKey}`);
+          }
+          await depItem.process();
+          if (depItem.valueResolver?.deps.length) {
+            throw new Error("envFlag cannot follow a chain of dependencies");
+          }
+          await depItem.resolve();
+        }
+        await envFlagItem.resolve();
+        if (!envFlagItem.isValid) {
+          const err = new Error("resolved @envFlag value is not valid");
+          err.cause = envFlagItem.errors[0];
+          throw err;
+        }
+        if (envFlagItem.resolvedValue) {
+          if (!my_dash_default.isString(envFlagItem.resolvedValue)) {
+            throw new Error("expected resolved @envFlag value to be a string");
+          }
+          this.envFlagValue = envFlagItem.resolvedValue;
+        }
+      }
     }
     for (const itemKey in this.configSchema) {
       const item = this.configSchema[itemKey];
@@ -2249,12 +2376,39 @@ var EnvGraph = class {
     }
     return envObject;
   }
+  getSerializedGraph() {
+    const serializedGraph = {
+      sources: [],
+      config: {},
+      settings: {}
+    };
+    for (const source of this.sortedDataSources) {
+      serializedGraph.sources.push({
+        label: source.label,
+        enabled: !source.disabled
+      });
+    }
+    for (const itemKey in this.configSchema) {
+      const item = this.configSchema[itemKey];
+      serializedGraph.config[itemKey] = {
+        value: item.resolvedValue,
+        isSensitive: item.isSensitive
+      };
+    }
+    serializedGraph.settings.redactLogs = this.getRootDecoratorValue("redactLogs") ?? true;
+    serializedGraph.settings.preventLeaks = this.getRootDecoratorValue("preventLeaks") ?? true;
+    return serializedGraph;
+  }
   get isInvalid() {
     return my_dash_default.some(my_dash_default.values(this.configSchema), (i) => !i.isValid);
   }
   async generateTypes(lang, outputPath) {
     await generateTypes(this, lang, outputPath);
   }
+  getRootDecoratorValue(decoratorName) {
+    const dec = this.schemaDataSource?.decorators?.[decoratorName];
+    return dec?.simplifiedValue;
+  }
 };
 var SKIP_FILE_TYPES = [".md", ".d.ts"];
 async function findEnvFiles(opts) {
@@ -2291,6 +2445,9 @@ async function loadEnvGraph(opts) {
   if (opts?.afterInit) {
     await opts.afterInit(graph);
   }
+  if (opts?.currentEnvFallback) {
+    graph.envFlagValue = opts.currentEnvFallback;
+  }
   const envFilePaths = await findEnvFiles({
     cwd: contextPath
   });
@@ -2299,12 +2456,12 @@ async function loadEnvGraph(opts) {
     graph.addDataSource(fileDataSource);
     await fileDataSource.finishInit();
   }
-  graph.addDataSource(new ProcessEnvDataSource());
+  graph.finalOverridesDataSource = new ProcessEnvDataSource();
   await graph.finishLoad();
   return graph;
 }
 __name(loadEnvGraph, "loadEnvGraph");
 
 export { DotEnvFileDataSource, EnvSourceParseError, StaticValueResolver, checkIsFileGitIgnored, loadEnvGraph, my_dash_default };
-//# sourceMappingURL=chunk-G4BD2BPH.js.map
-//# sourceMappingURL=chunk-G4BD2BPH.js.map
+//# sourceMappingURL=chunk-TYL3Q4QG.js.map
+//# sourceMappingURL=chunk-TYL3Q4QG.js.map