@featurevisor/sdk 0.0.3

package/src/conditions.spec.ts

@@ -0,0 +1,533 @@
+import { allConditionsAreMatched } from "./conditions";
+import { Condition } from "@featurevisor/types";
+
+describe("sdk: Conditions", function () {
+  it("should be a function", function () {
+    expect(typeof allConditionsAreMatched).toEqual("function");
+  });
+
+  describe("operators", function () {
+    it("should match with operator: equals", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "browser_type",
+          operator: "equals",
+          value: "chrome",
+        },
+      ];
+
+      // match
+      expect(allConditionsAreMatched(conditions, { browser_type: "chrome" })).toEqual(true);
+
+      // not match
+      expect(allConditionsAreMatched(conditions, { browser_type: "firefox" })).toEqual(false);
+    });
+
+    it("should match with operator: notEquals", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "browser_type",
+          operator: "notEquals",
+          value: "chrome",
+        },
+      ];
+
+      // match
+      expect(allConditionsAreMatched(conditions, { browser_type: "firefox" })).toEqual(true);
+
+      // not match
+      expect(allConditionsAreMatched(conditions, { browser_type: "chrome" })).toEqual(false);
+    });
+
+    it("should match with operator: greaterThan", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "age",
+          operator: "greaterThan",
+          value: 18,
+        },
+      ];
+
+      // match
+      expect(allConditionsAreMatched(conditions, { age: 19 })).toEqual(true);
+
+      // not match
+      expect(allConditionsAreMatched(conditions, { age: 17 })).toEqual(false);
+    });
+
+    it("should match with operator: lessThan", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "age",
+          operator: "lessThan",
+          value: 18,
+        },
+      ];
+
+      // match
+      expect(allConditionsAreMatched(conditions, { age: 17 })).toEqual(true);
+
+      // not match
+      expect(allConditionsAreMatched(conditions, { age: 19 })).toEqual(false);
+    });
+  });
+
+  describe("simple condition", function () {
+    it("should match with exact single condition", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "browser_type",
+          operator: "equals",
+          value: "chrome",
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions[0], {
+          browser_type: "chrome",
+        }),
+      ).toEqual(true);
+    });
+
+    it("should match with exact condition", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "browser_type",
+          operator: "equals",
+          value: "chrome",
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+        }),
+      ).toEqual(true);
+    });
+
+    it("should not match with empty conditions", function () {
+      const conditions: Condition[] = [];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+        }),
+      ).toEqual(true);
+
+      // not match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "firefox",
+        }),
+      ).toEqual(true);
+    });
+
+    it("should match with extra conditions that are not needed", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "browser_type",
+          operator: "equals",
+          value: "chrome",
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+          browser_version: "1.0",
+        }),
+      ).toEqual(true);
+    });
+
+    it("should match with multiple conditions", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "browser_type",
+          operator: "equals",
+          value: "chrome",
+        },
+        {
+          attribute: "browser_version",
+          operator: "equals",
+          value: "1.0",
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+          browser_version: "1.0",
+          foo: "bar",
+        }),
+      ).toEqual(true);
+    });
+  });
+
+  describe("AND condition", function () {
+    it("should match with one AND condition", function () {
+      const conditions: Condition[] = [
+        {
+          and: [
+            {
+              attribute: "browser_type",
+              operator: "equals",
+              value: "chrome",
+            },
+          ],
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+        }),
+      ).toEqual(true);
+    });
+
+    it("should match with multiple conditions inside AND", function () {
+      const conditions: Condition[] = [
+        {
+          and: [
+            {
+              attribute: "browser_type",
+              operator: "equals",
+              value: "chrome",
+            },
+            {
+              attribute: "browser_version",
+              operator: "equals",
+              value: "1.0",
+            },
+          ],
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+          browser_version: "1.0",
+        }),
+      ).toEqual(true);
+
+      // not match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+        }),
+      ).toEqual(false);
+    });
+  });
+
+  describe("OR condition", function () {
+    it("should match with one OR condition", function () {
+      const conditions: Condition[] = [
+        {
+          or: [
+            {
+              attribute: "browser_type",
+              operator: "equals",
+              value: "chrome",
+            },
+          ],
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+        }),
+      ).toEqual(true);
+    });
+
+    it("should match with multiple conditions inside OR", function () {
+      const conditions: Condition[] = [
+        {
+          or: [
+            {
+              attribute: "browser_type",
+              operator: "equals",
+              value: "chrome",
+            },
+            {
+              attribute: "browser_version",
+              operator: "equals",
+              value: "1.0",
+            },
+          ],
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_version: "1.0",
+        }),
+      ).toEqual(true);
+
+      // not match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "firefox",
+        }),
+      ).toEqual(false);
+    });
+  });
+
+  describe("nested conditions", function () {
+    it("should match with OR inside AND", function () {
+      const conditions: Condition[] = [
+        {
+          and: [
+            {
+              attribute: "browser_type",
+              operator: "equals",
+              value: "chrome",
+            },
+            {
+              or: [
+                {
+                  attribute: "browser_version",
+                  operator: "equals",
+                  value: "1.0",
+                },
+                {
+                  attribute: "browser_version",
+                  operator: "equals",
+                  value: "2.0",
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+          browser_version: "1.0",
+        }),
+      ).toEqual(true);
+
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+          browser_version: "2.0",
+        }),
+      ).toEqual(true);
+
+      // not match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+          browser_version: "3.0",
+        }),
+      ).toEqual(false);
+
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_version: "2.0",
+        }),
+      ).toEqual(false);
+    });
+
+    it("should match with plain conditions, followed by OR inside AND", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "country",
+          operator: "equals",
+          value: "nl",
+        },
+        {
+          and: [
+            {
+              attribute: "browser_type",
+              operator: "equals",
+              value: "chrome",
+            },
+            {
+              or: [
+                {
+                  attribute: "browser_version",
+                  operator: "equals",
+                  value: "1.0",
+                },
+                {
+                  attribute: "browser_version",
+                  operator: "equals",
+                  value: "2.0",
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          country: "nl",
+          browser_type: "chrome",
+          browser_version: "1.0",
+        }),
+      ).toEqual(true);
+
+      expect(
+        allConditionsAreMatched(conditions, {
+          country: "nl",
+          browser_type: "chrome",
+          browser_version: "2.0",
+        }),
+      ).toEqual(true);
+
+      // not match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+          browser_version: "3.0",
+        }),
+      ).toEqual(false);
+
+      expect(
+        allConditionsAreMatched(conditions, {
+          country: "us",
+          browser_version: "2.0",
+        }),
+      ).toEqual(false);
+    });
+
+    it("should match with AND inside OR", function () {
+      const conditions: Condition[] = [
+        {
+          or: [
+            {
+              attribute: "browser_type",
+              operator: "equals",
+              value: "chrome",
+            },
+            {
+              and: [
+                {
+                  attribute: "device_type",
+                  operator: "equals",
+                  value: "mobile",
+                },
+                {
+                  attribute: "orientation",
+                  operator: "equals",
+                  value: "portrait",
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "chrome",
+          browser_version: "2.0",
+        }),
+      ).toEqual(true);
+
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "firefox",
+          device_type: "mobile",
+          orientation: "portrait",
+        }),
+      ).toEqual(true);
+
+      // not match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "firefox",
+          browser_version: "2.0",
+        }),
+      ).toEqual(false);
+
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "firefox",
+          device_type: "desktop",
+        }),
+      ).toEqual(false);
+    });
+
+    it("should match with plain conditions, followed by AND inside OR", function () {
+      const conditions: Condition[] = [
+        {
+          attribute: "country",
+          operator: "equals",
+          value: "nl",
+        },
+        {
+          or: [
+            {
+              attribute: "browser_type",
+              operator: "equals",
+              value: "chrome",
+            },
+            {
+              and: [
+                {
+                  attribute: "device_type",
+                  operator: "equals",
+                  value: "mobile",
+                },
+                {
+                  attribute: "orientation",
+                  operator: "equals",
+                  value: "portrait",
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      // match
+      expect(
+        allConditionsAreMatched(conditions, {
+          country: "nl",
+          browser_type: "chrome",
+          browser_version: "2.0",
+        }),
+      ).toEqual(true);
+
+      expect(
+        allConditionsAreMatched(conditions, {
+          country: "nl",
+          browser_type: "firefox",
+          device_type: "mobile",
+          orientation: "portrait",
+        }),
+      ).toEqual(true);
+
+      // not match
+      expect(
+        allConditionsAreMatched(conditions, {
+          browser_type: "firefox",
+          browser_version: "2.0",
+        }),
+      ).toEqual(false);
+
+      expect(
+        allConditionsAreMatched(conditions, {
+          country: "de",
+          browser_type: "firefox",
+          device_type: "desktop",
+        }),
+      ).toEqual(false);
+    });
+  });
+});

package/src/conditions.ts

@@ -0,0 +1,73 @@
+import { Attributes, Condition, PlainCondition } from "@featurevisor/types";
+
+export function conditionIsMatched(condition: PlainCondition, attributes: Attributes): boolean {
+  const { attribute, operator, value } = condition;
+
+  if (operator === "equals") {
+    return attributes[attribute] === value;
+  } else if (operator === "notEquals") {
+    return attributes[attribute] !== value;
+  } else if (typeof attributes[attribute] === "string" && Array.isArray(value)) {
+    // array
+    const valueInAttributes = attributes[attribute] as string;
+
+    if (operator === "in") {
+      return value.indexOf(valueInAttributes) !== -1;
+    } else if (operator === "notIn") {
+      return value.indexOf(valueInAttributes) === -1;
+    }
+  } else if (typeof attributes[attribute] === "string" && typeof value === "string") {
+    // string
+    const valueInAttributes = attributes[attribute] as string;
+
+    if (operator === "contains") {
+      return valueInAttributes.indexOf(value) !== -1;
+    } else if (operator === "notContains") {
+      return valueInAttributes.indexOf(value) === -1;
+    } else if (operator === "startsWith") {
+      return valueInAttributes.startsWith(value);
+    } else if (operator === "endsWith") {
+      return valueInAttributes.endsWith(value);
+    }
+  } else if (typeof attributes[attribute] === "number" && typeof value === "number") {
+    // numeric
+    const valueInAttributes = attributes[attribute] as number;
+
+    if (operator === "greaterThan") {
+      return valueInAttributes > value;
+    } else if (operator === "greaterThanOrEquals") {
+      return valueInAttributes >= value;
+    } else if (operator === "lessThan") {
+      return valueInAttributes < value;
+    } else if (operator === "lessThanOrEquals") {
+      return valueInAttributes <= value;
+    }
+  }
+
+  return false;
+}
+
+export function allConditionsAreMatched(
+  conditions: Condition[] | Condition,
+  attributes: Attributes,
+): boolean {
+  if ("attribute" in conditions) {
+    return conditionIsMatched(conditions, attributes);
+  }
+
+  if ("and" in conditions && Array.isArray(conditions.and)) {
+    return conditions.and.every((c) => allConditionsAreMatched(c, attributes));
+  }
+
+  if ("or" in conditions && Array.isArray(conditions.or)) {
+    return conditions.or.some((c) => allConditionsAreMatched(c, attributes));
+  }
+
+  // @TODO: introduce `not`
+
+  if (Array.isArray(conditions)) {
+    return conditions.every((c) => allConditionsAreMatched(c, attributes));
+  }
+
+  return false;
+}

package/src/datafileReader.ts

@@ -0,0 +1,73 @@
+import {
+  Feature,
+  Segment,
+  DatafileContent,
+  Attribute,
+  AttributeKey,
+  SegmentKey,
+  FeatureKey,
+} from "@featurevisor/types";
+
+export function parseJsonConditionsIfStringified<T>(record: T, key: string): T {
+  if (typeof record[key] === "string" && record[key] !== "*") {
+    try {
+      record[key] = JSON.parse(record[key]);
+    } catch (e) {
+      console.error("Error parsing JSON", e);
+    }
+  }
+
+  return record;
+}
+
+export class DatafileReader {
+  private schemaVersion: string;
+  private revision: string;
+  private attributes: Attribute[];
+  private segments: Segment[];
+  private features: Feature[];
+
+  constructor(datafileJson: DatafileContent) {
+    this.schemaVersion = datafileJson.schemaVersion;
+    this.revision = datafileJson.revision;
+    this.segments = datafileJson.segments;
+    this.attributes = datafileJson.attributes;
+    this.features = datafileJson.features;
+  }
+
+  getRevision(): string {
+    return this.revision;
+  }
+
+  getSchemaVersion(): string {
+    return this.schemaVersion;
+  }
+
+  getAllAttributes(): Attribute[] {
+    return this.attributes;
+  }
+
+  getAttribute(attributeKey: AttributeKey): Attribute | undefined {
+    return this.attributes.find((a) => a.key === attributeKey);
+  }
+
+  getSegment(segmentKey: SegmentKey): Segment | undefined {
+    const segment = this.segments.find((s) => s.key === segmentKey);
+
+    if (!segment) {
+      return undefined;
+    }
+
+    return parseJsonConditionsIfStringified(segment, "conditions");
+  }
+
+  getFeature(featureKey: FeatureKey): Feature | undefined {
+    const feature = this.features.find((s) => s.key === featureKey);
+
+    if (!feature) {
+      return undefined;
+    }
+
+    return feature;
+  }
+}