Rename SPLIT_NOT_FOUND to DEFINITION_NOT_FOUND and update related references

EmilianoSanchez · EmilianoSanchez · commit c3d97309caec · 2026-03-13T03:30:03.000-03:00
diff --git a/.gitignore b/.gitignore
@@ -12,3 +12,11 @@
 
 ## coverage info
 /coverage
+
+## worktrees
+/.worktrees
+
+## agents files
+/AGENTS.md
+/CLAUDE.md
+/.claude
diff --git a/src/evaluator/__tests__/evaluate-feature.spec.ts b/src/evaluator/__tests__/evaluate-feature.spec.ts
@@ -1,5 +1,5 @@
 import { evaluateFeature } from '../index';
-import { EXCEPTION, NOT_IN_SPLIT, SPLIT_ARCHIVED, SPLIT_KILLED, SPLIT_NOT_FOUND } from '../../utils/labels';
+import { EXCEPTION, NOT_IN_SPLIT, SPLIT_ARCHIVED, SPLIT_KILLED, DEFINITION_NOT_FOUND } from '../../utils/labels';
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 import { ISplit } from '../../dtos/types';
 import { IStorageSync } from '../../storages/types';
@@ -53,7 +53,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     config: '{color:\'black\'}', changeNumber: 1487277320548
   };
   const expectedOutputControl = {
-    treatment: 'control', label: SPLIT_NOT_FOUND, config: null
+    treatment: 'control', label: DEFINITION_NOT_FOUND, config: null
   };
 
   const evaluationWithConfig = evaluateFeature(
diff --git a/src/evaluator/__tests__/evaluate-features.spec.ts b/src/evaluator/__tests__/evaluate-features.spec.ts
@@ -1,5 +1,5 @@
 import { evaluateFeatures, evaluateFeaturesByFlagSets } from '../index';
-import { EXCEPTION, NOT_IN_SPLIT, SPLIT_ARCHIVED, SPLIT_KILLED, SPLIT_NOT_FOUND } from '../../utils/labels';
+import { EXCEPTION, NOT_IN_SPLIT, SPLIT_ARCHIVED, SPLIT_KILLED, DEFINITION_NOT_FOUND } from '../../utils/labels';
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../../logger/constants';
 import { ISplit } from '../../dtos/types';
@@ -71,7 +71,7 @@ test('EVALUATOR - Multiple evaluations at once / should return right labels, tre
       config: '{color:\'black\'}', changeNumber: 1487277320548
     },
     not_existent_split: {
-      treatment: 'control', label: SPLIT_NOT_FOUND, config: null
+      treatment: 'control', label: DEFINITION_NOT_FOUND, config: null
     },
   };
 
@@ -122,7 +122,7 @@ describe('EVALUATOR - Multiple evaluations at once by flag sets', () => {
       config: '{color:\'black\'}', changeNumber: 1487277320548
     },
     not_existent_split: {
-      treatment: 'control', label: SPLIT_NOT_FOUND, config: null
+      treatment: 'control', label: DEFINITION_NOT_FOUND, config: null
     },
   };
 
diff --git a/src/evaluator/index.ts b/src/evaluator/index.ts
@@ -1,6 +1,6 @@
 import { engineParser } from './Engine';
 import { thenable } from '../utils/promise/thenable';
-import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
+import { EXCEPTION, DEFINITION_NOT_FOUND } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
@@ -148,7 +148,7 @@ function getEvaluation(
 ): MaybeThenable<IEvaluationResult> {
   let evaluation: MaybeThenable<IEvaluationResult> = {
     treatment: CONTROL,
-    label: SPLIT_NOT_FOUND,
+    label: DEFINITION_NOT_FOUND,
     config: null
   };
 
diff --git a/src/logger/constants.ts b/src/logger/constants.ts
@@ -71,7 +71,7 @@ export const WARN_SETTING_NULL = 211;
 export const WARN_TRIMMING_PROPERTIES = 212;
 export const WARN_CONVERTING = 213;
 export const WARN_TRIMMING = 214;
-export const WARN_NOT_EXISTENT_SPLIT = 215;
+export const WARN_NOT_EXISTENT_DEFINITION = 215;
 export const WARN_LOWERCASE_TRAFFIC_TYPE = 216;
 export const WARN_NOT_EXISTENT_TT = 217;
 export const WARN_INTEGRATION_INVALID = 218;
diff --git a/src/logger/messages/warn.ts b/src/logger/messages/warn.ts
@@ -21,7 +21,7 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_TRIMMING_PROPERTIES, '%s: more than 300 properties were provided. Some of them will be trimmed when processed.'],
   [c.WARN_CONVERTING, '%s: %s "%s" is not of type string, converting.'],
   [c.WARN_TRIMMING, '%s: %s "%s" has extra whitespace, trimming.'],
-  [c.WARN_NOT_EXISTENT_SPLIT, '%s: feature flag "%s" does not exist in this environment. Please double check what feature flags exist in the Split user interface.'],
+  [c.WARN_NOT_EXISTENT_DEFINITION, '%s: definition "%s" does not exist in this environment. Please double check what definitions exist in the Split user interface.'],
   [c.WARN_LOWERCASE_TRAFFIC_TYPE, '%s: traffic_type_name should be all lowercase - converting string to lowercase.'],
   [c.WARN_NOT_EXISTENT_TT, '%s: traffic type "%s" does not have any corresponding feature flag in this environment, make sure you\'re tracking your events to a valid traffic type defined in the Split user interface.'],
   [c.WARN_FLAGSET_NOT_CONFIGURED, '%s: you passed %s which is not part of the configured FlagSetsFilter, ignoring Flag Set.'],
diff --git a/src/sdkClient/client.ts b/src/sdkClient/client.ts
@@ -1,7 +1,7 @@
 import { evaluateFeature, evaluateFeatures, evaluateFeaturesByFlagSets } from '../evaluator';
 import { thenable } from '../utils/promise/thenable';
 import { getMatching, getBucketing } from '../utils/key';
-import { validateSplitExistence } from '../utils/inputValidation/splitExistence';
+import { validateDefinitionExistence } from '../utils/inputValidation/definitionExistence';
 import { validateTrafficTypeExistence } from '../utils/inputValidation/trafficTypeExistence';
 import { SDK_NOT_READY } from '../utils/labels';
 import { CONTROL, TREATMENT, TREATMENTS, TREATMENT_WITH_CONFIG, TREATMENTS_WITH_CONFIG, TRACK, TREATMENTS_WITH_CONFIG_BY_FLAGSETS, TREATMENTS_BY_FLAGSETS, TREATMENTS_BY_FLAGSET, TREATMENTS_WITH_CONFIG_BY_FLAGSET, GET_TREATMENTS_WITH_CONFIG, GET_TREATMENTS_BY_FLAG_SETS, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SETS, GET_TREATMENTS_BY_FLAG_SET, GET_TREATMENTS_WITH_CONFIG_BY_FLAG_SET, GET_TREATMENT_WITH_CONFIG, GET_TREATMENT, GET_TREATMENTS, TRACK_FN_LABEL } from '../utils/constants';
@@ -151,7 +151,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     }
 
     // If no target/key, no impression is tracked
-    if (validateSplitExistence(log, readinessManager, featureFlagName, label, invokingMethodName) && key) {
+    if (validateDefinitionExistence(log, readinessManager, featureFlagName, label, invokingMethodName) && key) {
       const matchingKey = getMatching(key);
       const bucketingKey = getBucketing(key);
 
diff --git a/src/sdkConfig/index.ts b/src/sdkConfig/index.ts
@@ -42,7 +42,7 @@ export function sdkConfigFactory(params: ISdkFactoryParams): SplitIO.ConfigsClie
     }
   });
 
-  const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);
+  const fallbackTreatmentsCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);
 
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
diff --git a/src/sdkManager/index.ts b/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, validateSplitExistence, validateIfOperational } from '../utils/inputValidation';
+import { validateSplit, validateDefinitionExistence, validateIfOperational } from '../utils/inputValidation';
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
@@ -74,12 +74,12 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
 
         if (thenable(split)) {
           return split.catch(() => null).then(result => { // handle possible rejections when using pluggable storage
-            validateSplitExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
+            validateDefinitionExistence(log, readinessManager, splitName, result, SPLIT_FN_LABEL);
             return objectToView(result);
           });
         }
 
-        validateSplitExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
+        validateDefinitionExistence(log, readinessManager, splitName, split, SPLIT_FN_LABEL);
 
         return objectToView(split);
       },
diff --git a/src/utils/inputValidation/__tests__/splitExistence.spec.ts b/src/utils/inputValidation/__tests__/splitExistence.spec.ts
@@ -3,9 +3,9 @@ import * as LabelConstants from '../../labels';
 
 import { loggerMock } from '../../../logger/__tests__/sdkLogger.mock';
 
-import { validateSplitExistence } from '../splitExistence';
+import { validateDefinitionExistence } from '../definitionExistence';
 import { IReadinessManager } from '../../../readiness/types';
-import { WARN_NOT_EXISTENT_SPLIT } from '../../../logger/constants';
+import { WARN_NOT_EXISTENT_DEFINITION } from '../../../logger/constants';
 
 describe('Split existence (special case)', () => {
 
@@ -17,30 +17,30 @@ describe('Split existence (special case)', () => {
       isReady: jest.fn(() => false) // Fake the signal for the non ready SDK
     } as IReadinessManager;
 
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'some_split', {}, 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'some_split', null, 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'some_split', undefined, 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'some_split', 'a label', 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'some_split', LabelConstants.SPLIT_NOT_FOUND, 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'some_split', {}, 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'some_split', null, 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'some_split', undefined, 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'some_split', 'a label', 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'some_split', LabelConstants.DEFINITION_NOT_FOUND, 'test_method')).toBe(true); // Should always return true when the SDK is not ready.
 
     expect(loggerMock.warn).not.toBeCalled(); // There should have been no warning logs since the SDK was not ready yet.
     expect(loggerMock.error).not.toBeCalled(); // There should have been no error logs since the SDK was not ready yet.
 
     // Prepare the mock to fake that the SDK is ready now.
     (readinessManagerMock.isReady as jest.Mock).mockImplementation(() => true);
 
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'other_split', {}, 'other_method')).toBe(true); // Should return true if it receives a Split Object instead of null (when the object is not found, for manager).
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'other_split', 'a label', 'other_method')).toBe(true); // Should return true if it receives a Label and it is not split not found (when the Split was not found on the storage, for client).
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'other_split', {}, 'other_method')).toBe(true); // Should return true if it receives a Split Object instead of null (when the object is not found, for manager).
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'other_split', 'a label', 'other_method')).toBe(true); // Should return true if it receives a Label and it is not split not found (when the Split was not found on the storage, for client).
 
     expect(loggerMock.warn).not.toBeCalled(); // There should have been no warning logs since the values we used so far were considered valid.
     expect(loggerMock.error).not.toBeCalled(); // There should have been no error logs since the values we used so far were considered valid.
 
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'other_split', null, 'other_method')).toBe(false); // Should return false if it receives a non-truthy value as a split object or label
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'other_split', undefined, 'other_method')).toBe(false); // Should return false if it receives a non-truthy value as a split object or label
-    expect(validateSplitExistence(loggerMock, readinessManagerMock, 'other_split', LabelConstants.SPLIT_NOT_FOUND, 'other_method')).toBe(false); // Should return false if it receives a label but it is the split not found one.
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'other_split', null, 'other_method')).toBe(false); // Should return false if it receives a non-truthy value as a split object or label
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'other_split', undefined, 'other_method')).toBe(false); // Should return false if it receives a non-truthy value as a split object or label
+    expect(validateDefinitionExistence(loggerMock, readinessManagerMock, 'other_split', LabelConstants.DEFINITION_NOT_FOUND, 'other_method')).toBe(false); // Should return false if it receives a label but it is the split not found one.
 
     expect(loggerMock.warn).toBeCalledTimes(3); // It should have logged 3 warnings, one per each time we called it
-    loggerMock.warn.mock.calls.forEach(call => expect(call).toEqual([WARN_NOT_EXISTENT_SPLIT, ['other_method', 'other_split']])); // Warning logs should have the correct message.
+    loggerMock.warn.mock.calls.forEach(call => expect(call).toEqual([WARN_NOT_EXISTENT_DEFINITION, ['other_method', 'other_split']])); // Warning logs should have the correct message.
 
     expect(loggerMock.error).not.toBeCalled(); // We log warnings, not errors.
   });
diff --git a/src/utils/inputValidation/definitionExistence.ts b/src/utils/inputValidation/definitionExistence.ts
@@ -0,0 +1,19 @@
+import { FALLBACK_DEFINITION_NOT_FOUND, DEFINITION_NOT_FOUND } from '../labels';
+import { IReadinessManager } from '../../readiness/types';
+import { ILogger } from '../../logger/types';
+import { WARN_NOT_EXISTENT_DEFINITION } from '../../logger/constants';
+
+/**
+ * This is defined here and in this format mostly because of the logger and the fact that it's considered a validation at product level.
+ * But it's not going to run on the input validation layer. In any case, the most compelling reason to use it as we do is to avoid going to Redis and get a definition twice.
+ */
+export function validateDefinitionExistence(log: ILogger, readinessManager: IReadinessManager, definitionName: string, labelOrDefinitionObj: any, method: string): boolean {
+  if (readinessManager.isReady()) { // Only if it's ready (synced with BE) we validate this, otherwise it may just be that the SDK is still syncing
+    if (labelOrDefinitionObj === DEFINITION_NOT_FOUND || labelOrDefinitionObj === FALLBACK_DEFINITION_NOT_FOUND || labelOrDefinitionObj == null) {
+      log.warn(WARN_NOT_EXISTENT_DEFINITION, [method, definitionName]);
+      return false;
+    }
+  }
+
+  return true;
+}
diff --git a/src/utils/inputValidation/index.ts b/src/utils/inputValidation/index.ts
@@ -8,6 +8,6 @@ export { validateSplit } from './split';
 export { validateSplits } from './splits';
 export { validateTrafficType } from './trafficType';
 export { validateIfNotDestroyed, validateIfReadyFromCache, validateIfOperational } from './isOperational';
-export { validateSplitExistence } from './splitExistence';
+export { validateDefinitionExistence } from './definitionExistence';
 export { validateTrafficTypeExistence } from './trafficTypeExistence';
 export { validateEvaluationOptions } from './eventProperties';
diff --git a/src/utils/inputValidation/splitExistence.ts b/src/utils/inputValidation/splitExistence.ts
diff --git a/src/utils/labels/index.ts b/src/utils/labels/index.ts
@@ -2,11 +2,11 @@ import { FALLBACK_PREFIX } from '../../evaluator/fallbackTreatmentsCalculator';
 
 export const SPLIT_KILLED = 'killed';
 export const NO_CONDITION_MATCH = 'default rule';
-export const SPLIT_NOT_FOUND = 'definition not found';
+export const DEFINITION_NOT_FOUND = 'definition not found';
 export const SDK_NOT_READY = 'not ready';
 export const EXCEPTION = 'exception';
 export const SPLIT_ARCHIVED = 'archived';
 export const NOT_IN_SPLIT = 'not in split';
 export const UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';
 export const PREREQUISITES_NOT_MET = 'prerequisites not met';
-export const FALLBACK_SPLIT_NOT_FOUND = FALLBACK_PREFIX + SPLIT_NOT_FOUND;
+export const FALLBACK_DEFINITION_NOT_FOUND = FALLBACK_PREFIX + DEFINITION_NOT_FOUND;

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ export function sdkConfigFactory(params: ISdkFactoryParams): SplitIO.ConfigsClie`
`42`	`42`	`}`
`43`	`43`	`});`
`44`	`44`
`45`		`- const fallbackTreatmentsCalculator = new FallbackTreatmentsCalculator(settings.fallbackTreatments);`
	`45`	`+ const fallbackTreatmentsCalculator = FallbackTreatmentsCalculator(settings.fallbackTreatments);`
`46`	`46`
`47`	`47`	`const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);`
`48`	`48`	`const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });`