Update Configs DTO

EmilianoSanchez · EmilianoSanchez · commit 5e6812749030 · 2026-04-08T02:01:03.000-03:00
AI-Session-Id: e9b3e072-2ec0-428a-b108-9646c6de8629
AI-Tool: claude-code
AI-Model: unknown
diff --git a/src/dtos/types.ts b/src/dtos/types.ts
@@ -215,51 +215,6 @@ export interface IRBSegment {
   } | null
 }
 
-// Superset of ISplit (i.e., ISplit extends IConfig)
-// - with optional fields related to targeting information and
-// - an optional link fields that binds configurations to other entities
-export interface IConfig {
-  name: string,
-  changeNumber: number,
-  status?: 'ACTIVE' | 'ARCHIVED',
-  conditions?: ISplitCondition[] | null,
-  prerequisites?: null | {
-    n: string,
-    ts: string[]
-  }[]
-  killed?: boolean,
-  defaultTreatment: string,
-  trafficTypeName?: string,
-  seed?: number,
-  trafficAllocation?: number,
-  trafficAllocationSeed?: number
-  configurations?: {
-    [treatmentName: string]: string
-  },
-  sets?: string[],
-  impressionsDisabled?: boolean,
-  // a map of entities (e.g., pipeline, feature-flag, etc) to configuration variants
-  links?: {
-    [entityType: string]: {
-      [entityName: string]: string
-    }
-  }
-}
-
-/** Interface of the parsed JSON response of `/configs` */
-export interface IConfigsResponse {
-  configs?: {
-    t: number,
-    s?: number,
-    d: IConfig[]
-  },
-  rbs?: {
-    t: number,
-    s?: number,
-    d: IRBSegment[]
-  }
-}
-
 // @TODO: rename to IDefinition (Configs and Feature Flags are definitions)
 export interface ISplit {
   name: string,
@@ -277,7 +232,7 @@ export interface ISplit {
   trafficAllocation?: number,
   trafficAllocationSeed?: number
   configurations?: {
-    [treatmentName: string]: string
+    [treatmentName: string]: string | SplitIO.JsonObject
   },
   sets?: string[],
   impressionsDisabled?: boolean
diff --git a/src/evaluator/types.ts b/src/evaluator/types.ts
@@ -22,7 +22,7 @@ export interface IEvaluation {
   treatment?: string,
   label: string,
   changeNumber?: number,
-  config?: string | null
+  config?: string | null | SplitIO.JsonObject
 }
 
 export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDisabled?: boolean }
diff --git a/src/sdkClient/client.ts b/src/sdkClient/client.ts
@@ -173,7 +173,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient | Spl
     if (withConfig) {
       return {
         treatment,
-        config
+        config: config as string | null
       };
     }
 
diff --git a/src/sdkManager/index.ts b/src/sdkManager/index.ts
@@ -29,7 +29,7 @@ function objectToView(splitObject: ISplit | null): SplitIO.SplitView | null {
     killed: splitObject.killed,
     changeNumber: splitObject.changeNumber || 0,
     treatments: collectTreatments(splitObject),
-    configs: splitObject.configurations || {},
+    configs: splitObject.configurations as SplitIO.SplitView['configs'] || {},
     sets: splitObject.sets || [],
     defaultTreatment: splitObject.defaultTreatment,
     impressionsDisabled: splitObject.impressionsDisabled === true,
diff --git a/src/services/types.ts b/src/services/types.ts
@@ -35,7 +35,7 @@ export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyT
 
 export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
 
-export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
+export type IFetchDefinitionChanges = (since: number, noCache?: boolean, till?: number, rbSince?: number) => Promise<IResponse>
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
@@ -59,8 +59,8 @@ export interface ISplitApi {
 	getSdkAPIHealthCheck: IHealthCheckAPI
 	getEventsAPIHealthCheck: IHealthCheckAPI
 	fetchAuth: IFetchAuth
-	fetchSplitChanges: IFetchSplitChanges
-	fetchConfigs: IFetchSplitChanges
+	fetchSplitChanges: IFetchDefinitionChanges
+	fetchConfigs: IFetchDefinitionChanges
 	fetchSegmentChanges: IFetchSegmentChanges
 	fetchMemberships: IFetchMemberships
 	postEventsBulk: IPostEventsBulk
diff --git a/src/sync/polling/fetchers/__tests__/configsFetcher.spec.ts b/src/sync/polling/fetchers/__tests__/configsFetcher.spec.ts
@@ -0,0 +1,75 @@
+import { ISplitChangesResponse } from '../../../../dtos/types';
+import { convertConfigsResponseToDefinitionChangesResponse, IConfigsResponse } from '../configsFetcher';
+
+// TODO: complete input and output mocks
+const inputMock: IConfigsResponse = {
+  s: 100,
+  t: 200,
+  d: [{ 'name': 'SomeConfig1', 'defaultVariant': 'v2', 'variants': [{ 'name': 'v1', 'definition': { 'prop1': true, 'prop2': 123 } }, { 'name': 'v2', 'definition': { 'prop1': false, 'prop2': 456 } }], 'targeting': { 'conditions': [{ 'variant': 'v1', 'label': 'main condition', 'matchers': [{ 'type': 'IS_EQUAL_TO', 'data': { 'type': 'NUMBER', 'number': 42 }, 'attribute': 'age' }, { 'type': 'WHITELIST', 'data': { 'strings': ['a', 'b', 'c'] }, 'attribute': 'favoriteCharacter' }] }] } }],
+};
+
+const expectedOutput: ISplitChangesResponse = {
+  ff: {
+    s: 100,
+    t: 200,
+    d: [{
+      name: 'SomeConfig1',
+      changeNumber: 0,
+      status: 'ACTIVE',
+      killed: false,
+      defaultTreatment: 'v2',
+      trafficTypeName: 'user',
+      seed: 0,
+      configurations: {
+        'v1': { 'prop1': true, 'prop2': 123 },
+        'v2': { 'prop1': false, 'prop2': 456 },
+      },
+      conditions: [
+        {
+          conditionType: 'WHITELIST',
+          label: 'main condition',
+          matcherGroup: {
+            combiner: 'AND',
+            matchers: [
+              {
+                matcherType: 'EQUAL_TO',
+                negate: false,
+                keySelector: { trafficType: 'user', attribute: 'age' },
+                unaryNumericMatcherData: { dataType: 'NUMBER', value: 42 },
+              },
+              {
+                matcherType: 'WHITELIST',
+                negate: false,
+                keySelector: { trafficType: 'user', attribute: 'favoriteCharacter' },
+                whitelistMatcherData: { whitelist: ['a', 'b', 'c'] },
+              },
+            ],
+          },
+          partitions: [{ treatment: 'v1', size: 100 }],
+        },
+        {
+          conditionType: 'ROLLOUT',
+          matcherGroup: {
+            combiner: 'AND',
+            matchers: [{
+              keySelector: null,
+              matcherType: 'ALL_KEYS',
+              negate: false,
+            }],
+          },
+          partitions: [{ treatment: 'v2', size: 100 }],
+          label: 'default rule',
+        },
+      ],
+    }],
+  },
+};
+
+describe('convertConfigsResponseToDefinitionChangesResponse', () => {
+
+  test('should convert a configs response to a definition changes response', () => {
+    const result = convertConfigsResponseToDefinitionChangesResponse(inputMock);
+    expect(result).toEqual(expectedOutput);
+  });
+
+});
diff --git a/src/sync/polling/fetchers/configsFetcher.ts b/src/sync/polling/fetchers/configsFetcher.ts
@@ -1,28 +1,63 @@
-import { IConfig, IConfigsResponse, ISplitChangesResponse, ISplitCondition } from '../../../dtos/types';
-import { IFetchSplitChanges, IResponse } from '../../../services/types';
+import { ISplit, ISplitChangesResponse, ISplitCondition, ISplitMatcher } from '../../../dtos/types';
+import { IFetchDefinitionChanges, IResponse } from '../../../services/types';
 import { ISplitChangesFetcher } from './types';
+import SplitIO from '../../../../types/splitio';
+
+type IConfigMatcher = {
+  type: 'IS_EQUAL_TO';
+  data: { type: 'NUMBER'; number: number };
+  attribute?: string;
+} | {
+  type: 'WHITELIST';
+  data: { strings: string[] };
+  attribute?: string;
+}
+
+type IConfig = {
+  name: string;
+  variants: Array<{
+    name: string;
+    definition: SplitIO.JsonObject;
+  }>;
+  defaultVariant: string;
+  changeNumber?: number;
+  targeting?: {
+    conditions?: Array<{
+      variant: string;
+      label: string;
+      matchers: Array<IConfigMatcher>;
+    }>
+  };
+}
+
+/** Interface of the parsed JSON response of `/configs` */
+export type IConfigsResponse = {
+  t: number,
+  s?: number,
+  d: IConfig[]
+}
 
 /**
  * Factory of Configs fetcher.
  * Configs fetcher is a wrapper around `configs` API service that parses the response and handle errors.
  */
-export function configsFetcherFactory(fetchConfigs: IFetchSplitChanges): ISplitChangesFetcher {
+export function configsFetcherFactory(fetchConfigs: IFetchDefinitionChanges): ISplitChangesFetcher {
 
   return function configsFetcher(
     since: number,
     noCache?: boolean,
     till?: number,
     rbSince?: number,
-    // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
+    // Optional decorator for `fetchConfigs` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
   ): Promise<ISplitChangesResponse> {
 
     let configsPromise = fetchConfigs(since, noCache, till, rbSince);
     if (decorator) configsPromise = decorator(configsPromise);
 
     return configsPromise
-      .then((resp: IResponse) => resp.json())
-      .then(convertConfigsResponseToSplitChangesResponse);
+      .then<IConfigsResponse>((resp: IResponse) => resp.json())
+      .then(convertConfigsResponseToDefinitionChangesResponse);
   };
 
 }
@@ -43,28 +78,64 @@ function defaultCondition(treatment: string): ISplitCondition {
   };
 }
 
-function convertConfigToDefinitionDTO(config: IConfig) {
-  const defaultTreatment = config.defaultTreatment || 'default';
+function convertMatcher(matcher: IConfigMatcher): ISplitMatcher {
+  const keySelector = matcher.attribute ? { trafficType: 'user', attribute: matcher.attribute } : null;
+
+  switch (matcher.type) {
+    case 'IS_EQUAL_TO':
+      return {
+        matcherType: 'EQUAL_TO',
+        negate: false,
+        keySelector,
+        unaryNumericMatcherData: { dataType: matcher.data.type, value: matcher.data.number },
+      };
+    case 'WHITELIST':
+      return {
+        matcherType: 'WHITELIST',
+        negate: false,
+        keySelector,
+        whitelistMatcherData: { whitelist: matcher.data.strings },
+      };
+  }
+}
+
+function convertConfigToDefinition(config: IConfig): ISplit {
+  const defaultTreatment = config.defaultVariant || (config.variants && config.variants[0]?.name) || 'control';
+
+  const configurations: Record<string, SplitIO.JsonObject> = {};
+  config.variants.forEach(variant => configurations[variant.name] = variant.definition);
+
+  const conditions: ISplitCondition[] = config.targeting?.conditions?.map(condition => ({
+    conditionType: condition.matchers.some((m: IConfigMatcher) => m.type === 'WHITELIST') ? 'WHITELIST' : 'ROLLOUT',
+    label: condition.label,
+    matcherGroup: {
+      combiner: 'AND',
+      matchers: condition.matchers.map(convertMatcher),
+    },
+    partitions: [{ treatment: condition.variant, size: 100 }],
+  })) || [];
+
+  conditions.push(defaultCondition(defaultTreatment));
 
   return {
-    ...config,
+    name: config.name,
+    changeNumber: config.changeNumber || 0,
+    status: 'ACTIVE',
+    conditions,
+    killed: false,
     defaultTreatment,
-    trafficTypeName: config.trafficTypeName || 'user',
-    conditions: config.conditions && config.conditions.length > 0 ? config.conditions : [defaultCondition(defaultTreatment)],
-    killed: config.killed || false,
-    seed: config.seed || 0,
-    trafficAllocation: config.trafficAllocation || 100,
-    trafficAllocationSeed: config.trafficAllocationSeed || 0,
+    trafficTypeName: 'user',
+    seed: 0,
+    configurations,
   };
 }
 
-function convertConfigsResponseToSplitChangesResponse(configs: IConfigsResponse): ISplitChangesResponse {
+export function convertConfigsResponseToDefinitionChangesResponse(configs: IConfigsResponse): ISplitChangesResponse {
   return {
-    ...configs,
-    ff: configs.configs ? {
-      ...configs.configs,
-      d: configs.configs.d?.map(convertConfigToDefinitionDTO)
-    } : undefined,
-    rbs: configs.rbs
+    ff: {
+      s: configs.s,
+      t: configs.t,
+      d: configs.d.map(convertConfigToDefinition),
+    },
   };
 }
diff --git a/src/sync/polling/fetchers/splitChangesFetcher.ts b/src/sync/polling/fetchers/splitChangesFetcher.ts
@@ -1,6 +1,6 @@
 import { ISettings } from '../../../types';
 import { ISplitChangesResponse } from '../../../dtos/types';
-import { IFetchSplitChanges, IResponse } from '../../../services/types';
+import { IFetchDefinitionChanges, IResponse } from '../../../services/types';
 import { IStorageBase } from '../../../storages/types';
 import { FLAG_SPEC_VERSION } from '../../../utils/constants';
 import { base } from '../../../utils/settingsValidation';
@@ -20,7 +20,7 @@ function sdkEndpointOverridden(settings: ISettings) {
  * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
  */
 // @TODO breaking: drop support for Split Proxy below v5.10.0 and simplify the implementation
-export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges, settings: ISettings, storage: Pick<IStorageBase, 'splits' | 'rbSegments'>): ISplitChangesFetcher {
+export function splitChangesFetcherFactory(fetchSplitChanges: IFetchDefinitionChanges, settings: ISettings, storage: Pick<IStorageBase, 'splits' | 'rbSegments'>): ISplitChangesFetcher {
 
   const log = settings.log;
   const PROXY_CHECK_INTERVAL_MILLIS = checkIfServerSide(settings) ? PROXY_CHECK_INTERVAL_MILLIS_SS : PROXY_CHECK_INTERVAL_MILLIS_CS;
diff --git a/src/sync/polling/syncTasks/splitsSyncTask.ts b/src/sync/polling/syncTasks/splitsSyncTask.ts
@@ -3,15 +3,15 @@ import { IReadinessManager } from '../../../readiness/types';
 import { syncTaskFactory } from '../../syncTask';
 import { ISplitsSyncTask } from '../types';
 import { splitChangesFetcherFactory } from '../fetchers/splitChangesFetcher';
-import { IFetchSplitChanges } from '../../../services/types';
+import { IFetchDefinitionChanges } from '../../../services/types';
 import { ISettings } from '../../../types';
 import { splitChangesUpdaterFactory } from '../updaters/splitChangesUpdater';
 
 /**
  * Creates a sync task that periodically executes a `splitChangesUpdater` task
  */
 export function splitsSyncTaskFactory(
-  fetchSplitChanges: IFetchSplitChanges,
+  fetchSplitChanges: IFetchDefinitionChanges,
   storage: IStorageSync,
   readiness: IReadinessManager,
   settings: ISettings,
diff --git a/types/splitio.d.ts b/types/splitio.d.ts
@@ -2284,4 +2284,8 @@ declare namespace SplitIO {
      */
     split(featureFlagName: string): SplitViewAsync;
   }
+
+  type JsonValue = string | number | boolean | null | JsonObject | JsonArray;
+  type JsonArray = JsonValue[];
+  type JsonObject = { [key: string]: JsonValue; };
 }

Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ export interface IEvaluation {`
`22`	`22`	`treatment?: string,`
`23`	`23`	`label: string,`
`24`	`24`	`changeNumber?: number,`
`25`		`- config?: string \| null`
	`25`	`+ config?: string \| null \| SplitIO.JsonObject`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`export type IEvaluationResult = IEvaluation & { treatment: string; impressionsDisabled?: boolean }`
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ export function clientFactory(params: ISdkFactoryContext): SplitIO.IClient \| Spl`
`173`	`173`	`if (withConfig) {`
`174`	`174`	`return {`
`175`	`175`	`treatment,`
`176`		`- config`
	`176`	`+ config: config as string \| null`
`177`	`177`	`};`
`178`	`178`	`}`
`179`	`179`
Original file line number	Diff line number	Diff line change
`@@ -2284,4 +2284,8 @@ declare namespace SplitIO {`
`2284`	`2284`	`*/`
`2285`	`2285`	`split(featureFlagName: string): SplitViewAsync;`
`2286`	`2286`	`}`
	`2287`	`+`
	`2288`	`+ type JsonValue = string \| number \| boolean \| null \| JsonObject \| JsonArray;`
	`2289`	`+ type JsonArray = JsonValue[];`
	`2290`	`+ type JsonObject = { [key: string]: JsonValue; };`
`2287`	`2291`	`}`