@bymax-one/nest-config 1.2.1 → 1.2.3

package/dist/testing/index.mjs

@@ -1,4 +1,4 @@
-import { createValidatedConfig, BymaxConfigModule, resolveSourceNames } from '@bymax-one/nest-config/internal';
+import { BymaxConfigModule, assertDistinctVariables, resolveSourceNames, createValidatedConfig, BymaxConfigValidationError } from '@bymax-one/nest-config/internal';
 
 // src/testing/create-test-config.ts
 var FILLER_CHARACTER = "a";
@@ -7,6 +7,10 @@ var PLACEHOLDER_EMAIL_DOMAIN = "@placeholder.local";
 var DEFAULT_NUMBER = 1;
 var DEFAULT_STRING_LENGTH = 1;
 var PLACEHOLDER_BOOLEAN = "true";
+var PLACEHOLDER_UUID = "00000000-0000-4000-8000-000000000000";
+var PLACEHOLDER_DATETIME = "2000-01-01T00:00:00.000Z";
+var PLACEHOLDER_DATE = "2000-01-01";
+var PLACEHOLDER_TIME = "00:00:00";
 function readDef(leaf) {
   return leaf._zod.def;
 }
@@ -57,11 +61,23 @@ function synthesizePlainString(lengths) {
   const bounded = target > lengths.max ? lengths.max : target;
   return FILLER_CHARACTER.repeat(bounded);
 }
+function formatOf(def) {
+  const declared = checksOf(def).map((wrapper) => wrapper._zod.def).find((check) => check.check === "string_format");
+  return def.format ?? declared?.format;
+}
+var FIXED_FORMATS = /* @__PURE__ */ new Map([
+  ["uuid", PLACEHOLDER_UUID],
+  ["datetime", PLACEHOLDER_DATETIME],
+  ["date", PLACEHOLDER_DATE],
+  ["time", PLACEHOLDER_TIME]
+]);
 function synthesizeString(def) {
   const lengths = readStringLengths(def);
-  if (def.format === "url") return synthesizeUrl(lengths);
-  if (def.format === "email") return synthesizeEmail(lengths);
-  return synthesizePlainString(lengths);
+  const format = formatOf(def);
+  if (format === "url") return synthesizeUrl(lengths);
+  if (format === "email") return synthesizeEmail(lengths);
+  const fixed = format === void 0 ? void 0 : FIXED_FORMATS.get(format);
+  return fixed ?? synthesizePlainString(lengths);
 }
 function selectNumber(bounds) {
   const { lower, upper, integer } = bounds;
@@ -97,20 +113,35 @@ function synthesizeEnum(def) {
   const [first] = Object.values(def.entries);
   return String(first);
 }
+function withoutOptional(leaf) {
+  const def = readDef(leaf);
+  return def.type === "optional" ? withoutOptional(def.innerType) : leaf;
+}
 function synthesizeLeaf(leaf) {
   const def = readDef(leaf);
   switch (def.type) {
     case "default":
+    case "prefault":
+    case "catch":
     case "optional":
       return void 0;
     case "nullable":
+    case "readonly":
       return synthesizeLeaf(def.innerType);
+    case "nonoptional":
+      return synthesizeLeaf(withoutOptional(def.innerType));
+    case "pipe":
+      return readDef(def.out).type === "boolean" && readDef(def.in).type === "string" ? PLACEHOLDER_BOOLEAN : synthesizeLeaf(def.in);
     case "string":
       return synthesizeString(def);
     case "number":
       return synthesizeNumber(def);
     case "boolean":
       return PLACEHOLDER_BOOLEAN;
+    case "date":
+      return PLACEHOLDER_DATETIME;
+    case "literal":
+      return String(def.values[0]);
     case "enum":
       return synthesizeEnum(def);
     default:
@@ -143,25 +174,44 @@ function flattenOverrides(overrides) {
   }
   return flat;
 }
-function applyOverrides(schema, base, overrides) {
+function applyOverrides(schema, base, overrides, overridden) {
   const flat = flattenOverrides(overrides ?? {});
   const entries = new Map(Object.entries(base));
   for (const binding of resolveSourceNames(schema)) {
     const value = flat.get(binding.path);
-    if (value !== void 0) entries.set(binding.variable, String(value));
+    if (value === void 0) continue;
+    entries.set(binding.variable, String(value));
+    overridden.add(binding.variable);
   }
   const source = /* @__PURE__ */ Object.create(null);
   for (const [variable, value] of entries) source[variable] = value;
   return source;
 }
-function buildTestSource(schema, overrides) {
-  return applyOverrides(schema, synthesizePlaceholderSource(schema), overrides);
+function explainUnsatisfiedLeaves(error, overridden) {
+  return new BymaxConfigValidationError(
+    error.issues.map(
+      (issue) => !issue.path.includes(".") || overridden.has(issue.variable) ? issue : {
+        ...issue,
+        message: `no placeholder satisfies this leaf (${issue.message}); pass an override for ${issue.path}`
+      }
+    )
+  );
+}
+function prepareTestConfig(schema, overrides) {
+  assertDistinctVariables(resolveSourceNames(schema));
+  const overridden = /* @__PURE__ */ new Set();
+  const source = applyOverrides(schema, synthesizePlaceholderSource(schema), overrides, overridden);
+  try {
+    return { source, config: createValidatedConfig({ schema, source }) };
+  } catch (error) {
+    throw error instanceof BymaxConfigValidationError ? explainUnsatisfiedLeaves(error, overridden) : error;
+  }
 }
 function createTestConfig(schema, overrides) {
-  return createValidatedConfig({ schema, source: buildTestSource(schema, overrides) });
+  return prepareTestConfig(schema, overrides).config;
 }
 function configTestingModule(schema, overrides) {
-  const source = buildTestSource(schema, overrides);
+  const { source } = prepareTestConfig(schema, overrides);
   return BymaxConfigModule.forRoot({ schema, source });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bymax-one/nest-config",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Typed and validated environment configuration entry point for NestJS 11 applications, built on Zod v4.",
   "author": "Bymax One <support@bymax.one>",
   "license": "MIT",