core-services-sdk 1.3.16 → 1.3.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.16",
+  "version": "1.3.18",
   "main": "src/index.js",
   "type": "module",
   "scripts": {

package/src/core/index.js

@@ -1,6 +1,7 @@
 export * from './regex-utils.js'
 export * from './otp-generators.js'
 export * from './sanitize-objects.js'
+export * from './normalize-min-max.js'
 export * from './normalize-to-array.js'
 export * from './combine-unique-arrays.js'
 export * from './normalize-phone-number.js'

package/src/core/normalize-min-max.js

@@ -0,0 +1,62 @@
+/**
+ * Normalize minimum and maximum numeric policy values against defaults.
+ *
+ * This utility ensures:
+ * - Fallback to `defaultMinMax` if `valuesMinMax` is not provided or invalid.
+ * - Both `min` and `max` are clamped to stay within the default range.
+ * - Guarantees `min <= max` by adjusting `max` when necessary.
+ *
+ * @param {{ min: number, max: number }} defaultMinMax
+ *        The default minimum and maximum values. These act as the allowed range boundaries.
+ *
+ * @param {{ min?: number, max?: number } | null | undefined} valuesMinMax
+ *        Custom minimum and/or maximum values. May be partial, null, or undefined.
+ *        Non-numeric inputs are ignored in favor of the default values.
+ *
+ * @returns {{ min: number, max: number }}
+ *          Normalized min and max values that respect the defaults and guarantee a valid range.
+ *
+ * @example
+ * // Within range, keeps given values
+ * normalizeMinMax({ min: 8, max: 64 }, { min: 10, max: 32 })
+ * // → { min: 10, max: 32 }
+ *
+ * @example
+ * // If min > max, coerces max to be at least min
+ * normalizeMinMax({ min: 8, max: 64 }, { min: 60, max: 20 })
+ * // → { min: 60, max: 60 }
+ *
+ * @example
+ * // Values outside default range are clamped
+ * normalizeMinMax({ min: 8, max: 64 }, { min: 4, max: 100 })
+ * // → { min: 8, max: 64 }
+ *
+ * @example
+ * // Missing or invalid input falls back to defaults
+ * normalizeMinMax({ min: 8, max: 64 }, null)
+ * // → { min: 8, max: 64 }
+ */
+export const normalizeMinMax = (defaultMinMax, valuesMinMax) => {
+  if (!valuesMinMax || typeof valuesMinMax !== 'object') {
+    return { ...defaultMinMax }
+  }
+
+  const { min, max } = valuesMinMax
+  const valuesMinMaxFixed = {
+    min: typeof min === 'number' ? min : defaultMinMax.min,
+    max: typeof max === 'number' ? max : defaultMinMax.max,
+  }
+
+  const minMax = {
+    min: Math.min(
+      Math.max(valuesMinMaxFixed.min, defaultMinMax.min),
+      defaultMinMax.max,
+    ),
+    max: Math.min(valuesMinMaxFixed.max, defaultMinMax.max),
+  }
+
+  return {
+    min: minMax.min,
+    max: minMax.min > minMax.max ? minMax.min : minMax.max,
+  }
+}

package/src/logger/get-logger.js

@@ -1,12 +1,16 @@
 import pino from 'pino'
 
-const requiredMethods = ['info', 'warn', 'error', 'debug']
+const requiredMethods = ['info', 'warn', 'error', 'debug', 'fatal', 'trace']
 
 const dummyLogger = {
   info: () => {},
   warn: () => {},
-  error: () => {},
+  trace: () => {},
   debug: () => {},
+  error: () => {},
+  fatal: () => {},
+  levels: () => {},
+  silent: () => {},
   child() {
     return this
   },

package/tests/core/normalize-min-max.unit.test.js

@@ -0,0 +1,83 @@
+// tests/unit/utils/normalize-min-max.unit.test.js
+import { describe, it, expect } from 'vitest'
+import { normalizeMinMax } from '../../src/core/normalize-min-max.js'
+
+describe('normalizeMinMax', () => {
+  const defaults = { min: 8, max: 64 }
+
+  it('returns defaults if valuesMinMax is null', () => {
+    expect(normalizeMinMax(defaults, null)).toEqual(defaults)
+  })
+
+  it('returns defaults if valuesMinMax is undefined', () => {
+    expect(normalizeMinMax(defaults, undefined)).toEqual(defaults)
+  })
+
+  it('returns defaults if valuesMinMax is not an object', () => {
+    // @ts-ignore
+    expect(normalizeMinMax(defaults, 'invalid')).toEqual(defaults)
+  })
+
+  it('uses provided values when within range', () => {
+    expect(normalizeMinMax(defaults, { min: 10, max: 32 })).toEqual({
+      min: 10,
+      max: 32,
+    })
+  })
+
+  it('clamps values below minimum to default.min', () => {
+    expect(normalizeMinMax(defaults, { min: 4, max: 20 })).toEqual({
+      min: 8,
+      max: 20,
+    })
+  })
+
+  it('clamps values above maximum to default.max', () => {
+    expect(normalizeMinMax(defaults, { min: 20, max: 100 })).toEqual({
+      min: 20,
+      max: 64,
+    })
+  })
+
+  it('ensures max is not lower than min', () => {
+    expect(normalizeMinMax(defaults, { min: 60, max: 20 })).toEqual({
+      min: 60,
+      max: 60,
+    })
+  })
+
+  it('falls back to defaults if min is not a number', () => {
+    // @ts-ignore
+    expect(normalizeMinMax(defaults, { min: 'abc', max: 32 })).toEqual({
+      min: 8,
+      max: 32,
+    })
+  })
+
+  it('falls back to defaults if max is not a number', () => {
+    // @ts-ignore
+    expect(normalizeMinMax(defaults, { min: 10, max: 'zzz' })).toEqual({
+      min: 10,
+      max: 64,
+    })
+  })
+
+  it('handles partial input (only min provided)', () => {
+    expect(normalizeMinMax(defaults, { min: 12 })).toEqual({
+      min: 12,
+      max: 64,
+    })
+  })
+
+  it('handles partial input (only max provided)', () => {
+    expect(normalizeMinMax(defaults, { max: 30 })).toEqual({
+      min: 8,
+      max: 30,
+    })
+  })
+
+  it('returns defaults if both values are invalid', () => {
+    // @ts-ignore
+    expect(normalizeMinMax(defaults, { min: 'a', max: null })).toEqual(defaults)
+  })
+})

package/tests/logger/get-logger.unit.test.js

@@ -29,34 +29,42 @@ describe('getLogger', () => {
       warn: vi.fn(),
       error: vi.fn(),
       debug: vi.fn(),
+      fatal: vi.fn(),
+      trace: vi.fn(),
     }
 
     const result = getLogger({ logger: mockLogger })
     expect(result).toBe(mockLogger)
   })
 
-  it('returns the dummy logger when logger is invalid', () => {
-    const invalidLogger = { info: () => {}, warn: () => {} } // missing 'error' and 'debug'
+  it('returns the dummy logger when logger is invalid (missing methods)', () => {
+    const invalidLogger = { info: () => {}, warn: () => {} } // missing required methods
     const logger = getLogger({ logger: invalidLogger })
 
     expect(logger.info).toBeDefined()
     expect(logger.warn).toBeDefined()
     expect(logger.error).toBeDefined()
     expect(logger.debug).toBeDefined()
+    expect(logger.fatal).toBeDefined()
+    expect(logger.trace).toBeDefined()
 
-    // Check that it's the dummy logger (no-op)
+    // dummy logger methods are no-ops
     expect(() => logger.info('hello')).not.toThrow()
     // @ts-ignore
     expect(logger.info()).toBeUndefined()
   })
 
-  it('returns the dummy logger when called with invalid object', () => {
+  it('returns the dummy logger when called with unrelated object', () => {
     const result = getLogger({ someOtherKey: 123 })
     expect(result.info).toBeDefined()
     expect(result.warn).toBeDefined()
+    expect(result.error).toBeDefined()
+    expect(result.debug).toBeDefined()
+    expect(result.fatal).toBeDefined()
+    expect(result.trace).toBeDefined()
   })
 
-  it('logs a message when using internal pino', () => {
+  it('logs a message when using internal pino with level warn', () => {
     const logger = getLogger({ logger: true, level: 'warn' })
     // @ts-ignore
     expect(logger.level).toBe('warn')