core-services-sdk 1.3.89 → 1.3.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.89",
+  "version": "1.3.91",
   "main": "src/index.js",
   "type": "module",
   "types": "types/index.d.ts",

package/src/env/env-validation.js

@@ -4,6 +4,10 @@ import { mask as defaultMask } from '../util/mask-sensitive.js'
 /**
  * Converts a single field definition into a Zod schema.
  *
+ * NOTE: This function does NOT apply .default() — defaults are handled
+ * manually in validateEnv so that they work correctly even when other
+ * fields fail validation.
+ *
  * @param {Object} def
  * @param {'string'|'number'|'boolean'} def.type
  *
@@ -130,10 +134,6 @@ export function defToZod(def) {
     }
   }
 
-  if (def.default !== undefined) {
-    schema = schema.default(def.default)
-  }
-
   if (!def.required) {
     schema = schema.optional()
   }
@@ -163,39 +163,56 @@ export function createZodSchema(definition) {
 /**
  * Validates values using a JSON definition and Zod.
  *
+ * Defaults are applied manually (not via Zod .default()) so that:
+ * - defaults fill in when value is undefined
+ * - existing values are always validated (never replaced by defaults)
+ * - invalid values are kept in data (with errors reported)
+ * - data is ALWAYS returned, even on failure
+ *
  * @param {Record<string, Object>} definition
  * @param {Record<string, any>} values
  *
  * @returns {{
- *   success: true,
- *   data: Record<string, any>
- * } | {
- *   success: false,
- *   summary: Record<string, string[]>
+ *   success: boolean,
+ *   data: Record<string, any>,
+ *   summary?: Record<string, string[]>
  * }}
  */
 export function validateEnv(definition, values) {
-  const schema = createZodSchema(definition)
-  const result = schema.safeParse(values)
+  const data = {}
+  const summary = {}
 
-  if (result.success) {
-    return {
-      success: true,
-      data: result.data,
+  for (const [key, def] of Object.entries(definition)) {
+    const raw = values[key]
+
+    // Validate the field individually using its Zod schema
+    const fieldSchema = defToZod(def)
+
+    // Apply default when value is undefined
+    if (raw === undefined && def.default !== undefined) {
+      const defaultResult = fieldSchema.safeParse(def.default)
+      data[key] = defaultResult.success ? defaultResult.data : def.default
+      continue
+    }
+
+    const result = fieldSchema.safeParse(raw)
+
+    if (result.success) {
+      data[key] = result.data
+    } else {
+      // Keep original value in data, record errors
+      data[key] = raw
+      summary[key] = result.error.issues.map((issue) => issue.message)
     }
   }
 
-  const summary = result.error.issues.reduce((acc, issue) => {
-    const key = issue.path[0] || 'root'
-    acc[key] = acc[key] || []
-    acc[key].push(issue.message)
-    return acc
-  }, {})
+  const success = Object.keys(summary).length === 0
 
-  return {
-    success: false,
-    summary,
+  if (success) {
+    return { success: true, data }
   }
+
+  return { success: false, data, summary }
 }
 
 /**
@@ -232,13 +249,11 @@ export function buildEnvReport(definition, values, validationResult, mask) {
     const def = definition[key]
     const isSecret = Boolean(def.secret)
 
-    // value precedence:
-    // 1. validated & parsed value
-    // 2. raw input value
-    const rawValue = values[key]
-    const value = validationResult.success
+    // Always prefer validated data (includes defaults and parsed values)
+    // Fall back to raw values only for backward compat when data is missing
+    const value = validationResult.data
       ? validationResult.data[key]
-      : rawValue
+      : values[key]
 
     const displayValue = isSecret ? maskValue(value, '.', 3) : String(value)
 
@@ -330,7 +345,7 @@ export function formatEnvReport(report) {
  *   success: boolean,
  *   validation: {
  *     success: boolean,
- *     data?: Record<string, any>,
+ *     data: Record<string, any>,
  *     summary?: Record<string, string[]>
  *   },
  *   report: {
@@ -379,7 +394,7 @@ export function validateAndReportEnv(definition, values, options = {}) {
  *   table: string,
  *   validation: {
  *     success: boolean,
- *     data?: Record<string, any>,
+ *     data: Record<string, any>,
  *     summary?: Record<string, string[]>
  *   },
  *   report: {
@@ -392,7 +407,8 @@ export function validateAndReportEnv(definition, values, options = {}) {
  *       valid: boolean,
  *       errors?: string[]
  *     }>
- *   }
+ *   },
+ *   env: Record<string, any>
  * }}
  */
 export function prepareEnvValidation(definition, values, options = {}) {
@@ -407,6 +423,7 @@ export function prepareEnvValidation(definition, values, options = {}) {
     table,
     validation,
     report,
+    env: validation.data,
   }
 }
 

package/src/rabbit-mq/start-stop-rabbitmq.js

@@ -140,17 +140,14 @@ function waitForRabbitHealthy(containerName, dockerRunCmd, ports) {
     } catch {}
 
     try {
-      execSync(
-        `docker exec ${containerName} rabbitmq-diagnostics -q ping`,
-        { stdio: 'ignore' },
-      )
+      execSync(`docker exec ${containerName} rabbitmq-diagnostics -q ping`, {
+        stdio: 'ignore',
+      })
       console.log(`[RabbitTest] RabbitMQ is ready.`)
       return
     } catch {
       if (retries % 10 === 0 && retries > 0) {
-        console.log(
-          `[RabbitTest] Still waiting... (${retries}/${maxRetries})`,
-        )
+        console.log(`[RabbitTest] Still waiting... (${retries}/${maxRetries})`)
       }
     }
 

package/tests/env/create-zod-schema.test.js

@@ -18,18 +18,19 @@ describe('createZodSchema', () => {
   it('parses valid values successfully', () => {
     const definition = {
       PORT: { type: 'number', required: true, min: 1 },
-      DEBUG: { type: 'boolean', default: false },
+      DEBUG: { type: 'boolean' },
     }
 
     const schema = createZodSchema(definition)
 
     const result = schema.parse({
       PORT: '3000',
+      DEBUG: true,
     })
 
     expect(result).toEqual({
       PORT: 3000,
-      DEBUG: false,
+      DEBUG: true,
     })
   })
 

package/tests/env/prepare-env-validation.test.js

@@ -68,6 +68,43 @@ describe('prepareEnvValidation', () => {
     expect(result.validation.data.PORT).toBe(8080)
   })
 
+  it('returns env with parsed values and defaults applied', () => {
+    const def = {
+      PORT: { type: 'number', default: 3000 },
+      DEBUG: { type: 'boolean', default: 'false' },
+      MODE: {
+        type: 'string',
+        enum: ['development', 'production'],
+        required: true,
+      },
+    }
+
+    const values = { MODE: 'production' }
+
+    const result = prepareEnvValidation(def, values)
+
+    expect(result.success).toBe(true)
+    expect(result.env).toBeDefined()
+    expect(result.env.PORT).toBe(3000)
+    expect(result.env.DEBUG).toBe(false)
+    expect(result.env.MODE).toBe('production')
+  })
+
+  it('returns env with defaults and invalid originals on failure', () => {
+    const def = {
+      PORT: { type: 'number', default: 3000 },
+      HOST: { type: 'string', format: 'url', required: true },
+    }
+
+    const values = { HOST: 'not-a-url' }
+
+    const result = prepareEnvValidation(def, values)
+
+    expect(result.success).toBe(false)
+    expect(result.env.PORT).toBe(3000)
+    expect(result.env.HOST).toBe('not-a-url')
+  })
+
   it('returns a table string even on failure', () => {
     const values = {
       PORT: 0,

package/tests/env/validate-env.test.js

@@ -90,6 +90,121 @@ describe('validateEnv', () => {
     expect(result.summary).toHaveProperty('NODE_ENV')
   })
 
+  it('always returns data even when validation fails', () => {
+    const definition = {
+      PORT: { type: 'number', default: 3000 },
+      HOST: { type: 'string', format: 'url' },
+    }
+
+    const values = {
+      HOST: 'invalid-url',
+    }
+
+    const result = validateEnv(definition, values)
+
+    expect(result.success).toBe(false)
+    expect(result.data).toBeDefined()
+    expect(result.data.PORT).toBe(3000)
+    expect(result.data.HOST).toBe('invalid-url')
+    expect(result.summary).toHaveProperty('HOST')
+  })
+
+  it('applies default when value is undefined', () => {
+    const definition = {
+      PORT: { type: 'number', default: 3000 },
+      DEBUG: { type: 'boolean', default: false },
+    }
+
+    const values = {}
+
+    const result = validateEnv(definition, values)
+
+    expect(result.success).toBe(true)
+    expect(result.data.PORT).toBe(3000)
+    expect(result.data.DEBUG).toBe(false)
+  })
+
+  it('does not replace existing value with default', () => {
+    const definition = {
+      PORT: { type: 'number', default: 3000 },
+    }
+
+    const values = { PORT: '8080' }
+
+    const result = validateEnv(definition, values)
+
+    expect(result.success).toBe(true)
+    expect(result.data.PORT).toBe(8080)
+  })
+
+  it('does not replace invalid value with default', () => {
+    const definition = {
+      PORT: { type: 'number', min: 1, default: 3000 },
+    }
+
+    const values = { PORT: 'not-a-number' }
+
+    const result = validateEnv(definition, values)
+
+    expect(result.success).toBe(false)
+    expect(result.data.PORT).toBe('not-a-number')
+    expect(result.summary).toHaveProperty('PORT')
+  })
+
+  it('parses boolean string "false" to false', () => {
+    const definition = {
+      ENABLED: { type: 'boolean' },
+    }
+
+    const values = { ENABLED: 'false' }
+
+    const result = validateEnv(definition, values)
+
+    expect(result.success).toBe(true)
+    expect(result.data.ENABLED).toBe(false)
+  })
+
+  it('parses boolean string "true" to true', () => {
+    const definition = {
+      ENABLED: { type: 'boolean' },
+    }
+
+    const values = { ENABLED: 'true' }
+
+    const result = validateEnv(definition, values)
+
+    expect(result.success).toBe(true)
+    expect(result.data.ENABLED).toBe(true)
+  })
+
+  it('parses boolean string "1" to true and "0" to false', () => {
+    const definition = {
+      A: { type: 'boolean' },
+      B: { type: 'boolean' },
+    }
+
+    const values = { A: '1', B: '0' }
+
+    const result = validateEnv(definition, values)
+
+    expect(result.success).toBe(true)
+    expect(result.data.A).toBe(true)
+    expect(result.data.B).toBe(false)
+  })
+
+  it('parses boolean default string "false" to false', () => {
+    const definition = {
+      DIGITAL_SIGNING_ENABLED: { type: 'boolean', default: 'false' },
+    }
+
+    const values = {}
+
+    const result = validateEnv(definition, values)
+
+    expect(result.success).toBe(true)
+    expect(result.data.DIGITAL_SIGNING_ENABLED).toBe(false)
+  })
+
   it('does not include summary when validation succeeds', () => {
     const definition = {
       PORT: { type: 'number', required: true },

package/types/env/env-validation.d.ts

@@ -1,6 +1,10 @@
 /**
  * Converts a single field definition into a Zod schema.
  *
+ * NOTE: This function does NOT apply .default() — defaults are handled
+ * manually in validateEnv so that they work correctly even when other
+ * fields fail validation.
+ *
  * @param {Object} def
  * @param {'string'|'number'|'boolean'} def.type
  *
@@ -59,29 +63,29 @@ export function createZodSchema(
 /**
  * Validates values using a JSON definition and Zod.
  *
+ * Defaults are applied manually (not via Zod .default()) so that:
+ * - defaults fill in when value is undefined
+ * - existing values are always validated (never replaced by defaults)
+ * - invalid values are kept in data (with errors reported)
+ * - data is ALWAYS returned, even on failure
+ *
  * @param {Record<string, Object>} definition
  * @param {Record<string, any>} values
  *
  * @returns {{
- *   success: true,
- *   data: Record<string, any>
- * } | {
- *   success: false,
- *   summary: Record<string, string[]>
+ *   success: boolean,
+ *   data: Record<string, any>,
+ *   summary?: Record<string, string[]>
  * }}
  */
 export function validateEnv(
   definition: Record<string, any>,
   values: Record<string, any>,
-):
-  | {
-      success: true
-      data: Record<string, any>
-    }
-  | {
-      success: false
-      summary: Record<string, string[]>
-    }
+): {
+  success: boolean
+  data: Record<string, any>
+  summary?: Record<string, string[]>
+}
 /**
  * Builds a structured environment validation report.
  *
@@ -177,7 +181,7 @@ export function formatEnvReport(report: {
  *   success: boolean,
  *   validation: {
  *     success: boolean,
- *     data?: Record<string, any>,
+ *     data: Record<string, any>,
  *     summary?: Record<string, string[]>
  *   },
  *   report: {
@@ -204,7 +208,7 @@ export function validateAndReportEnv(
   success: boolean
   validation: {
     success: boolean
-    data?: Record<string, any>
+    data: Record<string, any>
     summary?: Record<string, string[]>
   }
   report: {
@@ -237,7 +241,7 @@ export function validateAndReportEnv(
  *   table: string,
  *   validation: {
  *     success: boolean,
- *     data?: Record<string, any>,
+ *     data: Record<string, any>,
  *     summary?: Record<string, string[]>
  *   },
  *   report: {
@@ -250,7 +254,8 @@ export function validateAndReportEnv(
  *       valid: boolean,
  *       errors?: string[]
  *     }>
- *   }
+ *   },
+ *   env: Record<string, any>
  * }}
  */
 export function prepareEnvValidation(
@@ -264,7 +269,7 @@ export function prepareEnvValidation(
   table: string
   validation: {
     success: boolean
-    data?: Record<string, any>
+    data: Record<string, any>
     summary?: Record<string, string[]>
   }
   report: {
@@ -278,6 +283,7 @@ export function prepareEnvValidation(
       errors?: string[]
     }>
   }
+  env: Record<string, any>
 }
 /**
  * Builds a console-ready table output for environment validation.