@featurevisor/sdk 1.28.0 → 1.29.2

package/src/datafileReader.spec.ts

@@ -1,4 +1,4 @@
-import { DatafileContent } from "@featurevisor/types";
+import { Attribute, DatafileContent } from "@featurevisor/types";
 import { DatafileReader } from "./datafileReader";
 
 describe("sdk: DatafileReader", function () {
@@ -6,7 +6,7 @@ describe("sdk: DatafileReader", function () {
     expect(typeof DatafileReader).toEqual("function");
   });
 
-  it("should return requested entities", function () {
+  it("v1 datafile schema: should return requested entities", function () {
     const datafileJson: DatafileContent = {
       schemaVersion: "1",
       revision: "1",
@@ -86,4 +86,90 @@ describe("sdk: DatafileReader", function () {
     expect(reader.getFeature("test")).toEqual(datafileJson.features[0]);
     expect(reader.getFeature("test2")).toEqual(undefined);
   });
+
+  it("v2 datafile schema: should return requested entities", function () {
+    const datafileJson: DatafileContent = {
+      schemaVersion: "2",
+      revision: "1",
+      attributes: {
+        userId: {
+          key: "userId",
+          type: "string",
+          capture: true,
+        },
+        country: {
+          key: "country",
+          type: "string",
+        },
+      },
+      segments: {
+        netherlands: {
+          key: "netherlands",
+          conditions: [
+            {
+              attribute: "country",
+              operator: "equals",
+              value: "nl",
+            },
+          ],
+        },
+        germany: {
+          key: "germany",
+          conditions: JSON.stringify([
+            {
+              attribute: "country",
+              operator: "equals",
+              value: "de",
+            },
+          ]),
+        },
+      },
+      features: {
+        test: {
+          key: "test",
+          bucketBy: "userId",
+          variations: [
+            { value: "control" },
+            {
+              value: "treatment",
+              variables: [
+                {
+                  key: "showSidebar",
+                  value: true,
+                },
+              ],
+            },
+          ],
+          traffic: [
+            {
+              key: "1",
+              segments: "*",
+              percentage: 100000,
+              allocation: [
+                { variation: "control", range: [0, 0] },
+                { variation: "treatment", range: [0, 100000] },
+              ],
+            },
+          ],
+        },
+      },
+    };
+
+    const reader = new DatafileReader(datafileJson);
+
+    expect(reader.getRevision()).toEqual("1");
+    expect(reader.getSchemaVersion()).toEqual("2");
+    expect(reader.getAllAttributes()).toEqual(
+      Object.keys(datafileJson.attributes).reduce((acc, key) => {
+        acc.push(datafileJson.attributes[key]);
+        return acc;
+      }, [] as Attribute[]),
+    );
+    expect(reader.getAttribute("userId")).toEqual(datafileJson.attributes.userId);
+    expect(reader.getSegment("netherlands")).toEqual(datafileJson.segments.netherlands);
+    expect((reader.getSegment("germany") as any).conditions[0].value).toEqual("de");
+    expect(reader.getSegment("belgium")).toEqual(undefined);
+    expect(reader.getFeature("test")).toEqual(datafileJson.features.test);
+    expect(reader.getFeature("test2")).toEqual(undefined);
+  });
 });

package/src/datafileReader.ts

@@ -25,32 +25,39 @@ export class DatafileReader {
   private schemaVersion: string;
   private revision: string;
 
-  // v1
-  private attributes: Attribute[];
-  private segments: Segment[];
-  private features: Feature[];
-
-  // v2
-  private attributesV2: Record<AttributeKey, Attribute>;
-  private segmentsV2: Record<SegmentKey, Segment>;
-  private featuresV2: Record<FeatureKey, Feature>;
+  private attributes: Record<AttributeKey, Attribute>;
+  private segments: Record<SegmentKey, Segment>;
+  private features: Record<FeatureKey, Feature>;
 
   constructor(datafileJson: DatafileContentV1 | DatafileContentV2) {
     this.schemaVersion = datafileJson.schemaVersion;
     this.revision = datafileJson.revision;
 
     if (this.schemaVersion === "2") {
+      // v2
       const datafileJsonV2 = datafileJson as DatafileContentV2;
 
-      this.attributesV2 = datafileJsonV2.attributes;
-      this.segmentsV2 = datafileJsonV2.segments;
-      this.featuresV2 = datafileJsonV2.features;
+      this.attributes = datafileJsonV2.attributes;
+      this.segments = datafileJsonV2.segments;
+      this.features = datafileJsonV2.features;
     } else {
+      // v1
       const datafileJsonV1 = datafileJson as DatafileContentV1;
 
-      this.segments = datafileJsonV1.segments;
-      this.attributes = datafileJsonV1.attributes;
-      this.features = datafileJsonV1.features;
+      this.attributes = {};
+      datafileJsonV1.attributes.forEach((a) => {
+        this.attributes[a.key] = a;
+      });
+
+      this.segments = {};
+      datafileJsonV1.segments.forEach((s) => {
+        this.segments[s.key] = s;
+      });
+
+      this.features = {};
+      datafileJsonV1.features.forEach((f) => {
+        this.features[f.key] = f;
+      });
     }
   }
 
@@ -63,33 +70,21 @@ export class DatafileReader {
   }
 
   getAllAttributes(): Attribute[] {
-    if (this.schemaVersion !== "2") {
-      return this.attributes;
-    }
-
-    // v2
     const result: Attribute[] = [];
 
-    for (const key in this.attributesV2) {
-      result.push(this.attributesV2[key]);
-    }
+    Object.keys(this.attributes).forEach((key) => {
+      result.push(this.attributes[key]);
+    });
 
     return result;
   }
 
   getAttribute(attributeKey: AttributeKey): Attribute | undefined {
-    if (this.schemaVersion === "2") {
-      return this.attributesV2[attributeKey];
-    }
-
-    return this.attributes.find((a) => a.key === attributeKey);
+    return this.attributes[attributeKey];
   }
 
   getSegment(segmentKey: SegmentKey): Segment | undefined {
-    const segment =
-      this.schemaVersion === "2"
-        ? this.segmentsV2[segmentKey]
-        : this.segments.find((s) => s.key === segmentKey);
+    const segment = this.segments[segmentKey];
 
     if (!segment) {
       return undefined;
@@ -99,15 +94,6 @@ export class DatafileReader {
   }
 
   getFeature(featureKey: FeatureKey): Feature | undefined {
-    const feature =
-      this.schemaVersion === "2"
-        ? this.featuresV2[featureKey]
-        : this.features.find((f) => f.key === featureKey);
-
-    if (!feature) {
-      return undefined;
-    }
-
-    return feature;
+    return this.features[featureKey];
   }
 }