Rename validation utils

AI-Session-Id: 32df18f1-ed0a-4979-bd0d-eb46df9d5c91
AI-Tool: claude-code
AI-Model: unknown

Author: EmilianoSanchez

src/sdkClient/clientInputValidation.ts

@@ -4,8 +4,8 @@ import {
   validateEventValue,
   validateEventProperties,
   validateKey,
-  validateSplit,
-  validateSplits,
+  validateDefinition,
+  validateDefinitions,
   validateTrafficType,
   validateIfNotDestroyed,
   validateIfReadyFromCache,
@@ -39,8 +39,8 @@ export function clientInputValidationDecorator<TClient extends SplitIO.IClient |
     const nameOrNames = methodName.indexOf('ByFlagSet') > -1 ?
       validateFlagSets(log, methodName, maybeNameOrNames as string[], settings.sync.__splitFiltersValidation.groupedFilters.bySet) :
       startsWith(methodName, GET_TREATMENTS) ?
-        validateSplits(log, maybeNameOrNames, methodName) :
-        validateSplit(log, maybeNameOrNames, methodName);
+        validateDefinitions(log, maybeNameOrNames, methodName) :
+        validateDefinition(log, maybeNameOrNames, methodName);
 
     const attributes = validateAttributes(log, maybeAttributes, methodName);
     const isNotDestroyed = validateIfNotDestroyed(log, readinessManager, methodName);

src/sdkManager/index.ts

@@ -1,7 +1,7 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import { thenable } from '../utils/promise/thenable';
 import { find } from '../utils/lang';
-import { validateSplit, validateDefinitionExistence, validateIfOperational } from '../utils/inputValidation';
+import { validateDefinition, validateDefinitionExistence, validateIfOperational } from '../utils/inputValidation';
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { IDefinition } from '../dtos/types';
@@ -65,7 +65,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
        * Get the feature flag object corresponding to the given feature flag name if valid
        */
       split(featureFlagName: string) {
-        const splitName = validateSplit(log, featureFlagName, SPLIT_FN_LABEL);
+        const splitName = validateDefinition(log, featureFlagName, SPLIT_FN_LABEL);
         if (!validateIfOperational(log, readinessManager, SPLIT_FN_LABEL) || !splitName) {
           return isAsync ? Promise.resolve(null) : null;
         }

src/utils/inputValidation/__tests__/definition.spec.ts

@@ -0,0 +1,71 @@
+import { ERROR_INVALID, ERROR_NULL, ERROR_EMPTY, WARN_TRIMMING } from '../../../logger/constants';
+import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
+
+import { validateDefinition } from '../definition';
+
+const invalidDefinitions = [
+  { definition: [], msg: ERROR_INVALID },
+  { definition: () => { }, msg: ERROR_INVALID },
+  { definition: Object.create({}), msg: ERROR_INVALID },
+  { definition: {}, msg: ERROR_INVALID },
+  { definition: true, msg: ERROR_INVALID },
+  { definition: false, msg: ERROR_INVALID },
+  { definition: 10, msg: ERROR_INVALID },
+  { definition: 0, msg: ERROR_INVALID },
+  { definition: NaN, msg: ERROR_INVALID },
+  { definition: Infinity, msg: ERROR_INVALID },
+  { definition: null, msg: ERROR_NULL },
+  { definition: undefined, msg: ERROR_NULL },
+  { definition: new Promise(res => res), msg: ERROR_INVALID },
+  { definition: Symbol('asd'), msg: ERROR_INVALID },
+  { definition: '', msg: ERROR_EMPTY }
+];
+
+const trimmableDefinitions = [
+  '  splitName  ',
+  'split_name2   \n  ',
+  ' split_name3'
+];
+
+describe('INPUT VALIDATION for definition name', () => {
+
+  afterEach(() => { loggerMock.mockClear(); });
+
+  test('Should return the provided definition name if it is a valid string without logging any errors', () => {
+    expect(validateDefinition(loggerMock, 'definitionName', 'some_method')).toBe('definitionName');
+    expect(loggerMock.error.mock.calls[0]).not.toEqual('some_method');
+    expect(validateDefinition(loggerMock, 'definition_name', 'some_method')).toBe('definition_name');
+    expect(loggerMock.error.mock.calls[0]).not.toEqual('some_method');
+    expect(validateDefinition(loggerMock, 'A_definition-name_29', 'some_method')).toBe('A_definition-name_29');
+    expect(loggerMock.error.mock.calls[0]).not.toEqual('some_method');
+
+    expect(loggerMock.warn).not.toBeCalled();
+  });
+
+  test('Should trim definition name if it is a valid string with trimmable spaces and log a warning', () => {
+    for (let i = 0; i < trimmableDefinitions.length; i++) {
+      const trimmableDefinition = trimmableDefinitions[i];
+      expect(validateDefinition(loggerMock, trimmableDefinition, 'some_method')).toBe(trimmableDefinition.trim());
+      expect(loggerMock.warn).toBeCalledWith(WARN_TRIMMING, ['some_method', 'feature flag name', trimmableDefinition]);
+
+      loggerMock.warn.mockClear();
+    }
+
+    expect(loggerMock.error).not.toBeCalled();
+  });
+
+  test('Should return false and log error if definition name is not a valid string', () => {
+    for (let i = 0; i < invalidDefinitions.length; i++) {
+      const invalidValue = invalidDefinitions[i]['definition'];
+      // @ts-ignore
+      const expectedLog = invalidDefinitions[i]['msg'];
+
+      expect(validateDefinition(loggerMock, invalidValue, 'test_method')).toBe(false);
+      expect(loggerMock.error).toBeCalledWith(expectedLog, ['test_method', 'feature flag name']);
+
+      loggerMock.error.mockClear();
+    }
+
+    expect(loggerMock.warn).not.toBeCalled();
+  });
+});

src/utils/inputValidation/__tests__/definitions.spec.ts

@@ -0,0 +1,87 @@
+import uniq from 'lodash/uniq';
+import startsWith from 'lodash/startsWith';
+
+// mocks sdkLogger
+import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
+import { ERROR_EMPTY_ARRAY } from '../../../logger/constants';
+
+// mocks validateDefinition
+jest.mock('../definition');
+import { validateDefinition } from '../definition';
+const validateDefinitionMock = validateDefinition as jest.Mock;
+validateDefinitionMock.mockImplementation((_, maybeDefinition) => maybeDefinition);
+
+// test target
+import { validateDefinitions } from '../definitions';
+
+const invalidDefinitions = [
+  [],
+  {},
+  Object.create({}),
+  () => { },
+  false,
+  true,
+  5,
+  'something',
+  NaN,
+  -Infinity,
+  new Promise(res => res),
+  Symbol('asd'),
+  null,
+  undefined,
+  NaN
+];
+
+describe('INPUT VALIDATION for definition names', () => {
+
+  afterEach(() => {
+    loggerMock.mockClear();
+    validateDefinitionMock.mockClear();
+  });
+
+  test('Should return the provided array if it is a valid definition names array without logging any errors', () => {
+    const validArr = ['definitionName1', 'definition_name_2', 'definition-name-3'];
+
+    expect(validateDefinitions(loggerMock, validArr, 'some_method')).toEqual(validArr);
+    expect(validateDefinitionMock).toBeCalledTimes(validArr.length);
+    expect(loggerMock.error).not.toBeCalled();
+
+    expect(loggerMock.warn).not.toBeCalled();
+  });
+
+  test('Should return the provided array if it is a valid definition names array removing duplications, without logging any errors', () => {
+    const validArr = ['definition_name', 'definition_name', 'definition-name'];
+
+    expect(validateDefinitions(loggerMock, validArr, 'some_method')).toEqual(uniq(validArr));
+    expect(validateDefinitionMock).toBeCalledTimes(validArr.length);
+    expect(loggerMock.error).not.toBeCalled();
+
+    expect(loggerMock.warn).not.toBeCalled();
+  });
+
+  test('Should return false and log an error for the array if it is invalid', () => {
+    for (let i = 0; i < invalidDefinitions.length; i++) {
+      expect(validateDefinitions(loggerMock, invalidDefinitions[i], 'test_method')).toBe(false);
+      expect(loggerMock.error).toBeCalledWith(ERROR_EMPTY_ARRAY, ['test_method', 'feature flag names']);
+      expect(validateDefinitionMock).not.toBeCalled();
+
+      loggerMock.error.mockClear();
+    }
+
+    expect(loggerMock.warn).not.toBeCalled();
+  });
+
+  test('Should strip out any invalid value from the array', () => {
+    validateDefinitionMock.mockImplementation((_, value) => startsWith(value, 'invalid') ? false : value);
+    const myArr = ['valid_name', 'invalid_name', 'invalid_val_2', 'something_valid'];
+
+    expect(validateDefinitions(loggerMock, myArr, 'test_method')).toEqual(['valid_name', 'something_valid']);
+
+    for (let i = 0; i < myArr.length; i++) {
+      expect(validateDefinitionMock.mock.calls[i]).toEqual([loggerMock, myArr[i], 'test_method', 'feature flag name']);
+    }
+
+    expect(loggerMock.error).not.toBeCalled();
+    expect(loggerMock.warn).not.toBeCalled();
+  });
+});

src/utils/inputValidation/__tests__/split.spec.ts

@@ -0,0 +1,27 @@
+import { ERROR_NULL, ERROR_INVALID, WARN_TRIMMING, ERROR_EMPTY } from '../../logger/constants';
+import { ILogger } from '../../logger/types';
+import { isString } from '../lang';
+
+// include BOM and nbsp
+const TRIMMABLE_SPACES_REGEX = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/;
+
+export function validateDefinition(log: ILogger, maybeDefinition: any, method: string, item = 'feature flag name'): string | false {
+  if (maybeDefinition == undefined) { // eslint-disable-line eqeqeq
+    log.error(ERROR_NULL, [method, item]);
+  } else if (!isString(maybeDefinition)) {
+    log.error(ERROR_INVALID, [method, item]);
+  } else {
+    if (TRIMMABLE_SPACES_REGEX.test(maybeDefinition)) {
+      log.warn(WARN_TRIMMING, [method, item, maybeDefinition]);
+      maybeDefinition = maybeDefinition.trim();
+    }
+
+    if (maybeDefinition.length > 0) {
+      return maybeDefinition;
+    } else {
+      log.error(ERROR_EMPTY, [method, item]);
+    }
+  }
+
+  return false;
+}