flagsmith-nodejs 3.3.0 → 3.3.2

package/build/flagsmith-engine/segments/models.js

@@ -52,7 +52,7 @@ exports.matchingFunctions = (_a = {},
     },
     _a[constants_1.CONDITION_OPERATORS.NOT_EQUAL] = function (thisValue, otherValue) { return thisValue != otherValue; },
     _a[constants_1.CONDITION_OPERATORS.CONTAINS] = function (thisValue, otherValue) {
-        return otherValue.includes(thisValue);
+        return !!otherValue && otherValue.includes(thisValue);
     },
     _a);
 exports.semverMatchingFunction = __assign(__assign({}, exports.matchingFunctions), (_b = {}, _b[constants_1.CONDITION_OPERATORS.EQUAL] = function (thisValue, otherValue) { return semver_1.default.eq(thisValue, otherValue); }, _b[constants_1.CONDITION_OPERATORS.GREATER_THAN] = function (thisValue, otherValue) { return semver_1.default.gt(otherValue, thisValue); }, _b[constants_1.CONDITION_OPERATORS.GREATER_THAN_INCLUSIVE] = function (thisValue, otherValue) {
@@ -79,10 +79,13 @@ var SegmentConditionModel = /** @class */ (function () {
         var _this = this;
         var evaluators = {
             evaluateNotContains: function (traitValue) {
-                return !traitValue.includes(_this.value);
+                var _a;
+                return typeof traitValue == "string" &&
+                    !!_this.value &&
+                    !traitValue.includes((_a = _this.value) === null || _a === void 0 ? void 0 : _a.toString());
             },
             evaluateRegex: function (traitValue) {
-                return !!_this.value && !!traitValue.match(new RegExp(_this.value));
+                return !!_this.value && !!(traitValue === null || traitValue === void 0 ? void 0 : traitValue.toString().match(new RegExp(_this.value)));
             },
             evaluateModulo: function (traitValue) {
                 if (isNaN(parseFloat(traitValue)) || !_this.value) {

package/build/sdk/analytics.d.ts

@@ -8,6 +8,7 @@ export declare class AnalyticsProcessor {
     };
     private requestTimeoutMs;
     private logger;
+    private currentFlush;
     /**
      * AnalyticsProcessor is used to track how often individual Flags are evaluated within
      * the Flagsmith SDK. Docs: https://docs.flagsmith.com/advanced-use/flag-analytics.

package/build/sdk/analytics.js

@@ -73,24 +73,25 @@ var AnalyticsProcessor = /** @class */ (function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!Object.keys(this.analyticsData).length) {
+                        if (this.currentFlush || !Object.keys(this.analyticsData).length) {
                             return [2 /*return*/];
                         }
                         _a.label = 1;
                     case 1:
-                        _a.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, (0, node_fetch_1.default)(this.analyticsEndpoint, {
-                                method: 'POST',
-                                body: JSON.stringify(this.analyticsData),
-                                timeout: this.requestTimeoutMs,
-                                headers: {
-                                    'Content-Type': 'application/json',
-                                    'X-Environment-Key': this.environmentKey
-                                }
-                            })];
+                        _a.trys.push([1, 3, 4, 5]);
+                        this.currentFlush = (0, node_fetch_1.default)(this.analyticsEndpoint, {
+                            method: 'POST',
+                            body: JSON.stringify(this.analyticsData),
+                            timeout: this.requestTimeoutMs,
+                            headers: {
+                                'Content-Type': 'application/json',
+                                'X-Environment-Key': this.environmentKey
+                            }
+                        });
+                        return [4 /*yield*/, this.currentFlush];
                     case 2:
                         _a.sent();
-                        return [3 /*break*/, 4];
+                        return [3 /*break*/, 5];
                     case 3:
                         error_1 = _a.sent();
                         // We don't want failing to write analytics to cause any exceptions in the main
@@ -98,6 +99,9 @@ var AnalyticsProcessor = /** @class */ (function () {
                         this.logger.warn('Failed to post analytics to Flagsmith API. Not clearing data, will retry.');
                         return [2 /*return*/];
                     case 4:
+                        this.currentFlush = undefined;
+                        return [7 /*endfinally*/];
+                    case 5:
                         this.analyticsData = {};
                         this.lastFlushed = Date.now();
                         return [2 /*return*/];

package/flagsmith-engine/segments/models.ts

@@ -27,7 +27,7 @@ export const matchingFunctions = {
         thisValue >= otherValue,
     [CONDITION_OPERATORS.NOT_EQUAL]: (thisValue: any, otherValue: any) => thisValue != otherValue,
     [CONDITION_OPERATORS.CONTAINS]: (thisValue: any, otherValue: any) =>
-        otherValue.includes(thisValue),
+        !!otherValue && otherValue.includes(thisValue),
 };
 
 export const semverMatchingFunction = {
@@ -64,10 +64,12 @@ export class SegmentConditionModel {
     matchesTraitValue(traitValue: any) {
         const evaluators: { [key: string]: CallableFunction } = {
             evaluateNotContains: (traitValue: any) => {
-                return !traitValue.includes(this.value);
+                return typeof traitValue == "string" &&
+                    !!this.value &&
+                    !traitValue.includes(this.value?.toString());
             },
             evaluateRegex: (traitValue: any) => {
-                return !!this.value && !!traitValue.match(new RegExp(this.value));
+                return !!this.value && !!traitValue?.toString().match(new RegExp(this.value));
             },
             evaluateModulo: (traitValue: any) => {
                 if (isNaN(parseFloat(traitValue)) || !this.value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flagsmith-nodejs",
-  "version": "3.3.0",
+  "version": "3.3.2",
   "description": "Flagsmith lets you manage features flags and remote config across web, mobile and server side applications. Deliver true Continuous Integration. Get builds out faster. Control who has access to new features.",
   "main": "build/index.js",
   "repository": {

package/sdk/analytics.ts

@@ -13,6 +13,7 @@ export class AnalyticsProcessor {
     analyticsData: { [key: string]: any };
     private requestTimeoutMs: number = 3000;
     private logger: Logger;
+    private currentFlush: ReturnType<typeof fetch> | undefined;
 
     /**
      * AnalyticsProcessor is used to track how often individual Flags are evaluated within
@@ -35,12 +36,12 @@ export class AnalyticsProcessor {
      * Sends all the collected data to the api asynchronously and resets the timer
      */
     async flush() {
-        if (!Object.keys(this.analyticsData).length) {
+        if (this.currentFlush || !Object.keys(this.analyticsData).length) {
             return;
         }
 
         try {
-            await fetch(this.analyticsEndpoint, {
+            this.currentFlush = fetch(this.analyticsEndpoint, {
                 method: 'POST',
                 body: JSON.stringify(this.analyticsData),
                 timeout: this.requestTimeoutMs,
@@ -48,12 +49,15 @@ export class AnalyticsProcessor {
                     'Content-Type': 'application/json',
                     'X-Environment-Key': this.environmentKey
                 }
-            })
+            });
+            await this.currentFlush;
         } catch (error) {
             // We don't want failing to write analytics to cause any exceptions in the main
             // thread so we just swallow them here.
             this.logger.warn('Failed to post analytics to Flagsmith API. Not clearing data, will retry.')
             return;
+        } finally {
+            this.currentFlush = undefined;
         }
 
         this.analyticsData = {};

package/tests/engine/unit/segments/segments_model.test.ts

@@ -11,7 +11,7 @@ import {
     SegmentRuleModel
 } from '../../../../flagsmith-engine/segments/models';
 
-const conditionMatchCases: [string, string | number | boolean, string, boolean][] = [
+const conditionMatchCases: [string, string | number | boolean | null, string, boolean][] = [
     [CONDITION_OPERATORS.EQUAL, 'bar', 'bar', true],
     [CONDITION_OPERATORS.EQUAL, 'bar', 'baz', false],
     [CONDITION_OPERATORS.EQUAL, 1, '1', true],
@@ -57,11 +57,14 @@ const conditionMatchCases: [string, string | number | boolean, string, boolean][
     [CONDITION_OPERATORS.CONTAINS, 'bar', 'b', true],
     [CONDITION_OPERATORS.CONTAINS, 'bar', 'bar', true],
     [CONDITION_OPERATORS.CONTAINS, 'bar', 'baz', false],
+    [CONDITION_OPERATORS.CONTAINS, null, 'foo', false],
     [CONDITION_OPERATORS.NOT_CONTAINS, 'bar', 'b', false],
     [CONDITION_OPERATORS.NOT_CONTAINS, 'bar', 'bar', false],
     [CONDITION_OPERATORS.NOT_CONTAINS, 'bar', 'baz', true],
+    [CONDITION_OPERATORS.NOT_CONTAINS, null, 'foo', false],
     [CONDITION_OPERATORS.REGEX, 'foo', '[a-z]+', true],
     [CONDITION_OPERATORS.REGEX, 'FOO', '[a-z]+', false],
+    [CONDITION_OPERATORS.REGEX, null, '[a-z]+', false],
     [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.0:semver", true],
     [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.0:semver", true],
     [CONDITION_OPERATORS.EQUAL, "1.0.0", "1.0.1:semver", false],
@@ -133,4 +136,4 @@ test('test_segment_rule_matching_function', () => {
     for (const testCase of testCases) {
         expect(new SegmentRuleModel(testCase[0]).matchingFunction()).toBe(testCase[1]);
     }
-});
+});

package/tests/sdk/analytics.test.ts

@@ -72,3 +72,21 @@ test('errors in fetch sending analytics data are swallowed', async () => {
     // we expect that fetch was called but the exception was handled
     expect(fetch).toHaveBeenCalled();
 })
+
+test('analytics is only flushed once even if requested concurrently', async () => {
+    const processor = analyticsProcessor();
+    processor.trackFeature('myFeature');
+    // @ts-ignore
+    fetch.mockImplementation(() => {
+        return new Promise((resolve, _) => {
+            setTimeout(resolve, 1000)
+        })
+    });
+    const flushes = Promise.all([
+        processor.flush(),
+        processor.flush(),
+    ])
+    jest.runOnlyPendingTimers();
+    await flushes;
+    expect(fetch).toHaveBeenCalledTimes(1)
+})