@xlameiro/env-typegen 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -5,12 +5,13 @@ var path6 = require('path');
 var url = require('url');
 var promises = require('fs/promises');
 var prettier = require('prettier');
-var picocolors = require('picocolors');
+var pc = require('picocolors');
 var util = require('util');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var path6__default = /*#__PURE__*/_interopDefault(path6);
+var pc__default = /*#__PURE__*/_interopDefault(pc);
 
 // src/parser/comment-parser.ts
 var VALID_ENV_VAR_TYPES = /* @__PURE__ */ new Set([
@@ -163,7 +164,9 @@ var inferenceRules = [
   {
     id: "P10_url_scheme",
     priority: 10,
-    match: (_key, value) => /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value),
+    // BUG-02: comma-separated URL lists (e.g. ALLOWED_ORIGINS) must NOT be inferred as
+    // a single URL — they don't pass z.string().url() or new URL() validation at runtime.
+    match: (_key, value) => !value.includes(",") && /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(value),
     type: "url"
   },
   {
@@ -291,7 +294,16 @@ function parseEnvFileContent(content, filePath, options) {
     );
     commentBlock = [];
   }
-  return { filePath, vars, groups };
+  const seenKeys = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (let i = vars.length - 1; i >= 0; i--) {
+    const variable = vars[i];
+    if (variable !== void 0 && !seenKeys.has(variable.key)) {
+      seenKeys.add(variable.key);
+      deduped.unshift(variable);
+    }
+  }
+  return { filePath, vars: deduped, groups };
 }
 function parseEnvFile(filePath) {
   const content = fs.readFileSync(filePath, "utf8");
@@ -492,9 +504,9 @@ function generateT3Env(parsed) {
   return lines.join("\n") + "\n";
 }
 var CONTRACT_FILE_NAMES = [
-  "env.contract.ts",
   "env.contract.mjs",
-  "env.contract.js"
+  "env.contract.js",
+  "env.contract.ts"
 ];
 function defineContract(contract) {
   return contract;
@@ -503,6 +515,12 @@ async function loadContract(cwd = process.cwd()) {
   for (const name of CONTRACT_FILE_NAMES) {
     const filePath = path6__default.default.resolve(cwd, name);
     if (fs.existsSync(filePath)) {
+      if (filePath.endsWith(".ts")) {
+        throw new Error(
+          `Contract file ${filePath} is a TypeScript file and cannot be loaded at runtime by Node.js.
+Rename it to ${filePath.replace(/\.ts$/, ".mjs")} and use ESM syntax (export default ...), or run via \`tsx\` / \`ts-node\` as a loader.`
+        );
+      }
       const fileUrl = url.pathToFileURL(filePath).href;
       const mod = await import(fileUrl);
       return mod.default;
@@ -543,7 +561,15 @@ env-typegen.config.mjs for runtime loading.`
   return void 0;
 }
 async function readEnvFile(filePath) {
-  return promises.readFile(path6__default.default.resolve(filePath), "utf8");
+  const resolved = path6__default.default.resolve(filePath);
+  try {
+    return await promises.readFile(resolved, "utf8");
+  } catch (err) {
+    if (err instanceof Error && err.code === "ENOENT") {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    throw err;
+  }
 }
 async function writeOutput(filePath, content) {
   const resolved = path6__default.default.resolve(filePath);
@@ -561,22 +587,30 @@ async function formatOutput(content, parser = "typescript") {
     return content;
   }
 }
+var { green, red, yellow } = pc__default.default;
 function log(message) {
   console.log(message);
 }
 function warn(message) {
-  console.warn(picocolors.yellow(`\u26A0 ${message}`));
+  console.warn(yellow(`\u26A0 ${message}`));
 }
 function error(message) {
-  console.error(picocolors.red(`\u2716 ${message}`));
+  console.error(red(`\u2716 ${message}`));
 }
 function success(message) {
-  console.log(picocolors.green(`\u2714 ${message}`));
+  console.log(green(`\u2714 ${message}`));
 }
 
 // src/pipeline.ts
 function deriveOutputPath(base, generator, isSingle) {
-  if (isSingle) return base;
+  if (isSingle) {
+    if (generator === "declaration" && !base.endsWith(".d.ts")) {
+      const ext2 = path6__default.default.extname(base);
+      const noExt2 = ext2.length > 0 ? base.slice(0, -ext2.length) : base;
+      return `${noExt2}.d.ts`;
+    }
+    return base;
+  }
   const ext = path6__default.default.extname(base);
   const noExt = ext.length > 0 ? base.slice(0, -ext.length) : base;
   const baseExt = ext.length > 0 ? ext : ".ts";
@@ -614,10 +648,6 @@ async function persistOutput(params) {
   }
   if (dryRun) {
     if (!silent) {
-      if (!isSingle) {
-        console.log(`// --- ${generator}: ${outputPath} ---`);
-      }
-      console.log(generated);
       success(`Dry run: would write ${outputPath}`);
     }
     return;
@@ -725,7 +755,8 @@ function checkInvalidType(variable, entry, environment) {
       break;
     }
     case "boolean": {
-      if (value !== "true" && value !== "false") {
+      const lower = value.toLowerCase();
+      if (!["true", "false", "1", "0", "yes", "no"].includes(lower)) {
         return {
           code: "ENV_INVALID_TYPE",
           key: variable.key,
@@ -848,7 +879,8 @@ function validateContract(parsed, contract, opts = {}) {
   const parsedByKey = new Map(parsed.vars.map((v) => [v.key, v]));
   for (const entry of contract.vars) {
     if (!entry.required) continue;
-    if (parsedByKey.has(entry.name)) continue;
+    const existing = parsedByKey.get(entry.name);
+    if (existing !== void 0 && existing.rawValue !== "") continue;
     issues.push({
       code: "ENV_MISSING",
       key: entry.name,
@@ -1029,12 +1061,20 @@ function parseProviderPayload(provider, value) {
 }
 async function loadCloudSource(options) {
   const resolvedPath = path6__default.default.resolve(options.filePath);
-  const raw = await promises.readFile(resolvedPath, "utf8");
+  let raw;
+  try {
+    raw = await promises.readFile(resolvedPath, "utf8");
+  } catch (err) {
+    if (err instanceof Error && err.code === "ENOENT") {
+      throw new Error(`File not found: ${options.filePath}`);
+    }
+    throw err;
+  }
   const parsed = JSON.parse(raw);
   return parseProviderPayload(options.provider, parsed);
 }
 var SECRET_KEY_RE = /(SECRET|TOKEN|PASSWORD|PRIVATE|API_KEY|ACCESS_KEY|CLIENT_SECRET)/i;
-var CONTRACT_FILE_NAMES2 = ["env.contract.ts", "env.contract.mjs", "env.contract.js"];
+var CONTRACT_FILE_NAMES2 = ["env.contract.mjs", "env.contract.js", "env.contract.ts"];
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1158,6 +1198,12 @@ async function loadValidationContract(options) {
   const discoveredContractPath = findDefaultContractPath(cwd);
   const resolvedContractPath = contractPath === void 0 ? discoveredContractPath : path6__default.default.resolve(cwd, contractPath);
   if (resolvedContractPath !== void 0 && fs.existsSync(resolvedContractPath)) {
+    if (resolvedContractPath.endsWith(".ts")) {
+      throw new Error(
+        `Contract file ${resolvedContractPath} is a TypeScript file and cannot be loaded at runtime by Node.js.
+Rename it to ${resolvedContractPath.replace(/\.ts$/, ".mjs")} and use ESM syntax (export default ...), or run via \`tsx\` / \`ts-node\` as a loader.`
+      );
+    }
     const moduleUrl = url.pathToFileURL(resolvedContractPath).href;
     const moduleValue = await import(moduleUrl);
     const candidate = moduleValue.default ?? moduleValue.contract;
@@ -1192,6 +1238,9 @@ function isPlugin(value) {
 }
 async function loadPluginFromPath(pluginPath, cwd) {
   const resolvedPath = path6__default.default.resolve(cwd, pluginPath);
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Plugin not found: ${pluginPath}`);
+  }
   const moduleValue = await import(url.pathToFileURL(resolvedPath).href);
   const candidate = moduleValue.default ?? moduleValue.plugin;
   if (isPlugin(candidate)) return candidate;
@@ -1408,7 +1457,7 @@ function isClientSecret(variable, key) {
 function checkContractVariable(key, variable, context) {
   const { options, issues } = context;
   const value = options.values[key];
-  const hasValue = value !== void 0 && value.trim().length > 0;
+  const hasValue = value !== void 0 && (value !== "" || !variable.required);
   if (variable.required && !hasValue) {
     issues.push(
       createIssue({
@@ -1510,7 +1559,11 @@ function diffTypeConflicts(key, present, context) {
   for (const entry of present) {
     typeBySource.set(entry.sourceName, detectReceivedType(entry.value ?? ""));
   }
-  if (new Set(typeBySource.values()).size <= 1) return;
+  const knownTypes = /* @__PURE__ */ new Set();
+  for (const t of typeBySource.values()) {
+    if (t !== "unknown") knownTypes.add(t);
+  }
+  if (knownTypes.size <= 1) return;
   for (const [sourceName, detectedType] of typeBySource.entries()) {
     issues.push(
       createIssue({
@@ -1589,12 +1642,8 @@ function diffEnvironmentSources(options) {
       sourceName,
       value: options.sources[sourceName]?.[key]
     }));
-    const present = valuesBySource.filter(
-      (entry) => entry.value !== void 0 && entry.value !== ""
-    );
-    const missing = valuesBySource.filter(
-      (entry) => entry.value === void 0 || entry.value === ""
-    );
+    const present = valuesBySource.filter((entry) => entry.value !== void 0);
+    const missing = valuesBySource.filter((entry) => entry.value === void 0);
     if (present.length === 0 && variable?.required === true) {
       for (const entry of missing) {
         issues.push(
@@ -1681,6 +1730,7 @@ async function loadEnvSource(options) {
     return parseEnvSourceContent(content);
   } catch (error_) {
     if (options.allowMissing === true && error_ instanceof Error && "code" in error_ && error_.code === "ENOENT") {
+      warn(`Target file not found: ${options.filePath} \u2014 treating as empty`);
       return {};
     }
     throw error_;
@@ -1847,6 +1897,9 @@ async function loadCommandConfig(configPath) {
     return loadConfig(process.cwd());
   }
   const resolvedPath = path6__default.default.resolve(configPath);
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(`Config file not found: ${configPath}`);
+  }
   const configDir = path6__default.default.dirname(resolvedPath);
   const moduleValue = await import(url.pathToFileURL(resolvedPath).href);
   if (moduleValue.default === void 0) return void 0;