core-services-sdk 1.3.77 → 1.3.80

package/package.json

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

package/src/env/env-validation.js

@@ -240,7 +240,7 @@ export function buildEnvReport(definition, values, validationResult, mask) {
       ? validationResult.data[key]
       : rawValue
 
-    const displayValue = isSecret ? maskValue(value) : String(value)
+    const displayValue = isSecret ? maskValue(value, '.', 3) : String(value)
 
     const errors = validationResult.success
       ? undefined
@@ -409,3 +409,82 @@ export function prepareEnvValidation(definition, values, options = {}) {
     report,
   }
 }
+
+/**
+ * Builds a console-ready table output for environment validation.
+ *
+ * Always includes all variables.
+ * NOTES column always has a value:
+ * - 'OK' for valid variables
+ * - error message(s) for invalid variables
+ *
+ * @param {{
+ *   params: Array<{
+ *     key: string,
+ *     displayValue: string,
+ *     valid: boolean,
+ *     errors?: string[]
+ *   }>
+ * }} report
+ *
+ * @returns {string}
+ */
+export function buildConsoleOutput(report) {
+  const headers = ['STATUS', 'KEY', 'VALUE', 'NOTES']
+
+  const rows = report.params.map((p) => {
+    const status = p.valid ? 'OK' : 'ERROR'
+    const notes = p.valid ? 'OK' : p.errors?.join('; ') || 'Invalid value'
+
+    return [status, p.key, p.displayValue, notes]
+  })
+
+  const allRows = [headers, ...rows]
+
+  const colWidths = headers.map((_, i) =>
+    Math.max(...allRows.map((row) => String(row[i]).length)),
+  )
+
+  const formatRow = (row) =>
+    row.map((cell, i) => String(cell).padEnd(colWidths[i])).join('  ')
+
+  return [
+    'Environment variables',
+    '',
+    ...allRows.map(formatRow),
+    '',
+    report.params.every((p) => p.valid)
+      ? 'All variables are valid.'
+      : 'Some variables are invalid.',
+  ].join('\n')
+}
+
+/**
+ * Validates environment variables and prepares
+ * a fully printable console output.
+ *
+ * @param {Record<string, Object>} definition
+ * @param {Record<string, any>} values
+ * @param {{
+ *   mask?: (value: any) => string
+ * }} [options]
+ *
+ * @returns {{
+ *   success: boolean,
+ *   output: string,
+ *   report: any
+ * }}
+ */
+export function validateEnvForConsole(definition, values, options = {}) {
+  const { mask } = options
+
+  const validation = validateEnv(definition, values)
+  const report = buildEnvReport(definition, values, validation, mask)
+  const output = buildConsoleOutput(report)
+
+  return {
+    output,
+    report,
+    success: validation.success,
+  }
+}

package/src/util/mask-sensitive.js

@@ -17,7 +17,9 @@ export const maskSingle = (
   if (value == null) {
     return ''
   }
+
   const str = String(value)
+
   if (str.length === 0) {
     return ''
   }
@@ -25,16 +27,20 @@ export const maskSingle = (
   if (typeof value === 'boolean') {
     return str
   }
-  const m =
-    null === maskLen ? Math.max(1, str.length - (right + left)) : maskLen
+
+  // default: max 3 mask characters
+  const calculated = Math.max(1, str.length - (left + right))
+  const m = maskLen == null ? Math.min(3, calculated) : Math.max(0, maskLen)
 
   if (str.length <= left + right) {
     if (str.length === 1) {
       return fill
     }
+
     if (str.length === 2) {
-      return str[0] + fill.repeat(1) // "ab" -> "a.."
+      return str[0] + fill
     }
+
     return str.slice(0, 1) + fill.repeat(m) + str.slice(-1)
   }
 

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

@@ -2,6 +2,8 @@ import { describe, it, expect } from 'vitest'
 import { prepareEnvValidation } from '../../src/env/env-validation.js'
 
 describe('prepareEnvValidation', () => {
+  const mask = () => '****'
+
   const definition = {
     PORT: {
       type: 'number',
@@ -31,13 +33,8 @@ describe('prepareEnvValidation', () => {
     const result = prepareEnvValidation(definition, values, { mask })
 
     expect(result.success).toBe(true)
-    expect(result.validation.success).toBe(true)
-
     expect(result.table).toContain('Environment variables')
     expect(result.table).toContain('PORT')
-    expect(result.table).toContain('MODE')
-    expect(result.table).toContain('API_KEY')
-
     expect(result.table).toContain('OK')
     expect(result.table).toContain('****')
     expect(result.table).not.toContain('secret')
@@ -67,6 +64,7 @@ describe('prepareEnvValidation', () => {
     const result = prepareEnvValidation(definition, values)
 
     expect(result.success).toBe(true)
+    // @ts-ignore
     expect(result.validation.data.PORT).toBe(8080)
   })
 

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

@@ -0,0 +1,122 @@
+import { describe, it, expect } from 'vitest'
+import { validateEnvForConsole } from '../../src/env/env-validation.js'
+
+describe('validateEnvForConsole', () => {
+  const definition = {
+    PORT: {
+      type: 'number',
+      required: true,
+      int: true,
+      min: 1,
+      max: 65535,
+    },
+    MODE: {
+      type: 'string',
+      enum: ['development', 'production'],
+      required: true,
+    },
+    API_KEY: {
+      type: 'string',
+      secret: true,
+    },
+  }
+
+  const mask = () => '****'
+
+  it('returns a printable table with all variables and OK notes when valid', () => {
+    const values = {
+      PORT: '3000',
+      MODE: 'development',
+      API_KEY: 'secret',
+    }
+
+    const result = validateEnvForConsole(definition, values, { mask })
+
+    expect(result.success).toBe(true)
+    expect(typeof result.output).toBe('string')
+
+    // header
+    expect(result.output).toContain('Environment variables')
+    expect(result.output).toContain('STATUS')
+    expect(result.output).toContain('KEY')
+    expect(result.output).toContain('VALUE')
+    expect(result.output).toContain('NOTES')
+
+    // rows
+    expect(result.output).toContain('PORT')
+    expect(result.output).toContain('MODE')
+    expect(result.output).toContain('API_KEY')
+
+    // notes always present
+    expect(result.output).toContain('OK      PORT')
+    expect(result.output).toContain('OK      MODE')
+    expect(result.output).toContain('OK      API_KEY')
+
+    // masking
+    expect(result.output).toContain('****')
+    expect(result.output).not.toContain('secret')
+  })
+
+  it('returns a printable table with ERROR notes when invalid', () => {
+    const values = {
+      PORT: '0',
+      MODE: 'prod',
+      API_KEY: 'secret',
+    }
+
+    const result = validateEnvForConsole(definition, values, { mask })
+
+    expect(result.success).toBe(false)
+    expect(typeof result.output).toBe('string')
+
+    // all variables still appear
+    expect(result.output).toContain('PORT')
+    expect(result.output).toContain('MODE')
+    expect(result.output).toContain('API_KEY')
+
+    // error rows
+    expect(result.output).toContain('ERROR   PORT')
+    expect(result.output).toContain('ERROR   MODE')
+
+    // notes are NOT empty
+    expect(result.output).toMatch(/PORT\s+0\s+.+/)
+    expect(result.output).toMatch(/MODE\s+prod\s+.+/)
+
+    // summary line
+    expect(result.output).toContain('Some variables are invalid.')
+  })
+
+  it('always sets NOTES to OK for valid variables even if others fail', () => {
+    const values = {
+      PORT: '3000',
+      MODE: 'prod', // invalid
+      API_KEY: 'secret',
+    }
+
+    const result = validateEnvForConsole(definition, values, { mask })
+
+    // PORT and API_KEY are valid → NOTES = OK
+    expect(result.output).toMatch(/OK\s+PORT\s+3000\s+OK/)
+    expect(result.output).toMatch(/OK\s+API_KEY\s+\*\*\*\*\s+OK/)
+
+    // MODE is invalid → NOTES = error message
+    expect(result.output).toMatch(/ERROR\s+MODE\s+prod\s+.+/)
+  })
+
+  it('always returns output even if multiple errors exist', () => {
+    const values = {
+      MODE: 'prod',
+    }
+
+    const result = validateEnvForConsole(definition, values)
+
+    expect(result.success).toBe(false)
+    expect(typeof result.output).toBe('string')
+    expect(result.output.length).toBeGreaterThan(0)
+
+    // all keys still listed
+    expect(result.output).toContain('PORT')
+    expect(result.output).toContain('MODE')
+    expect(result.output).toContain('API_KEY')
+  })
+})

package/tests/util/mask-sensitive.unit.test.js

@@ -5,11 +5,11 @@ import { mask, maskSingle } from '../../src/util/index.js'
 describe('maskSingle', () => {
   it('masks middle of a regular string (length == left+right)', () => {
     const value = maskSingle('abcdefgh')
-    expect(value).toBe('ab....gh')
+    expect(value).toBe('ab...gh')
   })
 
   it('masks numbers with default settings', () => {
-    expect(maskSingle(12345678)).toBe('12....78')
+    expect(maskSingle(12345678)).toBe('12...78')
   })
 
   it('masks booleans', () => {
@@ -45,8 +45,8 @@ describe('maskSingle', () => {
 
 describe('mask', () => {
   it('masks primitives (string, number, boolean)', () => {
-    expect(mask('abcdefgh')).toBe('ab....gh')
-    expect(mask(12345678)).toBe('12....78')
+    expect(mask('abcdefgh')).toBe('ab...gh')
+    expect(mask(12345678)).toBe('12...78')
     const trueValue = mask(true)
     expect(trueValue).toBe('true')
     expect(mask(false)).toBe('false')
@@ -59,20 +59,20 @@ describe('mask', () => {
 
   it('masks arrays recursively', () => {
     const value = mask(['abcdefgh', 12345678])
-    expect(value).toEqual(['ab....gh', '12....78'])
+    expect(value).toEqual(['ab...gh', '12...78'])
   })
 
   it('masks objects recursively', () => {
     expect(mask({ a: 'abcdefgh', b: 12345678 })).toEqual({
-      a: 'ab....gh',
-      b: '12....78',
+      a: 'ab...gh',
+      b: '12...78',
     })
   })
 
   it('masks nested objects/arrays recursively', () => {
     const input = { arr: ['abcdefgh', { num: 12345678 }] }
     const expected = { arr: ['ab....gh', { num: '12....78' }] }
-    const value = mask(input)
+    const value = mask(input, undefined, 4)
     expect(value).toEqual(expected)
   })
 
@@ -96,4 +96,25 @@ describe('mask', () => {
     const value = mask(input, '*', 3)
     expect(value).toEqual(expected)
   })
+
+  it('limits default mask to max 3 characters', () => {
+    const value = maskSingle('abcdefghijklmnop')
+    expect(value).toBe('ab...op')
+  })
+
+  it('does not exceed available middle length', () => {
+    const value = maskSingle('abcde') // left=2 right=2 → middle=1
+    expect(value).toBe('ab.de')
+  })
+
+  it('allows maskLen = 0', () => {
+    const value = maskSingle('abcdefgh', '.', 0)
+    expect(value).toBe('abgh')
+  })
+
+  it('handles Date inside object', () => {
+    const d = new Date('2025-01-01T00:00:00.000Z')
+    const value = mask({ date: d })
+    expect(value).toEqual({ date: d.toISOString() })
+  })
 })

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

@@ -279,3 +279,57 @@ export function prepareEnvValidation(
     }>
   }
 }
+/**
+ * Builds a console-ready table output for environment validation.
+ *
+ * Always includes all variables.
+ * NOTES column always has a value:
+ * - 'OK' for valid variables
+ * - error message(s) for invalid variables
+ *
+ * @param {{
+ *   params: Array<{
+ *     key: string,
+ *     displayValue: string,
+ *     valid: boolean,
+ *     errors?: string[]
+ *   }>
+ * }} report
+ *
+ * @returns {string}
+ */
+export function buildConsoleOutput(report: {
+  params: Array<{
+    key: string
+    displayValue: string
+    valid: boolean
+    errors?: string[]
+  }>
+}): string
+/**
+ * Validates environment variables and prepares
+ * a fully printable console output.
+ *
+ * @param {Record<string, Object>} definition
+ * @param {Record<string, any>} values
+ * @param {{
+ *   mask?: (value: any) => string
+ * }} [options]
+ *
+ * @returns {{
+ *   success: boolean,
+ *   output: string,
+ *   report: any
+ * }}
+ */
+export function validateEnvForConsole(
+  definition: Record<string, any>,
+  values: Record<string, any>,
+  options?: {
+    mask?: (value: any) => string
+  },
+): {
+  success: boolean
+  output: string
+  report: any
+}