@romaintaillandier1978/dotenv-never-lies 0.3.0 → 1.1.0

package/dist/cli/index.js

@@ -1,127 +1,351 @@
 #!/usr/bin/env node
-import { program } from "commander";
+import { program, CommanderError } from "commander";
 import { assertCommand } from "./commands/assert.js";
 import { generateCommand } from "./commands/generate.js";
 import { reverseEnvCommand } from "./commands/reverseEnv.js";
-import { explainCommand } from "./commands/explain.js";
+import { explainCommand, printHuman } from "./commands/explain.js";
+import { exportCommand } from "./commands/export.js";
+import { toFile } from "./utils/toFile.js";
+import { DnlError, ExitCodes, ValidationError } from "../errors.js";
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const packageJson = require("../../package.json");
+const exitCodeHelp = {
+    [ExitCodes.success]: "Success (everything is valid, exit OK)",
+    [ExitCodes.usageError]: "Usage error or internal error",
+    [ExitCodes.schemaNotFound]: "DNL schema not found or not resolved",
+    [ExitCodes.validationError]: "Validation failed (invalid environment)",
+    [ExitCodes.exportError]: "Export error (format, file writing, secret, etc.)",
+};
+// #region Program
 program
     .name("dnl")
-    .version("0.1.0")
-    .addHelpText("before", `
-CLI pour dotenv-never-lies.
-Valide, charge et génère des variables d’environnement typées à partir d’un schéma TypeScript/Zod.
+    //.version("0.3.0")
+    .version(packageJson.version)
+    // allows passing positional arguments, before/after options
+    .enablePositionalOptions()
+    .exitOverride()
+    .addHelpText("before", `Summary:
+  CLI for dotenv-never-lies.
+  Validates typed environment variables from a TypeScript/Zod schema.
       `)
-    .addHelpText("after", `\nExemples :
+    .option("--schema <file>", "DNL schema file (e.g., path/to/my-dnl.ts). See the Environment schema section for details.")
+    .addHelpText("after", `\nExit codes:\n${Object.entries(exitCodeHelp)
+    .map(([key, value]) => `  - ${key}: ${value}`)
+    .join("\n")}
+        `)
+    .addHelpText("after", `\nEnvironment schema:
+  The dotenv-never-lies schema is resolved in the following order:
+  1. --schema option if provided
+  2. "dotenv-never-lies.schema" key in package.json
+  3. Convention files:
+    - env.dnl.ts
+    - env.dnl.js
+    - dnl.config.ts
+    - dnl.config.js
+  If no schema is found, the command fails.
+        `)
+    .addHelpText("after", `\nExamples:
         
-        # Vérifier l’environnement à l’exécution et arrêter le process si le schéma n’est pas respecté
-        dnl assert 
-        dnl assert --schema env.dnl.ts
-      
-        # Générer un fichier .env documenté à partir du schéma
-        dnl generate 
-        dnl generate --schema env.dnl.ts --out .env
-      
-        # Créer un schéma env.dnl.ts depuis un .env existant
-        dnl reverse-env --source .env
-      
-        # Afficher les variables connues et leur description
-        dnl explain
-      `);
+  # Check the environment at runtime and exit the process if the schema is not satisfied
+  dnl assert 
+  dnl assert --schema my-dnl.ts
+  
+  # Generate a documented .env file from the schema
+  dnl generate 
+  dnl generate --schema my-dnl.ts --out .env
+  
+  # Create an env.dnl.ts schema from an existing .env
+  dnl reverse-env --source .env
+  
+  # Display known variables and their description
+  dnl explain
+
+  # Export variables in docker-args format
+  dnl export docker-args --source .env
+  
+    `);
+// #endregion Program
+// #region assert
 program
     .command("assert")
-    .description("Vérifie l’environnement runtime et termine le process si le schéma n’est pas respecté.")
-    .option("--schema <file>", "Fichier de schéma dnl (ex: my-dnl.ts)", "env.dnl.ts")
-    .option("-s, --source <source>", "Source des variables (défaut : process.env)")
+    .description("Verifies the runtime environment and exits the process if the schema is not satisfied.")
+    .option("-s, --source <source>", "Variables source (default: process.env)")
     .action(assertCommand)
-    .addHelpText("after", `\nExemples :
+    .addHelpText("after", `\nExamples:
         
-        # Valider les variables d’environnement de process.env
-        # Recommandé en CI pour empêcher un démarrage avec une configuration invalide
-        dnl assert
-        dnl assert --schema my-dnl.ts
-
-        # Valider les variables d’environnement depuis un fichier .env
-        # Recommandé en local (préparation du schéma, onboarding)
-        dnl assert --source .env
-        dnl assert --schema my-dnl.ts --source .env
-
-        # valider les variables d'environnement du fichier fourni par la CI
-        dnl assert --source $ENV_FILE
-        dnl assert --schema my-dnl.ts --source $ENV_FILE
+  # Validate environment variables from process.env
+  # Recommended in CI to prevent starting with an invalid configuration
+  dnl assert
+  dnl assert --schema my-dnl.ts
+  
+  # Validate environment variables from a .env file
+  # Recommended locally (schema preparation, onboarding)
+  dnl assert --source .env
+  dnl assert --schema my-dnl.ts --source .env
+  
+  # validate environment variables from the file provided by the CI
+  dnl assert --source $ENV_FILE
+  dnl assert --schema my-dnl.ts --source $ENV_FILE
       `);
+// #endregion assert
+// #region export
+const exportHelp = {
+    "docker-args": "Arguments `--env KEY=VALUE` for `docker run`",
+    "docker-env": "File compatible with Docker `--env-file`",
+    "github-env": "Inject into a GitHub Actions job environment",
+    "github-secret": "GitHub Secrets via gh CLI (repo or organization)",
+    "gitlab-env": "GitLab CI environment variables",
+    "k8s-configmap": "Kubernetes ConfigMap (NON-sensitive variables)",
+    "k8s-secret": "Kubernetes Secret (sensitive variables only)",
+    env: ".env file cleaned (without unnecessary comments)",
+    json: "Key/value JSON object",
+    ts: "Typed TypeScript object",
+    js: "JavaScript object",
+};
 program
-    .command("generate")
-    .description("Génère un fichier .env à partir d’un schéma dnl.\n" +
-    "Utile pour initialiser un projet ou faciliter l’onboarding d’un nouveau développeur.\n" +
-    "Seules les valeurs définies par défaut dans le schéma sont écrites.")
-    .option("--schema <file>", "Fichier de schéma env (ex: env.dnl.ts)")
-    .option("-o, --out <file>", "Fichier de sortie (défaut : .env)")
-    .option("-f, --force", "Écraser le fichier existant")
-    .action(generateCommand)
-    .addHelpText("after", `\nExemples :
-        
-        # Générer un fichier .env à partir du schéma par défaut (env.dnl.ts)
-        dnl generate
+    .command("export")
+    .description("Exports environment variables to a specified format. Variables are exported after being validated against the schema.")
+    .argument("<format>", "Export format. See list and examples at the end")
+    .option("-s, --source <source>", "Variables source (default: process.env if none provided)")
+    .option("--hide-secret", 'Mask sensitive variables (replace with "********")')
+    .option("--exclude-secret", "Exclude sensitive variables (do not show them at all)")
+    .option("--include-comments", "Include comments in the export (does not work with the json format)")
+    .option("--serialize-typed", "Serialize validated runtime values (js/ts/json only). See below for more details.")
+    .option("-o, --out <file>", "Output file")
+    .option("-f, --force", "Overwrite the existing file, in conjunction with -o or --out")
+    .option("--k8s-name <name>", "Name for the k8s resource. Default: env-secret for k8s-secret, env-config for k8s-configmap")
+    .option("--github-org <org>", "GitHub organization name")
+    .action(async (format, opts) => {
+    const { content, warnings, out } = await exportCommand({ ...opts, format });
+    if (out) {
+        await toFile(content, out, opts.force ?? false);
+    }
+    else {
+        console.log(content);
+    }
+    for (const warning of warnings) {
+        console.error(`${warning}`);
+    }
+})
+    .addHelpText("after", `\nExport formats:\n${Object.entries(exportHelp)
+    .map(([key, value]) => `  - ${key}: ${value}`)
+    .join("\n")}
+        `)
+    .addHelpText("after", `\nSerialize validated runtime values (js/ts/json only):
+  When the --serialize-typed option is used, runtime values (after Zod transformations and validation) 
+  are serialized instead of the raw (but still validated) values from the source (.env or process.env).
 
-        # Générer un fichier .env à partir d'un schéma spécifié
-        dnl generate --schema my-dnl.ts
+  Example:
 
-        # Générer un fichier .env.local à partir du schéma
-        dnl generate --out .env.local
+  .env file:
+  NODE_CORS_ORIGIN=https://a.site.com;https://b.site.com;https://c.site.com
 
-        # Générer un fichier .env à partir d'un schéma et écraser le fichier existant
-        dnl generate --out .env --force
+  env.dnl.ts file:
+  NODE_CORS_ORIGIN: {
+      description: "Allowed frontend URLs separated by semicolons",
+      schema: z.string().transform((v) =>
+          v
+              .split(";")
+              .map((s) => s.trim())
+              .filter(Boolean)
+      ),
+  },
+
+  dnl export json --source .env 
+  {
+      "NODE_CORS_ORIGIN": "https://a.site.com;https://b.site.com;https://c.site.com"
+  }
+  
+  dnl export json --source .env --serialize-typed
+  {
+      "NODE_CORS_ORIGIN": [
+          "https://a.site.com",
+          "https://b.site.com",
+          "https://c.site.com"
+      ]
+  }
+
+        `)
+    .addHelpText("after", `\nExamples:
+      
+  # --- Simple cases ----------------------------------------------------
+  
+  # Export environment variables as JSON from a .env file
+  dnl export json --source .env
+  
+  # Clean a .env file (remove comments and extraneous lines)
+  dnl export env --source .env --out .env.clean
+  dnl export env --source .env -fo .env
+  
+  
+  # --- Docker / CI ----------------------------------------------------
+  
+  # Export variables as docker-args
+  dnl export docker-args --source .env
+  
+  # Concrete CI example to run a Docker container
+  # (variables are injected dynamically)
+  docker run \\
+    $(dnl export docker-args --source $DOTENV_FILE) \\
+    --restart always \\
+    -d my-image:latest
+  
+  
+  # --- GitHub Actions -------------------------------------------------
+  
+  # Export variables as GitHub secrets (current repo)
+  # Requires gh CLI configured (gh auth login)
+  dnl export github-secret
+  
+  # Export variables as GitHub organization secrets
+  dnl export github-secret --github-org my-org
+  
+  # Example usage in a GitHub Actions job:
+  # (variables are injected into the job environment)
+  dnl export github-env >> $GITHUB_ENV
+  
+  
+  # --- Kubernetes -----------------------------------------------------
+  
+  # Generate a Kubernetes ConfigMap (NON-sensitive variables), from process.env
+  dnl export k8s-configmap --out k8s-configmap.yaml
+  
+  # Generate a Kubernetes Secret from a .env file
+  dnl export k8s-secret --source .env --k8s-name my-secret --out k8s-secret.yaml
+  
+  # Apply the generated files
+  kubectl apply -f k8s-configmap.yaml
+  kubectl apply -f k8s-secret.yaml
+  
+  # note: if no secret is present in the dnl config, for k8s-secret the output will be empty
+  
+  # --- TypeScript / JavaScript ---------------------------------------
+  
+  # Export variables as a typed TypeScript object, or js
+  dnl export ts --out env.generated.ts --serialize-typed
+  dnl export js --out env.generated.js --serialize-typed
+  `);
+// #endregion export
+// #region generate
+program
+    .command("generate")
+    .description("Generates a .env file from a DNL schema.\n" +
+    "Useful to bootstrap a project or facilitate onboarding of a new developer.\n" +
+    "Only default values defined in the schema are written.")
+    .option("-o, --out <file>", "Output file (default: .env)")
+    .option("-f, --force", "Overwrite existing file")
+    .action(async (opts) => {
+    const { content, out } = await generateCommand(opts);
+    await toFile(content, out, opts.force ?? false);
+})
+    .addHelpText("after", `\nExamples:
+        
+  # Generate a .env file from the default schema (env.dnl.ts)
+  dnl generate
+  
+  # Generate a .env file from a specified schema
+  dnl generate --schema my-dnl.ts
+  
+  # Generate a .env.local file from the schema
+  dnl generate --out .env.local
+  
+  # Generate a .env file from a schema and overwrite the existing file
+  dnl generate --out .env --force
       `);
+// #endregion generate
+// #region reverse-env
 program
     .command("reverse-env")
-    .description("Génère un schéma dotenv-never-lies à partir d’un fichier .env.\n" +
-    "Utile pour migrer un projet existant vers dotenv-never-lies.\n" +
-    "Le schéma généré est un point de départ et doit être affiné manuellement.")
-    .option("-s, --source <source>", "Fichier .env source", ".env")
-    .option("-o, --out <file>", "Fichier dnl de sortie", "env.dnl.ts")
-    .option("-f, --force", "Écraser le fichier existant")
-    .option("--guess-secret", "Tenter de deviner les variables sensibles (heuristique)")
-    .action(reverseEnvCommand)
-    .addHelpText("after", `\nExemples :
-        
-        # Générer un schéma env.dnl.ts à partir d'un fichier .env
-        dnl reverse-env
-
-        # Générer un schéma env.dnl.ts à partir d'un fichier .env.local
-        dnl reverse-env --source .env.local
+    .description("Generates a dotenv-never-lies schema from a .env file.\n" +
+    "Useful to migrate an existing project to dotenv-never-lies.\n" +
+    "The generated schema is a starting point and must be refined manually.\n" +
+    "Keys in the .env file that are not valid identifiers are escaped to JSON strings. (e.g. MY-KEY -> 'MY-KEY')")
+    .option("-s, --source <source>", "Source .env file", ".env")
+    .option("-o, --out <file>", "Output DNL file", "env.dnl.ts")
+    .option("-f, --force", "Overwrite existing file")
+    .option("--guess-secret", "Try to guess sensitive variables (heuristic)")
+    .action(async (opts) => {
+    const { content, out, warnings } = await reverseEnvCommand(opts);
+    await toFile(content, out, opts.force ?? false);
+    for (const warning of warnings) {
+        console.error(`${warning}`);
+    }
+})
+    .addHelpText("after", `\nExamples:
         
-        # Générer un schéma my-dnl.ts à partir d'un fichier .env
-        dnl reverse-env --out my-dnl.ts
-
-        # Générer un schéma env.dnl.ts à partir d'un fichier .env et écraser le fichier existant
-        dnl reverse-env --force
-      `);
+  # Generate an env.dnl.ts schema from a .env file, try to guess sensitive variables
+  dnl reverse-env --guess-secret
+  
+  # Generate an env.dnl.ts schema from a .env.local file
+  dnl reverse-env --source .env.local
+  
+  # Generate a my-dnl.ts schema from a .env file
+  dnl reverse-env --out my-dnl.ts
+  
+  # Generate an env.dnl.ts schema from a .env file and overwrite the existing file
+  dnl reverse-env --force 
+  `);
+// #endregion reverse-env
+// #region explain
 program
     .command("explain")
-    .description("Affiche la liste des variables d’environnement connues et leur description.")
-    .argument("[keys...]", "Clés à expliquer (0..N). Sans argument, toutes les clés.")
-    .option("--schema <file>", "Fichier de schéma env (ex: env.dnl.ts)")
-    .option("-f, --format <format>", 'Format d\'affichage ("human" | "json")', "human")
+    .description("Displays the list of known environment variables and their description.")
+    .argument("[keys...]", "Keys to explain (0..N). Without argument, all keys.")
+    .option("-f, --format <format>", 'Output format ("human" | "json")', "human")
     .action(async (keys, opts) => {
-    const result = await explainCommand({ keys: keys ?? [], schema: opts.schema, format: opts.format });
-    process.exit(result);
+    const { format, result } = await explainCommand({ keys: keys ?? [], schema: opts.schema, format: opts.format });
+    if (format === "human") {
+        printHuman(result);
+    }
+    else {
+        console.log(JSON.stringify(result, null, 2));
+    }
 })
-    .addHelpText("after", `\nExemples :
+    .addHelpText("after", `\nExamples:
         
-        # expliquer toutes les variables connues et leur description
-        dnl explain
-        
-        # expliquer une variable en détail
-        dnl explain NODE_ENV
-
-        # sortie machine
-        dnl explain --format json
-
-        # expliquer toutes les variables connues et leur description à partir d'un schéma
-        dnl explain --schema another-env.ts
-       
-        # expliquer une partie des variables connues et leur description
-        dnl explain NODE_ENV NODE_PORT 
+  # explain all known variables and their description
+  dnl explain
+  
+  # explain a variable in detail
+  dnl explain NODE_ENV
+  
+  # machine-readable output
+  dnl explain --format json
+  
+  # explain all known variables and their description from a schema
+  dnl explain --schema my-dnl.ts
+  
+  # explain a subset of known variables and their description
+  dnl explain NODE_ENV NODE_PORT 
         
       `);
-program.parse(process.argv);
+// #endregion explain
+try {
+    await program.parseAsync(process.argv);
+    process.exit(ExitCodes.success);
+}
+catch (err) {
+    // Commander throws a controlled error when help or version is displayed
+    if (err instanceof CommanderError) {
+        if (err.code === "commander.helpDisplayed" || err.code === "commander.version") {
+            process.exit(ExitCodes.success);
+        }
+        process.exit(typeof err.exitCode === "number" ? err.exitCode : ExitCodes.usageError);
+    }
+    if (err instanceof ValidationError) {
+        console.error("❌ Invalid environment variables:\n");
+        for (const issue of err.issues ?? []) {
+            console.error(`- ${issue.key}`);
+            console.error(`  → ${issue.message}`);
+        }
+        process.exit(err.exitCode);
+    }
+    if (err instanceof DnlError) {
+        console.error(err.message);
+        process.exit(err.exitCode);
+    }
+    console.error("Unexpected error");
+    console.error(err);
+    process.exit(ExitCodes.usageError);
+}

package/dist/cli/utils/exitCodes.d.ts

@@ -0,0 +1,8 @@
+export declare enum ExitCodes {
+    success = 0,
+    usageError = 1,
+    schemaNotFound = 2,
+    validationError = 3,
+    exportError = 4
+}
+//# sourceMappingURL=exitCodes.d.ts.map

package/dist/cli/utils/exitCodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exitCodes.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/exitCodes.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS;IACjB,OAAO,IAAI;IACX,UAAU,IAAI;IACd,cAAc,IAAI;IAClB,eAAe,IAAI;IACnB,WAAW,IAAI;CAClB"}

package/dist/cli/utils/exitCodes.js

@@ -0,0 +1,8 @@
+export var ExitCodes;
+(function (ExitCodes) {
+    ExitCodes[ExitCodes["success"] = 0] = "success";
+    ExitCodes[ExitCodes["usageError"] = 1] = "usageError";
+    ExitCodes[ExitCodes["schemaNotFound"] = 2] = "schemaNotFound";
+    ExitCodes[ExitCodes["validationError"] = 3] = "validationError";
+    ExitCodes[ExitCodes["exportError"] = 4] = "exportError";
+})(ExitCodes || (ExitCodes = {}));

package/dist/cli/utils/infer-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"infer-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/infer-schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,GAAG,SAAS,oIAuBpD,CAAC;AAIF,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,YAExC,CAAC"}
+{"version":3,"file":"infer-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/infer-schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,GAAG,SAAS,oIAuBpD,CAAC;AAIF,eAAO,MAAM,WAAW,GAAI,OAAO,MAAM,YAGxC,CAAC"}

package/dist/cli/utils/infer-schema.js

@@ -1,5 +1,5 @@
 export const inferSchema = (value) => {
-    if (!value) {
+    if (value === undefined) {
         return "z.string().optional()";
     }
     if (/^(true|false)$/i.test(value)) {
@@ -18,7 +18,8 @@ export const inferSchema = (value) => {
     }
     return "z.string()";
 };
-const secretSuffixes = ["_SECRET", "_KEY", "_TOKEN", "_PASSWORD", "_AUTH"];
+const secretMarkers = ["SECRET", "KEY", "TOKEN", "PASSWORD", "PASS", "AUTH"];
 export const guessSecret = (value) => {
-    return secretSuffixes.some((suffix) => value.endsWith(suffix));
+    const parts = value.toUpperCase().split(/[_\-]/);
+    return secretMarkers.some((marker) => parts.includes(marker));
 };

package/dist/cli/utils/load-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/load-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEpD,eAAO,MAAM,OAAO,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAsBlF,CAAC"}
+{"version":3,"file":"load-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/load-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAGpD,eAAO,MAAM,OAAO,GAAU,YAAY,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAAC,GAAG,CAAC,CA2BlF,CAAC"}

package/dist/cli/utils/load-schema.js

@@ -2,21 +2,29 @@ import { build } from "esbuild";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { pathToFileURL } from "node:url";
+import { SchemaNotFoundError } from "../../errors.js";
 export const loadDef = async (schemaPath) => {
     const outDir = path.join(process.cwd(), ".dnl");
     await fs.mkdir(outDir, { recursive: true });
+    // We always overwrite the file here; this could be an issue.
     const outFile = path.join(outDir, "env.dnl.mjs");
-    await build({
-        entryPoints: [schemaPath],
-        outfile: outFile,
-        format: "esm",
-        platform: "node",
-        target: "node18",
-        bundle: false,
-    });
-    const mod = await import(pathToFileURL(outFile).href);
-    if (!mod.default) {
-        throw new Error("Le fichier env.dnl.ts doit exporter un schéma par défaut (export default).");
+    try {
+        await build({
+            entryPoints: [schemaPath],
+            outfile: outFile,
+            format: "esm",
+            platform: "node",
+            target: "node18",
+            bundle: true,
+            packages: "external",
+        });
+        const mod = await import(pathToFileURL(outFile).href);
+        if (!mod.default) {
+            throw new SchemaNotFoundError(`The file ${schemaPath} must export a default schema (export default).`);
+        }
+        return mod.default;
+    }
+    catch (error) {
+        throw new SchemaNotFoundError(`Unable to load DNL schema (${schemaPath}): ${error}`);
     }
-    return mod.default;
 };

package/dist/cli/utils/printer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"printer.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/printer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AACF,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,OAAO,gBAAgB,CAAC,GAAG,CAAC,KAAG,WAWzE,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,MAAM,CAoE5D;AAuBD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,MAAM,GAAG,SAAS,CAwB9E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,OAAO,CAyB3D"}
+{"version":3,"file":"printer.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/printer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AACF,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,EAAE,OAAO,gBAAgB,CAAC,GAAG,CAAC,KAAG,WAWzE,CAAC;AAEF,wBAAgB,YAAY,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,MAAM,CAqE5D;AAuBD,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,MAAM,GAAG,SAAS,CAwB9E;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,OAAO,CAyB3D"}

package/dist/cli/utils/printer.js

@@ -45,11 +45,12 @@ export function printZodType(def) {
             }
             return "unknown  | null";
         case "default":
+            //TODO :  ignore les valeurs par défaut falsy (0, false, "") dans printZodType, donc dnl explain omet des defaults valides.
             if ("innerType" in def) {
                 const result = printZodType(def.innerType);
                 const defaultValue = typeof def.defaultValue === "function" ? def.defaultValue() : (def.defaultValue ?? undefined);
                 // const defaultValue = (def as any).defaultValue;
-                if (defaultValue) {
+                if (defaultValue !== undefined) {
                     return result + " (default: " + defaultValue.toString() + ")";
                 }
                 return result;
@@ -97,7 +98,7 @@ export function getDefaultEnvValue(def) {
             const raw = typeof def.defaultValue === "function" ? def.defaultValue() : (def.defaultValue ?? undefined);
             return stringifyEnvValue(raw);
         }
-        // wrappers transparents
+        // transparent wrappers
         case "optional":
         case "nullable":
             if ("innerType" in def) {
@@ -119,13 +120,13 @@ export function isRequired(def) {
             return false;
         case "default":
             return false;
-        // nullable n’enlève PAS le required
+        // nullable DOES NOT remove the required
         case "nullable":
             if ("innerType" in def) {
                 return isRequired(def.innerType);
             }
             return false;
-        // pipe / transform → transparent côté required
+        // pipe / transform → transparent regarding required
         case "pipe":
             if ("in" in def) {
                 return isRequired(def.in);

package/dist/cli/utils/resolve-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/resolve-schema.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,MA0BpD,CAAC"}
+{"version":3,"file":"resolve-schema.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/resolve-schema.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,MA6BpD,CAAC"}

package/dist/cli/utils/resolve-schema.js

@@ -1,10 +1,15 @@
 import fs from "node:fs";
 import path from "node:path";
+import { SchemaNotFoundError } from "../../errors.js";
 const CANDIDATES = ["env.dnl.ts", "env.dnl.js", "dnl.config.ts", "dnl.config.js"];
 export const resolveSchemaPath = (cliPath) => {
     // 1. --schema
     if (cliPath) {
-        return path.resolve(process.cwd(), cliPath);
+        const full = path.resolve(process.cwd(), cliPath);
+        if (!fs.existsSync(full)) {
+            throw new SchemaNotFoundError(`Schema file not found: ${cliPath}`);
+        }
+        return full;
     }
     // 2. package.json
     const pkgPath = path.resolve(process.cwd(), "package.json");
@@ -18,10 +23,9 @@ export const resolveSchemaPath = (cliPath) => {
     // 3. convention
     for (const file of CANDIDATES) {
         const full = path.resolve(process.cwd(), file);
-        console.log("full", full);
         if (fs.existsSync(full)) {
             return full;
         }
     }
-    throw new Error("No env schema found. Use --schema or define one in package.json.");
+    throw new SchemaNotFoundError("No env schema found. Use --schema, define dotenv-never-lies.schema in package.json, or add env.dnl.ts");
 };

package/dist/cli/utils/toFile.d.ts

@@ -0,0 +1,2 @@
+export declare const toFile: (content: string, path: string, force?: boolean) => Promise<void>;
+//# sourceMappingURL=toFile.d.ts.map

package/dist/cli/utils/toFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toFile.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/toFile.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,MAAM,GAAU,SAAS,MAAM,EAAE,MAAM,MAAM,EAAE,QAAO,OAAe,KAAG,OAAO,CAAC,IAAI,CAKhG,CAAC"}