@featurevisor/sdk 1.35.3 → 2.0.1

package/src/datafileReader.ts

@@ -1,71 +1,58 @@
-import {
+import type {
   Feature,
   Segment,
-  DatafileContentV1,
-  DatafileContentV2,
-  Attribute,
-  AttributeKey,
+  DatafileContent,
   SegmentKey,
   FeatureKey,
+  Context,
+  Traffic,
+  Allocation,
+  GroupSegment,
+  Condition,
+  Force,
 } 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);
-    }
-  }
+import { conditionIsMatched } from "./conditions";
+import { Logger } from "./logger";
+
+export type GetRegex = (regexString: string, regexFlags: string) => RegExp;
+
+export interface DatafileReaderOptions {
+  datafile: DatafileContent;
+  logger: Logger;
+}
 
-  return record;
+export interface ForceResult {
+  force?: Force;
+  forceIndex?: number;
 }
 
 export class DatafileReader {
   private schemaVersion: string;
   private revision: string;
 
-  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;
+  private logger: Logger;
 
-    if (this.schemaVersion === "2") {
-      // v2
-      const datafileJsonV2 = datafileJson as DatafileContentV2;
+  // done to avoid creating new RegExp objects for the same regex string and flags.
+  // kept here to avoid memory leaks.
+  // if datafile is reset, this cache will be cleared.
+  private regexCache: Record<string, RegExp>;
 
-      this.attributes = datafileJsonV2.attributes;
-      this.segments = datafileJsonV2.segments;
-      this.features = datafileJsonV2.features;
-    } else {
-      // v1
-      const datafileJsonV1 = datafileJson as DatafileContentV1;
+  constructor(options: DatafileReaderOptions) {
+    const { datafile, logger } = options;
 
-      this.attributes = {};
-      datafileJsonV1.attributes.forEach((a) => {
-        this.attributes[a.key] = a;
-      });
+    this.logger = logger;
 
-      this.segments = {};
-      datafileJsonV1.segments.forEach((s) => {
-        this.segments[s.key] = s;
-      });
+    this.schemaVersion = datafile.schemaVersion;
+    this.revision = datafile.revision;
 
-      this.features = {};
-      datafileJsonV1.features.forEach((f) => {
-        if (Array.isArray(f.variablesSchema)) {
-          f.variablesSchema = f.variablesSchema.reduce((acc, variable) => {
-            acc[variable.key] = variable;
-            return acc;
-          }, {});
-        }
+    this.segments = datafile.segments;
+    this.features = datafile.features;
 
-        this.features[f.key] = f;
-      });
-    }
+    this.regexCache = {};
   }
 
   getRevision(): string {
@@ -76,31 +63,264 @@ export class DatafileReader {
     return this.schemaVersion;
   }
 
-  getAllAttributes(): Attribute[] {
-    const result: Attribute[] = [];
+  getSegment(segmentKey: SegmentKey): Segment | undefined {
+    const segment = this.segments[segmentKey];
 
-    Object.keys(this.attributes).forEach((key) => {
-      result.push(this.attributes[key]);
-    });
+    if (!segment) {
+      return undefined;
+    }
 
-    return result;
+    segment.conditions = this.parseConditionsIfStringified(segment.conditions);
+
+    return segment;
   }
 
-  getAttribute(attributeKey: AttributeKey): Attribute | undefined {
-    return this.attributes[attributeKey];
+  getFeatureKeys(): string[] {
+    return Object.keys(this.features);
   }
 
-  getSegment(segmentKey: SegmentKey): Segment | undefined {
-    const segment = this.segments[segmentKey];
+  getFeature(featureKey: FeatureKey): Feature | undefined {
+    return this.features[featureKey];
+  }
 
-    if (!segment) {
+  getVariableKeys(featureKey: FeatureKey): string[] {
+    const feature = this.getFeature(featureKey);
+
+    if (!feature) {
+      return [];
+    }
+
+    return Object.keys(feature.variablesSchema || {});
+  }
+
+  hasVariations(featureKey: FeatureKey): boolean {
+    const feature = this.getFeature(featureKey);
+
+    if (!feature) {
+      return false;
+    }
+
+    return Array.isArray(feature.variations) && feature.variations.length > 0;
+  }
+
+  getRegex(regexString: string, regexFlags?: string): RegExp {
+    const flags = regexFlags || "";
+    const cacheKey = `${regexString}-${flags}`;
+
+    if (this.regexCache[cacheKey]) {
+      return this.regexCache[cacheKey];
+    }
+
+    const regex = new RegExp(regexString, flags);
+    this.regexCache[cacheKey] = regex;
+
+    return regex;
+  }
+
+  allConditionsAreMatched(conditions: Condition[] | Condition, context: Context): boolean {
+    if (typeof conditions === "string") {
+      if (conditions === "*") {
+        return true;
+      }
+
+      return false;
+    }
+
+    const getRegex = (regexString: string, regexFlags: string) =>
+      this.getRegex(regexString, regexFlags);
+
+    if ("attribute" in conditions) {
+      try {
+        return conditionIsMatched(conditions, context, getRegex);
+      } catch (e) {
+        this.logger.warn(e.message, {
+          error: e,
+          details: {
+            condition: conditions,
+            context,
+          },
+        });
+
+        return false;
+      }
+    }
+
+    if ("and" in conditions && Array.isArray(conditions.and)) {
+      return conditions.and.every((c) => this.allConditionsAreMatched(c, context));
+    }
+
+    if ("or" in conditions && Array.isArray(conditions.or)) {
+      return conditions.or.some((c) => this.allConditionsAreMatched(c, context));
+    }
+
+    if ("not" in conditions && Array.isArray(conditions.not)) {
+      return conditions.not.every(
+        () =>
+          this.allConditionsAreMatched(
+            {
+              and: conditions.not,
+            },
+            context,
+          ) === false,
+      );
+    }
+
+    if (Array.isArray(conditions)) {
+      return conditions.every((c) => this.allConditionsAreMatched(c, context));
+    }
+
+    return false;
+  }
+
+  segmentIsMatched(segment: Segment, context: Context): boolean {
+    return this.allConditionsAreMatched(segment.conditions as Condition | Condition[], context);
+  }
+
+  allSegmentsAreMatched(
+    groupSegments: GroupSegment | GroupSegment[] | "*",
+    context: Context,
+  ): boolean {
+    if (groupSegments === "*") {
+      return true;
+    }
+
+    if (typeof groupSegments === "string") {
+      const segment = this.getSegment(groupSegments);
+
+      if (segment) {
+        return this.segmentIsMatched(segment, context);
+      }
+
+      return false;
+    }
+
+    if (typeof groupSegments === "object") {
+      if ("and" in groupSegments && Array.isArray(groupSegments.and)) {
+        return groupSegments.and.every((groupSegment) =>
+          this.allSegmentsAreMatched(groupSegment, context),
+        );
+      }
+
+      if ("or" in groupSegments && Array.isArray(groupSegments.or)) {
+        return groupSegments.or.some((groupSegment) =>
+          this.allSegmentsAreMatched(groupSegment, context),
+        );
+      }
+
+      if ("not" in groupSegments && Array.isArray(groupSegments.not)) {
+        return groupSegments.not.every(
+          (groupSegment) => this.allSegmentsAreMatched(groupSegment, context) === false,
+        );
+      }
+    }
+
+    if (Array.isArray(groupSegments)) {
+      return groupSegments.every((groupSegment) =>
+        this.allSegmentsAreMatched(groupSegment, context),
+      );
+    }
+
+    return false;
+  }
+
+  getMatchedTraffic(traffic: Traffic[], context: Context): Traffic | undefined {
+    return traffic.find((t) => {
+      if (!this.allSegmentsAreMatched(this.parseSegmentsIfStringified(t.segments), context)) {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  getMatchedAllocation(traffic: Traffic, bucketValue: number): Allocation | undefined {
+    if (!traffic.allocation) {
       return undefined;
     }
 
-    return parseJsonConditionsIfStringified(segment, "conditions");
+    for (const allocation of traffic.allocation) {
+      const [start, end] = allocation.range;
+
+      if (allocation.range && start <= bucketValue && end >= bucketValue) {
+        return allocation;
+      }
+    }
+
+    return undefined;
   }
 
-  getFeature(featureKey: FeatureKey): Feature | undefined {
-    return this.features[featureKey];
+  getMatchedForce(featureKey: FeatureKey | Feature, context: Context): ForceResult {
+    const result: ForceResult = {
+      force: undefined,
+      forceIndex: undefined,
+    };
+
+    const feature = typeof featureKey === "string" ? this.getFeature(featureKey) : featureKey;
+
+    if (!feature || !feature.force) {
+      return result;
+    }
+
+    for (let i = 0; i < feature.force.length; i++) {
+      const currentForce = feature.force[i];
+
+      if (
+        currentForce.conditions &&
+        this.allConditionsAreMatched(
+          this.parseConditionsIfStringified(currentForce.conditions),
+          context,
+        )
+      ) {
+        result.force = currentForce;
+        result.forceIndex = i;
+        break;
+      }
+
+      if (
+        currentForce.segments &&
+        this.allSegmentsAreMatched(this.parseSegmentsIfStringified(currentForce.segments), context)
+      ) {
+        result.force = currentForce;
+        result.forceIndex = i;
+        break;
+      }
+    }
+
+    return result;
+  }
+
+  parseConditionsIfStringified(conditions: Condition | Condition[]): Condition | Condition[] {
+    if (typeof conditions !== "string") {
+      // already parsed
+      return conditions;
+    }
+
+    if (conditions === "*") {
+      // everyone
+      return conditions;
+    }
+
+    try {
+      return JSON.parse(conditions);
+    } catch (e) {
+      this.logger.error("Error parsing conditions", {
+        error: e,
+        details: {
+          conditions,
+        },
+      });
+
+      return conditions;
+    }
+  }
+
+  parseSegmentsIfStringified(
+    segments: GroupSegment | GroupSegment[],
+  ): GroupSegment | GroupSegment[] {
+    if (typeof segments === "string" && (segments.startsWith("{") || segments.startsWith("["))) {
+      return JSON.parse(segments);
+    }
+
+    return segments;
   }
 }

package/src/emitter.spec.ts

@@ -1,100 +1,41 @@
-import { Emitter } from "./emitter";
+import { Emitter, EventDetails } from "./emitter";
 
-describe("sdk :: Emitter", () => {
+describe("Emitter", () => {
   let emitter: Emitter;
+  let handledDetails: EventDetails[] = [];
+
+  function handleDetails(details: EventDetails) {
+    handledDetails.push(details);
+  }
 
   beforeEach(() => {
     emitter = new Emitter();
+    handledDetails = [];
   });
 
-  describe("addListener", () => {
-    it("should add a listener", () => {
-      const fn = jest.fn();
-
-      emitter.addListener("ready", fn);
-
-      expect(emitter["_listeners"]["ready"]).toEqual([fn]);
-    });
-
-    it("should add multiple listeners", () => {
-      const fn1 = jest.fn();
-      const fn2 = jest.fn();
-
-      emitter.addListener("ready", fn1);
-      emitter.addListener("ready", fn2);
-
-      expect(emitter["_listeners"]["ready"]).toEqual([fn1, fn2]);
-    });
-
-    it("should add multiple listeners for different events", () => {
-      const fn1 = jest.fn();
-      const fn2 = jest.fn();
-
-      emitter.addListener("ready", fn1);
-      emitter.addListener("update", fn2);
-
-      expect(emitter["_listeners"]["ready"]).toEqual([fn1]);
-      expect(emitter["_listeners"]["update"]).toEqual([fn2]);
-    });
-  });
-
-  describe("removeListener", () => {
-    it("should remove a listener", () => {
-      const fn = jest.fn();
-
-      emitter.addListener("ready", fn);
-      emitter.removeListener("ready", fn);
-      emitter.removeListener("update", fn);
-
-      expect(emitter["_listeners"]["ready"]).toEqual([]);
-    });
-
-    it("should remove multiple listeners", () => {
-      const fn1 = jest.fn();
-      const fn2 = jest.fn();
-
-      emitter.addListener("ready", fn1);
-      emitter.addListener("ready", fn2);
-      emitter.removeListener("ready", fn1);
-      emitter.removeListener("ready", fn2);
-
-      expect(emitter["_listeners"]["ready"]).toEqual([]);
-    });
-
-    it("should remove multiple listeners for different events", () => {
-      const fn1 = jest.fn();
-      const fn2 = jest.fn();
-
-      emitter.addListener("ready", fn1);
-      emitter.addListener("update", fn2);
-      emitter.removeListener("ready", fn1);
-      emitter.removeListener("update", fn2);
-
-      expect(emitter["_listeners"]["ready"]).toEqual([]);
-      expect(emitter["_listeners"]["update"]).toEqual([]);
-    });
-  });
+  it("should add a listener for an event", function () {
+    const unsubscribe = emitter.on("datafile_set", handleDetails);
 
-  describe("removeAllListeners", () => {
-    it("should remove all listeners", () => {
-      const fn1 = jest.fn();
-      const fn2 = jest.fn();
+    expect(emitter.listeners["datafile_set"]).toContain(handleDetails);
+    expect(emitter.listeners["datafile_changed"]).toBeUndefined();
+    expect(emitter.listeners["context_set"]).toBeUndefined();
+    expect(emitter.listeners["datafile_set"].length).toBe(1);
 
-      emitter.addListener("ready", fn1);
-      emitter.addListener("update", fn2);
-      emitter.removeAllListeners();
-    });
+    // trigger already subscribed event
+    emitter.trigger("datafile_set", { key: "value" });
+    expect(handledDetails.length).toBe(1);
+    expect(handledDetails[0]).toEqual({ key: "value" });
 
-    it("should remove all listeners for a specific event", () => {
-      const fn1 = jest.fn();
-      const fn2 = jest.fn();
+    // trigger unsubscribed event
+    emitter.trigger("sticky_set", { key: "value2" });
+    expect(handledDetails.length).toBe(1);
 
-      emitter.addListener("ready", fn1);
-      emitter.addListener("update", fn2);
-      emitter.removeAllListeners("ready");
+    // unsubscribe
+    unsubscribe();
+    expect(emitter.listeners["datafile_set"].length).toBe(0);
 
-      expect(emitter["_listeners"]["ready"]).toEqual([]);
-      expect(emitter["_listeners"]["update"]).toEqual([fn2]);
-    });
+    // clear all
+    emitter.clearAll();
+    expect(emitter.listeners).toEqual({});
   });
 });

package/src/emitter.ts

@@ -1,53 +1,59 @@
-export type EventName = "ready" | "refresh" | "update" | "activation";
+export type EventName = "datafile_set" | "context_set" | "sticky_set";
 
-export interface Listeners {
-  [key: string]: Function[];
-}
+export type EventDetails = Record<string, unknown>;
+
+export type EventCallback = (details: EventDetails) => void;
+
+export type Listeners = Record<EventName, EventCallback[]> | {}; // eslint-disable-line
 
 export class Emitter {
-  private _listeners: Listeners;
+  listeners: Listeners;
 
   constructor() {
-    this._listeners = {};
+    this.listeners = {};
   }
 
-  public addListener(eventName: EventName, fn: Function): void {
-    if (typeof this._listeners[eventName] === "undefined") {
-      this._listeners[eventName] = [];
+  on(eventName: EventName, callback: EventCallback) {
+    if (!this.listeners[eventName]) {
+      this.listeners[eventName] = [];
     }
 
-    this._listeners[eventName].push(fn);
-  }
+    const listeners = this.listeners[eventName];
+    listeners.push(callback);
 
-  public removeListener(eventName: EventName, fn: Function): void {
-    if (typeof this._listeners[eventName] === "undefined") {
-      return;
-    }
+    let isActive = true;
 
-    const index = this._listeners[eventName].indexOf(fn);
+    return function unsubscribe() {
+      if (!isActive) {
+        return;
+      }
 
-    if (index !== -1) {
-      this._listeners[eventName].splice(index, 1);
-    }
-  }
+      isActive = false;
 
-  public removeAllListeners(eventName?: EventName): void {
-    if (eventName) {
-      this._listeners[eventName] = [];
-    } else {
-      Object.keys(this._listeners).forEach((key) => {
-        this._listeners[key] = [];
-      });
-    }
+      const index = listeners.indexOf(callback);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    };
   }
 
-  public emit(eventName: EventName, ...args: any[]): void {
-    if (typeof this._listeners[eventName] === "undefined") {
+  trigger(eventName: EventName, details: EventDetails = {}) {
+    const listeners = this.listeners[eventName];
+
+    if (!listeners) {
       return;
     }
 
-    this._listeners[eventName].forEach((fn) => {
-      fn(...args);
+    listeners.forEach(function (listener) {
+      try {
+        listener(details);
+      } catch (err) {
+        console.error(err);
+      }
     });
   }
+
+  clearAll() {
+    this.listeners = {};
+  }
 }