@statsig/js-user-persisted-storage 0.0.1-beta.13

package/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@statsig/js-user-persisted-storage",
+  "version": "0.0.1-beta.13",
+  "dependencies": {
+    "@statsig/client-core": "0.0.1-beta.13"
+  },
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts"
+}

package/src/UserPersistedStorage.d.ts

@@ -0,0 +1,16 @@
+import { SecondaryExposure } from '@statsig/client-core';
+export type StickyValues = {
+    value: boolean;
+    rule_id: string;
+    json_value: Record<string, unknown>;
+    secondary_exposures: SecondaryExposure[];
+    group_name: string | null;
+    time: number;
+};
+export type UserPersistedValues = Record<string, StickyValues>;
+export type UserPersistentStorage = {
+    delete(key: string, experiment: string): void;
+    load(key: string): UserPersistedValues;
+    save(key: string, experiment: string, data: string): void;
+    loadAsync(key: string): Promise<UserPersistedValues>;
+};

package/src/UserPersistedStorage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/UserPersistentOverrideAdapter.d.ts

@@ -0,0 +1,13 @@
+import { Experiment, ExperimentEvaluationOptions, OverrideAdapter, StatsigUser } from '@statsig/client-core';
+import { UserPersistedValues, UserPersistentStorage } from './UserPersistedStorage';
+export declare class UserPersistentOverrideAdapter implements OverrideAdapter {
+    readonly storage: UserPersistentStorage;
+    constructor(storage: UserPersistentStorage);
+    loadUserPersistedValues(user: StatsigUser, idType: string): UserPersistedValues;
+    loadUserPersistedValuesAsync(user: StatsigUser, idType: string): Promise<UserPersistedValues>;
+    getExperimentOverride(current: Experiment, user: StatsigUser, options?: ExperimentEvaluationOptions): Experiment | null;
+    private _makeStickyExperiment;
+    private _handleDelete;
+    private _handleSave;
+    private _getStorageKey;
+}

package/src/UserPersistentOverrideAdapter.js

@@ -0,0 +1,97 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserPersistentOverrideAdapter = void 0;
+const client_core_1 = require("@statsig/client-core");
+class UserPersistentOverrideAdapter {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    loadUserPersistedValues(user, idType) {
+        var _a;
+        const key = this._getStorageKey(user, idType);
+        return (_a = this.storage.load(key)) !== null && _a !== void 0 ? _a : {};
+    }
+    loadUserPersistedValuesAsync(user, idType) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const key = this._getStorageKey(user, idType);
+            return (_a = (yield this.storage.loadAsync(key))) !== null && _a !== void 0 ? _a : {};
+        });
+    }
+    getExperimentOverride(current, user, options) {
+        const evaluation = current.__evaluation;
+        if (evaluation == null) {
+            return null;
+        }
+        const values = options === null || options === void 0 ? void 0 : options.userPersistedValues;
+        if (evaluation.is_experiment_active !== true ||
+            values == null ||
+            typeof values !== 'object') {
+            this._handleDelete(user, current.name, evaluation.id_type);
+            return null;
+        }
+        const sticky = values[current.name];
+        if (sticky != null) {
+            return this._makeStickyExperiment(evaluation, sticky);
+        }
+        if (evaluation.is_user_in_experiment) {
+            this._handleSave(user, current, evaluation);
+        }
+        return null;
+    }
+    _makeStickyExperiment(evaluation, sticky) {
+        const { id_type, name } = evaluation;
+        const { json_value: value, secondary_exposures, group_name, rule_id, time, } = sticky;
+        const details = {
+            reason: 'Persisted',
+            lcut: time,
+        };
+        return (0, client_core_1.makeDynamicConfig)(name, details, {
+            // from sticky
+            value,
+            secondary_exposures,
+            group_name: group_name !== null && group_name !== void 0 ? group_name : undefined,
+            group: group_name !== null && group_name !== void 0 ? group_name : '',
+            rule_id,
+            // everything else
+            id_type,
+            name,
+            is_device_based: evaluation.is_device_based,
+        });
+    }
+    _handleDelete(user, name, idType) {
+        const key = this._getStorageKey(user, idType);
+        const current = this.storage.load(key);
+        if (current == null) {
+            return;
+        }
+        delete current[name];
+        this.storage.delete(key, name);
+    }
+    _handleSave(user, experiment, evaluation) {
+        var _a;
+        const key = this._getStorageKey(user, evaluation.id_type);
+        const values = {
+            value: true,
+            rule_id: evaluation.rule_id,
+            json_value: evaluation.value,
+            secondary_exposures: evaluation.secondary_exposures,
+            group_name: evaluation.group,
+            time: (_a = experiment.details.lcut) !== null && _a !== void 0 ? _a : 0,
+        };
+        this.storage.save(key, experiment.name, JSON.stringify(values));
+    }
+    _getStorageKey(user, idType) {
+        return `${String((0, client_core_1.getUnitIDFromUser)(user, idType))}:${idType}`;
+    }
+}
+exports.UserPersistentOverrideAdapter = UserPersistentOverrideAdapter;

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from './UserPersistentOverrideAdapter';
+export * from './UserPersistedStorage';

package/src/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./UserPersistentOverrideAdapter"), exports);
+__exportStar(require("./UserPersistedStorage"), exports);