@featurevisor/sdk 1.3.0 → 1.16.0

package/src/conditions.ts

@@ -2,6 +2,8 @@ import { compareVersions } from "compare-versions";
 
 import { Context, Condition, PlainCondition } from "@featurevisor/types";
 
+import { Logger } from "./logger";
+
 export function conditionIsMatched(condition: PlainCondition, context: Context): boolean {
   const { attribute, operator, value } = condition;
 
@@ -75,17 +77,30 @@ export function conditionIsMatched(condition: PlainCondition, context: Context):
 export function allConditionsAreMatched(
   conditions: Condition[] | Condition,
   context: Context,
+  logger: Logger,
 ): boolean {
   if ("attribute" in conditions) {
-    return conditionIsMatched(conditions, context);
+    try {
+      return conditionIsMatched(conditions, context);
+    } catch (e) {
+      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) => allConditionsAreMatched(c, context));
+    return conditions.and.every((c) => allConditionsAreMatched(c, context, logger));
   }
 
   if ("or" in conditions && Array.isArray(conditions.or)) {
-    return conditions.or.some((c) => allConditionsAreMatched(c, context));
+    return conditions.or.some((c) => allConditionsAreMatched(c, context, logger));
   }
 
   if ("not" in conditions && Array.isArray(conditions.not)) {
@@ -96,12 +111,13 @@ export function allConditionsAreMatched(
             and: conditions.not,
           },
           context,
+          logger,
         ) === false,
     );
   }
 
   if (Array.isArray(conditions)) {
-    return conditions.every((c) => allConditionsAreMatched(c, context));
+    return conditions.every((c) => allConditionsAreMatched(c, context, logger));
   }
 
   return false;

package/src/feature.ts

@@ -2,6 +2,7 @@ import { Allocation, Context, Traffic, Feature, Force } from "@featurevisor/type
 import { DatafileReader } from "./datafileReader";
 import { allGroupSegmentsAreMatched } from "./segments";
 import { allConditionsAreMatched } from "./conditions";
+import { Logger } from "./logger";
 
 export function getMatchedAllocation(
   traffic: Traffic,
@@ -30,10 +31,16 @@ export function getMatchedTraffic(
   traffic: Traffic[],
   context: Context,
   datafileReader: DatafileReader,
+  logger: Logger,
 ): Traffic | undefined {
   return traffic.find((t) => {
     if (
-      !allGroupSegmentsAreMatched(parseFromStringifiedSegments(t.segments), context, datafileReader)
+      !allGroupSegmentsAreMatched(
+        parseFromStringifiedSegments(t.segments),
+        context,
+        datafileReader,
+        logger,
+      )
     ) {
       return false;
     }
@@ -52,12 +59,14 @@ export function getMatchedTrafficAndAllocation(
   context: Context,
   bucketValue: number,
   datafileReader: DatafileReader,
+  logger: Logger,
 ): MatchedTrafficAndAllocation {
   const matchedTraffic = traffic.find((t) => {
     return allGroupSegmentsAreMatched(
       parseFromStringifiedSegments(t.segments),
       context,
       datafileReader,
+      logger,
     );
   });
 
@@ -80,6 +89,7 @@ export function findForceFromFeature(
   feature: Feature,
   context: Context,
   datafileReader: DatafileReader,
+  logger: Logger,
 ): Force | undefined {
   if (!feature.force) {
     return undefined;
@@ -87,11 +97,11 @@ export function findForceFromFeature(
 
   return feature.force.find((f: Force) => {
     if (f.conditions) {
-      return allConditionsAreMatched(f.conditions, context);
+      return allConditionsAreMatched(f.conditions, context, logger);
     }
 
     if (f.segments) {
-      return allGroupSegmentsAreMatched(f.segments, context, datafileReader);
+      return allGroupSegmentsAreMatched(f.segments, context, datafileReader, logger);
     }
 
     return false;

package/src/index.ts

@@ -2,3 +2,4 @@ export * from "./bucket";
 export * from "./instance";
 export * from "./logger";
 export * from "./conditions";
+export * from "./emitter";

package/src/instance.ts

@@ -521,7 +521,7 @@ export class FeaturevisorInstance {
       const finalContext = this.interceptContext ? this.interceptContext(context) : context;
 
       // forced
-      const force = findForceFromFeature(feature, context, this.datafileReader);
+      const force = findForceFromFeature(feature, context, this.datafileReader, this.logger);
 
       if (force && typeof force.enabled !== "undefined") {
         evaluation = {
@@ -579,7 +579,12 @@ export class FeaturevisorInstance {
       // bucketing
       const bucketValue = this.getBucketValue(feature, finalContext);
 
-      const matchedTraffic = getMatchedTraffic(feature.traffic, finalContext, this.datafileReader);
+      const matchedTraffic = getMatchedTraffic(
+        feature.traffic,
+        finalContext,
+        this.datafileReader,
+        this.logger,
+      );
 
       if (matchedTraffic) {
         // check if mutually exclusive
@@ -774,7 +779,7 @@ export class FeaturevisorInstance {
       const finalContext = this.interceptContext ? this.interceptContext(context) : context;
 
       // forced
-      const force = findForceFromFeature(feature, context, this.datafileReader);
+      const force = findForceFromFeature(feature, context, this.datafileReader, this.logger);
 
       if (force && force.variation) {
         const variation = feature.variations.find((v) => v.value === force.variation);
@@ -800,6 +805,7 @@ export class FeaturevisorInstance {
         finalContext,
         bucketValue,
         this.datafileReader,
+        this.logger,
       );
 
       if (matchedTraffic) {
@@ -1040,7 +1046,7 @@ export class FeaturevisorInstance {
       const finalContext = this.interceptContext ? this.interceptContext(context) : context;
 
       // forced
-      const force = findForceFromFeature(feature, context, this.datafileReader);
+      const force = findForceFromFeature(feature, context, this.datafileReader, this.logger);
 
       if (force && force.variables && typeof force.variables[variableKey] !== "undefined") {
         evaluation = {
@@ -1064,6 +1070,7 @@ export class FeaturevisorInstance {
         finalContext,
         bucketValue,
         this.datafileReader,
+        this.logger,
       );
 
       if (matchedTraffic) {
@@ -1109,6 +1116,7 @@ export class FeaturevisorInstance {
                     return allConditionsAreMatched(
                       typeof o.conditions === "string" ? JSON.parse(o.conditions) : o.conditions,
                       finalContext,
+                      this.logger,
                     );
                   }
 
@@ -1117,6 +1125,7 @@ export class FeaturevisorInstance {
                       parseFromStringifiedSegments(o.segments),
                       finalContext,
                       this.datafileReader,
+                      this.logger,
                     );
                   }
 

package/src/segments.spec.ts

@@ -1,6 +1,8 @@
+import { DatafileContent, GroupSegment } from "@featurevisor/types";
+
 import { DatafileReader } from "./datafileReader";
 import { allGroupSegmentsAreMatched } from "./segments";
-import { DatafileContent, GroupSegment } from "@featurevisor/types";
+import { createLogger } from "./logger";
 
 interface Group {
   key: string;
@@ -8,6 +10,8 @@ interface Group {
 }
 
 describe("sdk: Segments", function () {
+  const logger = createLogger();
+
   it("should be a function", function () {
     expect(typeof allGroupSegmentsAreMatched).toEqual("function");
   });
@@ -178,13 +182,13 @@ describe("sdk: Segments", 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,
-      );
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(true);
+      expect(
+        allGroupSegmentsAreMatched(group.segments, { foo: "foo" }, datafileReader, logger),
+      ).toEqual(true);
+      expect(
+        allGroupSegmentsAreMatched(group.segments, { bar: "bar" }, datafileReader, logger),
+      ).toEqual(true);
     });
 
     it("should match dutchMobileUsers", function () {
@@ -196,6 +200,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -203,16 +208,18 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "mobile", browser: "chrome" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
 
       // not match
-      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(false);
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(false);
       expect(
         allGroupSegmentsAreMatched(
           group.segments,
           { country: "de", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(false);
     });
@@ -226,6 +233,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -233,16 +241,18 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "mobile", browser: "chrome" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
 
       // not match
-      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(false);
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(false);
       expect(
         allGroupSegmentsAreMatched(
           group.segments,
           { country: "de", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(false);
     });
@@ -256,6 +266,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -263,6 +274,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "mobile", browser: "chrome" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -270,6 +282,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "desktop" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -277,16 +290,18 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "desktop", browser: "chrome" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
 
       // not match
-      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(false);
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(false);
       expect(
         allGroupSegmentsAreMatched(
           group.segments,
           { country: "de", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(false);
       expect(
@@ -294,6 +309,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "de", deviceType: "desktop" },
           datafileReader,
+          logger,
         ),
       ).toEqual(false);
     });
@@ -307,6 +323,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -314,6 +331,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "mobile", browser: "chrome" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -321,6 +339,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "desktop" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -328,16 +347,18 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "nl", deviceType: "desktop", browser: "chrome" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
 
       // not match
-      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(false);
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(false);
       expect(
         allGroupSegmentsAreMatched(
           group.segments,
           { country: "de", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(false);
       expect(
@@ -345,6 +366,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "de", deviceType: "desktop" },
           datafileReader,
+          logger,
         ),
       ).toEqual(false);
     });
@@ -358,6 +380,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "de", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -365,16 +388,18 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "de", deviceType: "mobile", browser: "chrome" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
 
       // not match
-      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(false);
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(false);
       expect(
         allGroupSegmentsAreMatched(
           group.segments,
           { country: "nl", deviceType: "mobile" },
           datafileReader,
+          logger,
         ),
       ).toEqual(false);
     });
@@ -388,6 +413,7 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "de", deviceType: "desktop" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
       expect(
@@ -395,16 +421,18 @@ describe("sdk: Segments", function () {
           group.segments,
           { country: "de", deviceType: "desktop", browser: "chrome" },
           datafileReader,
+          logger,
         ),
       ).toEqual(true);
 
       // not match
-      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(false);
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(false);
       expect(
         allGroupSegmentsAreMatched(
           group.segments,
           { country: "nl", deviceType: "desktop" },
           datafileReader,
+          logger,
         ),
       ).toEqual(false);
     });
@@ -413,28 +441,28 @@ describe("sdk: Segments", function () {
       const group = groups.find((g) => g.key === "notVersion5.5") as Group;
 
       // match
-      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(true);
-      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader)).toEqual(true);
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(true);
+      expect(allGroupSegmentsAreMatched(group.segments, {}, datafileReader, logger)).toEqual(true);
+      expect(
+        allGroupSegmentsAreMatched(group.segments, { version: "5.6" }, datafileReader, logger),
+      ).toEqual(true);
       expect(
-        allGroupSegmentsAreMatched(group.segments, { version: "5.6" }, datafileReader),
+        allGroupSegmentsAreMatched(group.segments, { version: 5.6 }, datafileReader, logger),
       ).toEqual(true);
-      expect(allGroupSegmentsAreMatched(group.segments, { version: 5.6 }, datafileReader)).toEqual(
-        true,
-      );
       expect(
-        allGroupSegmentsAreMatched(group.segments, { version: "5.7" }, datafileReader),
+        allGroupSegmentsAreMatched(group.segments, { version: "5.7" }, datafileReader, logger),
+      ).toEqual(true);
+      expect(
+        allGroupSegmentsAreMatched(group.segments, { version: 5.7 }, datafileReader, logger),
       ).toEqual(true);
-      expect(allGroupSegmentsAreMatched(group.segments, { version: 5.7 }, datafileReader)).toEqual(
-        true,
-      );
 
       // not match
       expect(
-        allGroupSegmentsAreMatched(group.segments, { version: "5.5" }, datafileReader),
+        allGroupSegmentsAreMatched(group.segments, { version: "5.5" }, datafileReader, logger),
+      ).toEqual(false);
+      expect(
+        allGroupSegmentsAreMatched(group.segments, { version: 5.5 }, datafileReader, logger),
       ).toEqual(false);
-      expect(allGroupSegmentsAreMatched(group.segments, { version: 5.5 }, datafileReader)).toEqual(
-        false,
-      );
     });
   });
 });

package/src/segments.ts

@@ -1,15 +1,17 @@
 import { Context, GroupSegment, Segment, Condition } from "@featurevisor/types";
 import { allConditionsAreMatched } from "./conditions";
 import { DatafileReader } from "./datafileReader";
+import { Logger } from "./logger";
 
-export function segmentIsMatched(segment: Segment, context: Context): boolean {
-  return allConditionsAreMatched(segment.conditions as Condition | Condition[], context);
+export function segmentIsMatched(segment: Segment, context: Context, logger: Logger): boolean {
+  return allConditionsAreMatched(segment.conditions as Condition | Condition[], context, logger);
 }
 
 export function allGroupSegmentsAreMatched(
   groupSegments: GroupSegment | GroupSegment[] | "*",
   context: Context,
   datafileReader: DatafileReader,
+  logger: Logger,
 ): boolean {
   if (groupSegments === "*") {
     return true;
@@ -19,7 +21,7 @@ export function allGroupSegmentsAreMatched(
     const segment = datafileReader.getSegment(groupSegments);
 
     if (segment) {
-      return segmentIsMatched(segment, context);
+      return segmentIsMatched(segment, context, logger);
     }
 
     return false;
@@ -28,27 +30,27 @@ export function allGroupSegmentsAreMatched(
   if (typeof groupSegments === "object") {
     if ("and" in groupSegments && Array.isArray(groupSegments.and)) {
       return groupSegments.and.every((groupSegment) =>
-        allGroupSegmentsAreMatched(groupSegment, context, datafileReader),
+        allGroupSegmentsAreMatched(groupSegment, context, datafileReader, logger),
       );
     }
 
     if ("or" in groupSegments && Array.isArray(groupSegments.or)) {
       return groupSegments.or.some((groupSegment) =>
-        allGroupSegmentsAreMatched(groupSegment, context, datafileReader),
+        allGroupSegmentsAreMatched(groupSegment, context, datafileReader, logger),
       );
     }
 
     if ("not" in groupSegments && Array.isArray(groupSegments.not)) {
       return groupSegments.not.every(
         (groupSegment) =>
-          allGroupSegmentsAreMatched(groupSegment, context, datafileReader) === false,
+          allGroupSegmentsAreMatched(groupSegment, context, datafileReader, logger) === false,
       );
     }
   }
 
   if (Array.isArray(groupSegments)) {
     return groupSegments.every((groupSegment) =>
-      allGroupSegmentsAreMatched(groupSegment, context, datafileReader),
+      allGroupSegmentsAreMatched(groupSegment, context, datafileReader, logger),
     );
   }