@featurevisor/sdk 0.0.3

package/src/feature.ts

@@ -0,0 +1,213 @@
+import {
+  Allocation,
+  Attributes,
+  Traffic,
+  Feature,
+  Variation,
+  VariableKey,
+  VariableValue,
+  Force,
+} from "@featurevisor/types";
+import { DatafileReader } from "./datafileReader";
+import { allGroupSegmentsAreMatched } from "./segments";
+import { allConditionsAreMatched } from "./conditions";
+
+export function getMatchedTraffic(
+  traffic: Traffic[],
+  attributes: Attributes,
+  bucketValue: number,
+  datafileReader: DatafileReader,
+): Traffic | undefined {
+  return traffic.find((traffic) => {
+    if (bucketValue > traffic.percentage) {
+      // out of bucket range
+      return false;
+    }
+
+    if (
+      !allGroupSegmentsAreMatched(
+        typeof traffic.segments === "string" && traffic.segments !== "*"
+          ? JSON.parse(traffic.segments)
+          : traffic.segments,
+        attributes,
+        datafileReader,
+      )
+    ) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+// @TODO: make this function better with tests
+export function getMatchedAllocation(
+  matchedTraffic: Traffic,
+  bucketValue: number,
+): Allocation | undefined {
+  let total = 0;
+
+  for (const allocation of matchedTraffic.allocation) {
+    total += allocation.percentage;
+
+    if (bucketValue <= total) {
+      return allocation;
+    }
+  }
+
+  return undefined;
+}
+
+function findForceFromFeature(
+  feature: Feature,
+  attributes: Attributes,
+  datafileReader: DatafileReader,
+): Force | undefined {
+  if (!feature.force) {
+    return undefined;
+  }
+
+  return feature.force.find((f: Force) => {
+    if (f.conditions) {
+      return allConditionsAreMatched(f.conditions, attributes);
+    }
+
+    if (f.segments) {
+      return allGroupSegmentsAreMatched(f.segments, attributes, datafileReader);
+    }
+
+    return false;
+  });
+}
+
+export function getForcedVariation(
+  feature: Feature,
+  attributes: Attributes,
+  datafileReader: DatafileReader,
+): Variation | undefined {
+  const force = findForceFromFeature(feature, attributes, datafileReader);
+
+  if (!force || !force.variation) {
+    return undefined;
+  }
+
+  return feature.variations.find((v) => v.value === force.variation);
+}
+
+export function getBucketedVariation(
+  feature: Feature,
+  attributes: Attributes,
+  bucketValue: number,
+  datafileReader: DatafileReader,
+): Variation | undefined {
+  const matchedTraffic = getMatchedTraffic(
+    feature.traffic,
+    attributes,
+    bucketValue,
+    datafileReader,
+  );
+
+  if (!matchedTraffic) {
+    return undefined;
+  }
+
+  const allocation = getMatchedAllocation(matchedTraffic, bucketValue);
+
+  if (!allocation) {
+    return undefined;
+  }
+
+  const variationValue = allocation.variation;
+
+  const variation = feature.variations.find((v) => {
+    return v.value === variationValue;
+  });
+
+  if (!variation) {
+    return undefined;
+  }
+
+  return variation;
+}
+
+export function getForcedVariableValue(
+  feature: Feature,
+  variableKey: VariableKey,
+  attributes: Attributes,
+  datafileReader: DatafileReader,
+): VariableValue | undefined {
+  const force = findForceFromFeature(feature, attributes, datafileReader);
+
+  if (!force || !force.variables) {
+    return undefined;
+  }
+
+  return force.variables[variableKey];
+}
+
+export function getBucketedVariableValue(
+  feature: Feature,
+  variableKey: VariableKey,
+  attributes: Attributes,
+  bucketValue: number,
+  datafileReader: DatafileReader,
+): VariableValue | undefined {
+  // all variables
+  const variablesSchema = feature.variablesSchema;
+
+  if (!variablesSchema) {
+    return undefined;
+  }
+
+  // single variable
+  const variableSchema = variablesSchema.find((v) => {
+    v.key === variableKey;
+  });
+
+  if (variableSchema) {
+    return undefined;
+  }
+
+  const variation = getBucketedVariation(feature, attributes, bucketValue, datafileReader);
+
+  if (!variation) {
+    return undefined;
+  }
+
+  const variableFromVariation = variation.variables?.find((v) => {
+    return v.key === variableKey;
+  });
+
+  if (!variableFromVariation) {
+    return undefined;
+  }
+
+  if (variableFromVariation.overrides) {
+    const override = variableFromVariation.overrides.find((o) => {
+      if (o.conditions) {
+        return allConditionsAreMatched(
+          typeof o.conditions === "string" ? JSON.parse(o.conditions) : o.conditions,
+          attributes,
+        );
+      }
+
+      if (o.segments) {
+        return allGroupSegmentsAreMatched(
+          typeof o.segments === "string" && o.segments !== "*"
+            ? JSON.parse(o.segments)
+            : o.segments,
+          attributes,
+          datafileReader,
+        );
+      }
+
+      return false;
+    });
+
+    if (override) {
+      return override.value;
+    }
+  }
+
+  return variableFromVariation.value;
+}

package/src/index.spec.ts

@@ -0,0 +1,5 @@
+describe("sdk: Index", function () {
+  it("should be a function", function () {
+    expect(true).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./bucket";
+export * from "./client";

package/src/segments.spec.ts

@@ -0,0 +1,196 @@
+import { DatafileReader } from "./datafileReader";
+import { allGroupSegmentsAreMatched } from "./segments";
+import { DatafileContent, GroupSegment } from "@featurevisor/types";
+
+interface Group {
+  key: string;
+  segments: GroupSegment | GroupSegment[] | "*";
+}
+
+describe("sdk: Segments", function () {
+  it("should be a function", function () {
+    expect(typeof allGroupSegmentsAreMatched).toEqual("function");
+  });
+
+  describe("datafile #1", function () {
+    const groups = [
+      // everyone
+      {
+        key: "*",
+        segments: "*",
+      },
+
+      // dutch
+      {
+        key: "dutchMobileUsers",
+        segments: ["mobileUsers", "netherlands"],
+      },
+      {
+        key: "dutchMobileUsers2",
+        segments: {
+          and: ["mobileUsers", "netherlands"],
+        },
+      },
+      {
+        key: "dutchMobileOrDesktopUsers",
+        segments: ["netherlands", { or: ["mobileUsers", "desktopUsers"] }],
+      },
+      {
+        key: "dutchMobileOrDesktopUsers2",
+        segments: {
+          and: ["netherlands", { or: ["mobileUsers", "desktopUsers"] }],
+        },
+      },
+    ];
+
+    const datafileContent: DatafileContent = {
+      schemaVersion: "1.0",
+      revision: "1",
+      features: [],
+      attributes: [],
+
+      segments: [
+        // deviceType
+        {
+          key: "mobileUsers",
+          conditions: [
+            {
+              attribute: "deviceType",
+              operator: "equals",
+              value: "mobile",
+            },
+          ],
+        },
+        {
+          key: "desktopUsers",
+          conditions: [
+            {
+              attribute: "deviceType",
+              operator: "equals",
+              value: "desktop",
+            },
+          ],
+        },
+
+        // browser
+        {
+          key: "chromeBrowser",
+          conditions: [
+            {
+              attribute: "browser",
+              operator: "equals",
+              value: "chrome",
+            },
+          ],
+        },
+        {
+          key: "firefoxBrowser",
+          conditions: [
+            {
+              attribute: "browser",
+              operator: "equals",
+              value: "firefox",
+            },
+          ],
+        },
+
+        // country
+        {
+          key: "netherlands",
+          conditions: [
+            {
+              attribute: "country",
+              operator: "equals",
+              value: "nl",
+            },
+          ],
+        },
+        {
+          key: "germany",
+          conditions: [
+            {
+              attribute: "country",
+              operator: "equals",
+              value: "de",
+            },
+          ],
+        },
+      ],
+    };
+
+    const datafileReader = new DatafileReader(datafileContent);
+
+    it("should match everyone", function () {
+      const group = groups.find((g) => g.key === "*") as Group;
+
+      // match
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(true);
+      expect(allGroupSegmentsAreMatched(group.segments, { foo: "foo" }, datafileReader)).toEqual(
+        true,
+      );
+      expect(allGroupSegmentsAreMatched(group.segments, { bar: "bar" }, datafileReader)).toEqual(
+        true,
+      );
+    });
+
+    it("should match dutchMobileUsers", function () {
+      const group = groups.find((g) => g.key === "dutchMobileUsers") as Group;
+
+      // match
+      expect(
+        allGroupSegmentsAreMatched(
+          group.segments,
+          { country: "nl", deviceType: "mobile" },
+          datafileReader,
+        ),
+      ).toEqual(true);
+      expect(
+        allGroupSegmentsAreMatched(
+          group.segments,
+          { country: "nl", deviceType: "mobile", browser: "chrome" },
+          datafileReader,
+        ),
+      ).toEqual(true);
+
+      // not match
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(false);
+      expect(
+        allGroupSegmentsAreMatched(
+          group.segments,
+          { country: "de", deviceType: "mobile" },
+          datafileReader,
+        ),
+      ).toEqual(false);
+    });
+
+    it("should match dutchMobileUsers2", function () {
+      const group = groups.find((g) => g.key === "dutchMobileUsers") as Group;
+
+      // match
+      expect(
+        allGroupSegmentsAreMatched(
+          group.segments,
+          { country: "nl", deviceType: "mobile" },
+          datafileReader,
+        ),
+      ).toEqual(true);
+      expect(
+        allGroupSegmentsAreMatched(
+          group.segments,
+          { country: "nl", deviceType: "mobile", browser: "chrome" },
+          datafileReader,
+        ),
+      ).toEqual(true);
+
+      // not match
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(false);
+      expect(
+        allGroupSegmentsAreMatched(
+          group.segments,
+          { country: "de", deviceType: "mobile" },
+          datafileReader,
+        ),
+      ).toEqual(false);
+    });
+  });
+});

package/src/segments.ts

@@ -0,0 +1,49 @@
+import { Attributes, GroupSegment, Segment, Condition } from "@featurevisor/types";
+import { allConditionsAreMatched } from "./conditions";
+import { DatafileReader } from "./datafileReader";
+
+export function segmentIsMatched(segment: Segment, attributes: Attributes): boolean {
+  return allConditionsAreMatched(segment.conditions as Condition | Condition[], attributes);
+}
+
+export function allGroupSegmentsAreMatched(
+  groupSegments: GroupSegment | GroupSegment[] | "*",
+  attributes: Attributes,
+  datafileReader: DatafileReader,
+): boolean {
+  if (groupSegments === "*") {
+    return true;
+  }
+
+  if (typeof groupSegments === "string") {
+    const segment = datafileReader.getSegment(groupSegments);
+
+    if (segment) {
+      return segmentIsMatched(segment, attributes);
+    }
+
+    return false;
+  }
+
+  if (typeof groupSegments === "object") {
+    if ("and" in groupSegments && Array.isArray(groupSegments.and)) {
+      return groupSegments.and.every((groupSegment) =>
+        allGroupSegmentsAreMatched(groupSegment, attributes, datafileReader),
+      );
+    }
+
+    if ("or" in groupSegments && Array.isArray(groupSegments.or)) {
+      return groupSegments.or.some((groupSegment) =>
+        allGroupSegmentsAreMatched(groupSegment, attributes, datafileReader),
+      );
+    }
+  }
+
+  if (Array.isArray(groupSegments)) {
+    return groupSegments.every((groupSegment) =>
+      allGroupSegmentsAreMatched(groupSegment, attributes, datafileReader),
+    );
+  }
+
+  return false;
+}

package/tsconfig.cjs.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.cjs.json",
+  "compilerOptions": {
+    "outDir": "./lib"
+  },
+  "include": ["./src/**/*.ts"]
+}

package/tsconfig.esm.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.esm.json",
+  "compilerOptions": {
+    "outDir": "./lib"
+  },
+  "include": ["./src/**/*.ts"]
+}

package/webpack.config.js

@@ -0,0 +1,13 @@
+const path = require("path");
+
+const getWebpackConfig = require("../../tools/getWebpackConfig");
+
+const wepbackConfig = getWebpackConfig({
+  entryFilePath: path.join(__dirname, "src", "index.ts"),
+  entryKey: "index",
+  outputDirectoryPath: path.join(__dirname, "dist"),
+  outputLibrary: "FeaturevisorSDK",
+  tsConfigFilePath: path.join(__dirname, "tsconfig.cjs.json"),
+});
+
+module.exports = wepbackConfig;