refactor: simplify fallback treatment sanitization and type handling

Author: EmilianoSanchez

src/evaluator/fallbackTreatmentsCalculator/__tests__/fallback-sanitizer.spec.ts

@@ -11,11 +11,7 @@ describe('FallbacksSanitizer', () => {
   };
 
   beforeEach(() => {
-    jest.spyOn(console, 'error').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    (loggerMock.error as jest.Mock).mockRestore();
+    loggerMock.mockClear();
   });
 
   describe('isValidFlagName', () => {
@@ -113,24 +109,25 @@ describe('FallbacksSanitizer', () => {
       expect(loggerMock.error).not.toHaveBeenCalled();
     });
   });
+
   describe('sanitizeFallbacks', () => {
-    test('returns undefined and logs error if fallbacks is not an object', () => {
+    test('returns undefined and logs error if fallbacks is not an object', () => { // @ts-expect-error
       const result = sanitizeFallbacks(loggerMock, 'invalid_fallbacks');
       expect(result).toBeUndefined();
       expect(loggerMock.error).toHaveBeenCalledWith(
         'Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties'
       );
     });
 
-    test('returns undefined and logs error if fallbacks is not an object', () => {
+    test('returns undefined and logs error if fallbacks is not an object', () => { // @ts-expect-error
       const result = sanitizeFallbacks(loggerMock, true);
       expect(result).toBeUndefined();
       expect(loggerMock.error).toHaveBeenCalledWith(
         'Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties'
       );
     });
 
-    test('sanitizes both global and byFlag fallbacks for empty object', () => {
+    test('sanitizes both global and byFlag fallbacks for empty object', () => { // @ts-expect-error
       const result = sanitizeFallbacks(loggerMock, { global: {} });
       expect(result).toEqual({ global: undefined, byFlag: {} });
     });

src/evaluator/fallbackTreatmentsCalculator/fallbackSanitizer/index.ts

@@ -33,14 +33,15 @@ function sanitizeGlobal(logger: ILogger, treatment?: Treatment | TreatmentWithCo
 
 function sanitizeByFlag(
   logger: ILogger,
-  byFlagFallbacks: Record<string, Treatment | TreatmentWithConfig> = {}
+  byFlagFallbacks?: Record<string, Treatment | TreatmentWithConfig>
 ): Record<string, Treatment | TreatmentWithConfig> {
   const sanitizedByFlag: Record<string, Treatment | TreatmentWithConfig> = {};
 
-  const entries = Object.keys(byFlagFallbacks);
-  entries.forEach((flag) => {
-    const t = byFlagFallbacks[flag];
-    if (!t) return;
+  if (!isObject(byFlagFallbacks)) return sanitizedByFlag;
+
+  Object.keys(byFlagFallbacks!).forEach((flag) => {
+    const t = byFlagFallbacks![flag];
+
     if (!isValidFlagName(flag)) {
       logger.error(`Fallback treatments - Discarded flag '${flag}': ${FallbackDiscardReason.FlagName}`);
       return;
@@ -57,14 +58,14 @@ function sanitizeByFlag(
   return sanitizedByFlag;
 }
 
-export function sanitizeFallbacks(logger: ILogger, fallbacks: unknown): FallbackTreatmentConfiguration | undefined {
+export function sanitizeFallbacks(logger: ILogger, fallbacks: FallbackTreatmentConfiguration): FallbackTreatmentConfiguration | undefined {
   if (!isObject(fallbacks)) {
     logger.error('Fallback treatments - Discarded configuration: it must be an object with optional `global` and `byFlag` properties');
     return;
   }
 
   return {
-    global: sanitizeGlobal(logger, (fallbacks as FallbackTreatmentConfiguration).global),
-    byFlag: sanitizeByFlag(logger, (fallbacks as FallbackTreatmentConfiguration).byFlag)
+    global: sanitizeGlobal(logger, fallbacks.global),
+    byFlag: sanitizeByFlag(logger, fallbacks.byFlag)
   };
 }

src/evaluator/fallbackTreatmentsCalculator/index.ts

@@ -9,7 +9,11 @@ export type IFallbackTreatmentsCalculator = {
 export const FALLBACK_PREFIX = 'fallback - ';
 
 export class FallbackTreatmentsCalculator implements IFallbackTreatmentsCalculator {
-  constructor(private readonly fallbacks: FallbackTreatmentConfiguration = {}) {}
+  private readonly fallbacks: FallbackTreatmentConfiguration;
+
+  constructor(fallbacks: FallbackTreatmentConfiguration = {}) {
+    this.fallbacks = fallbacks;
+  }
 
   resolve(flagName: string, label: string): TreatmentWithConfig & { label: string } {
     const treatment = this.fallbacks.byFlag?.[flagName];