refactor(client-http,web,server): use a serializable and more simple …

…configuration object

packages/client-http/src/client/ConfidenceClient.test.ts

@@ -1,6 +1,5 @@
 import { AppliedFlag, ConfidenceClient } from './ConfidenceClient';
 import { Configuration, ResolveContext } from './Configuration';
-import { ConfidenceFlag } from './ConfidenceFlag';
 
 describe('ConfidenceClient', () => {
   const mockFetch = jest.fn();
@@ -97,7 +96,19 @@ describe('ConfidenceClient', () => {
       const config = await instanceUnderTest.resolve(context);
 
       expect(config).toEqual({
-        flags: { ['test-flag']: new ConfidenceFlag(fakeFlag) },
+        flags: {
+          ['test-flag']: {
+            flagName: 'test-flag',
+            schema: {
+              str: 'string',
+            },
+            value: {
+              str: 'test',
+            },
+            reason: Configuration.ResolveReason.Match,
+            variant: 'test',
+          },
+        },
         resolveToken: 'resolve-token',
         context,
       });

packages/client-http/src/client/ConfidenceClient.ts

@@ -1,5 +1,4 @@
 import { Configuration, ResolveContext } from './Configuration';
-import { ConfidenceFlag, ResolvedFlag } from './ConfidenceFlag';
 
 type ApplyRequest = {
   clientSecret: string;
@@ -13,6 +12,13 @@ type ResolveRequest = {
   apply?: boolean;
   flags?: string[];
 };
+export type ResolvedFlag<T = any> = {
+  flag: string;
+  variant: string;
+  value?: T;
+  flagSchema?: ConfidenceFlagSchema;
+  reason: Configuration.ResolveReason;
+};
 type ResolveResponse = {
   resolvedFlags: ResolvedFlag[];
   resolveToken: string;
@@ -29,6 +35,12 @@ export type AppliedFlag = {
   flag: string;
   applyTime: string;
 };
+type ConfidenceBaseTypes = { boolSchema: {} } | { doubleSchema: {} } | { intSchema: {} } | { stringSchema: {} };
+type ConfidenceFlagSchema = {
+  schema: {
+    [key: string]: ConfidenceBaseTypes | { structSchema: ConfidenceFlagSchema };
+  };
+};
 
 export class ConfidenceClient {
   private readonly backendApplyEnabled: boolean;
@@ -58,9 +70,10 @@ export class ConfidenceClient {
       body: JSON.stringify(payload),
     });
     const responseBody: ResolveResponse = await response.json();
+
     return {
       flags: responseBody.resolvedFlags.reduce((acc, flag) => {
-        return { ...acc, [flag.flag]: new ConfidenceFlag(flag) };
+        return { ...acc, [flag.flag]: resolvedFlagToFlag(flag) };
       }, {}),
       resolveToken: responseBody.resolveToken,
       context,
@@ -80,3 +93,49 @@ export class ConfidenceClient {
     });
   }
 }
+
+function resolvedFlagToFlag(flag: ResolvedFlag): Configuration.Flag {
+  return {
+    flagName: flag.flag,
+    reason: flag.reason,
+    variant: flag.variant,
+    value: flag.value,
+    schema: parseSchema(flag.flagSchema),
+  };
+}
+
+function parseBaseType(obj: ConfidenceBaseTypes): Configuration.FlagSchema {
+  if ('boolSchema' in obj) {
+    return 'boolean';
+  }
+  if ('doubleSchema' in obj) {
+    return 'number';
+  }
+  if ('intSchema' in obj) {
+    return 'number';
+  }
+  if ('stringSchema' in obj) {
+    return 'string';
+  }
+
+  throw new Error(`Confidence: cannot parse schema. unknown schema: ${JSON.stringify(obj)}`);
+}
+function parseSchema(schema: ConfidenceFlagSchema | undefined): Configuration.FlagSchema {
+  if (!schema) {
+    return {};
+  }
+
+  return Object.keys(schema.schema).reduce((acc: Record<string, Configuration.FlagSchema>, key) => {
+    const obj = schema.schema[key];
+    if ('structSchema' in obj) {
+      return {
+        ...acc,
+        [key]: parseSchema(obj.structSchema),
+      };
+    }
+    return {
+      ...acc,
+      [key]: parseBaseType(obj),
+    };
+  }, {});
+}