superposition-provider 0.103.0 → 0.105.0

package/dist/configuration-client.d.ts

@@ -8,10 +8,13 @@ export declare class ConfigurationClient {
     private currentConfigData;
     private experimentationClient?;
     private experimentationOptions?;
+    private providerCache;
+    private refreshInterval;
     private defaults;
     private smithyClient;
     constructor(config: SuperpositionOptions, resolver: NativeResolver, options?: ConfigOptions, experimentationOptions?: ExperimentationOptions);
     initialize(): Promise<void>;
+    private reinitExperimentsCache;
     eval(queryData: Record<string, any>, filterPrefixes?: string[], targetingKey?: string): Promise<any>;
     eval<T>(queryData: Record<string, any>, filterPrefixes?: string[], targetingKey?: string): Promise<T>;
     setDefault(defaults: ConfigData): void;

package/dist/experimentation-client.d.ts

@@ -35,7 +35,8 @@ export declare class ExperimentationClient {
     private lastUpdated;
     private evaluationCache;
     private pollingInterval?;
-    constructor(superpositionOptions: SuperpositionOptions, experimentOptions: ExperimentationOptions);
+    private onExperimentsChange;
+    constructor(superpositionOptions: SuperpositionOptions, experimentOptions: ExperimentationOptions, onExperimentsChange: (experiments: Experiment[], experimentGroups: ExperimentGroup[]) => void);
     initialize(): Promise<void>;
     private startPolling;
     private fetchExperiments;
@@ -47,6 +48,8 @@ export declare class ExperimentationClient {
     private normalizeToStringRecord;
     getExperiments(): Promise<Experiment[]>;
     getExperimentGroups(): Promise<ExperimentGroup[]>;
+    getCachedExperiments(): Experiment[] | null;
+    getCachedExperimentGroups(): ExperimentGroup[] | null;
     generateCacheKey(queryData: Record<string, any>): string;
     getFromEvalCache(key: string): any | undefined;
     setEvalCache(key: string, value: any): void;

package/dist/index.esm.js

@@ -3180,7 +3180,7 @@ var runtimeConfig = {};
 
 var name = "superposition-sdk";
 var description = "superposition-sdk client";
-var version = "0.103.0";
+var version = "0.105.0";
 var repository = {
 	type: "git",
 	url: "git+https://github.com/juspay/superposition.git"
@@ -16389,13 +16389,14 @@ function requireModels () {
 } (superpositionSdk));
 
 class ExperimentationClient {
-    constructor(superpositionOptions, experimentOptions) {
+    constructor(superpositionOptions, experimentOptions, onExperimentsChange) {
         this.superpositionOptions = superpositionOptions;
         this.cachedExperiments = null;
         this.cachedExperimentGroups = null;
         this.lastUpdated = null;
         this.evaluationCache = new Map();
         this.options = experimentOptions;
+        this.onExperimentsChange = onExperimentsChange;
         this.smithyClient = new superpositionSdk.SuperpositionClient({
             endpoint: superpositionOptions.endpoint,
             token: { token: superpositionOptions.token },
@@ -16409,6 +16410,7 @@ class ExperimentationClient {
         if (experiments && experimentgroups) {
             this.cachedExperiments = experiments;
             this.cachedExperimentGroups = experimentgroups;
+            this.onExperimentsChange(experiments, experimentgroups);
             this.lastUpdated = new Date();
             console.log("Experiments and Experiment Groups fetched successfully.");
         }
@@ -16420,21 +16422,31 @@ class ExperimentationClient {
         }
     }
     startPolling(interval) {
-        this.pollingInterval = setInterval(async () => {
+        const weakSelf = new WeakRef(this);
+        const poll = async () => {
+            let self = weakSelf.deref();
+            if (!self)
+                return;
             try {
-                const experiments = await this.fetchExperiments();
-                const experimentGroups = await this.fetchExperimentGroups();
+                const experiments = await self.fetchExperiments();
+                const experimentGroups = await self.fetchExperimentGroups();
                 if (experiments && experimentGroups) {
-                    this.cachedExperiments = experiments;
-                    this.cachedExperimentGroups = experimentGroups;
-                    this.lastUpdated = new Date();
+                    self.cachedExperiments = experiments;
+                    self.cachedExperimentGroups = experimentGroups;
+                    self.lastUpdated = new Date();
                     console.log("Experiments and Experiment Groups refreshed successfully.");
+                    self.onExperimentsChange(experiments, experimentGroups);
                 }
             }
             catch (error) {
                 console.error("Polling error:", error);
             }
-        }, interval);
+            if (self) {
+                self.pollingInterval = setTimeout(poll, interval);
+            }
+            self = undefined;
+        };
+        this.pollingInterval = setTimeout(poll, interval);
     }
     async fetchExperiments() {
         try {
@@ -16487,7 +16499,7 @@ class ExperimentationClient {
                     id: exp.id,
                     context: this.normalizeToStringRecord(exp.context),
                     variants: variants,
-                    traffic_percentage: exp.traffic_percentage || 100,
+                    traffic_percentage: exp.traffic_percentage ?? 100,
                     status: exp.status || superpositionSdk.ExperimentStatusType.DISCARDED,
                 });
             }
@@ -16521,7 +16533,7 @@ class ExperimentationClient {
                 experimentGroups.push({
                     id: exp_group.id,
                     context: this.normalizeToStringRecord(exp_group.context),
-                    traffic_percentage: exp_group.traffic_percentage || 100,
+                    traffic_percentage: exp_group.traffic_percentage ?? 100,
                     member_experiment_ids: exp_group.member_experiment_ids || [],
                     group_type: exp_group.group_type ||
                         superpositionSdk.GroupType.USER_CREATED,
@@ -16580,6 +16592,7 @@ class ExperimentationClient {
                     if (experiments) {
                         this.cachedExperiments = experiments;
                         this.lastUpdated = new Date();
+                        this.onExperimentsChange(experiments, this.cachedExperimentGroups || []);
                     }
                 }
                 catch (error) {
@@ -16597,6 +16610,7 @@ class ExperimentationClient {
             const experiments = await this.fetchExperiments();
             if (experiments) {
                 this.cachedExperiments = experiments;
+                this.onExperimentsChange(experiments, this.cachedExperimentGroups || []);
                 this.lastUpdated = new Date();
             }
         }
@@ -16617,6 +16631,7 @@ class ExperimentationClient {
                     if (experimentGroups) {
                         this.cachedExperimentGroups = experimentGroups;
                         this.lastUpdated = new Date();
+                        this.onExperimentsChange(this.cachedExperiments || [], experimentGroups);
                     }
                 }
                 catch (error) {
@@ -16634,11 +16649,18 @@ class ExperimentationClient {
             const experimentGroups = await this.fetchExperimentGroups();
             if (experimentGroups) {
                 this.cachedExperimentGroups = experimentGroups;
+                this.onExperimentsChange(this.cachedExperiments || [], experimentGroups);
                 this.lastUpdated = new Date();
             }
         }
         return this.cachedExperimentGroups || [];
     }
+    getCachedExperiments() {
+        return this.cachedExperiments;
+    }
+    getCachedExperimentGroups() {
+        return this.cachedExperimentGroups;
+    }
     generateCacheKey(queryData) {
         return JSON.stringify(queryData, Object.keys(queryData).sort());
     }
@@ -16654,7 +16676,7 @@ class ExperimentationClient {
     async close() {
         try {
             if (this.pollingInterval) {
-                clearInterval(this.pollingInterval);
+                clearTimeout(this.pollingInterval);
                 console.log("Polling stopped successfully");
             }
             this.clearEvalCache();
@@ -16669,30 +16691,50 @@ class ExperimentationClient {
     }
 }
 
+const _cacheRegistry = new FinalizationRegistry((freeFn) => {
+    setImmediate(freeFn);
+});
 class ConfigurationClient {
     constructor(config, resolver, options = {}, experimentationOptions) {
         this.currentConfigData = null;
+        this.providerCache = null;
+        this.refreshInterval = null;
         this.defaults = null;
         this.config = config;
         this.resolver = resolver;
         this.options = options;
+        this.providerCache = resolver.createProviderCache();
+        const cache = this.providerCache;
+        _cacheRegistry.register(this, () => {
+            cache.free();
+        }, this);
         if (this.options.refreshStrategy &&
             "interval" in this.options.refreshStrategy) {
             const strategy = this.options.refreshStrategy;
-            setInterval(async () => {
+            const weakSelf = new WeakRef(this);
+            const poll = async () => {
+                let self = weakSelf.deref();
+                if (!self)
+                    return;
                 try {
-                    const refreshedConfig = await this.fetchConfigData();
-                    this.currentConfigData = refreshedConfig;
+                    const refreshedConfig = await self.fetchConfigData();
+                    self.currentConfigData = refreshedConfig;
+                    self.providerCache?.initConfig(refreshedConfig.default_configs, refreshedConfig.contexts, refreshedConfig.overrides, refreshedConfig.dimensions);
                     console.log("Configuration refreshed successfully.");
                 }
                 catch (error) {
                     console.error("Failed to refresh configuration. Will continue to use the last known good configuration.", error);
                 }
-            }, strategy.interval);
+                if (self) {
+                    self.refreshInterval = setTimeout(poll, strategy.interval);
+                }
+                self = undefined;
+            };
+            this.refreshInterval = setTimeout(poll, strategy.interval);
         }
         if (experimentationOptions) {
             this.experimentationOptions = experimentationOptions;
-            this.experimentationClient = new ExperimentationClient(config, experimentationOptions);
+            this.experimentationClient = new ExperimentationClient(config, experimentationOptions, this.reinitExperimentsCache.bind(this));
         }
         this.smithyClient = new superpositionSdk.SuperpositionClient({
             endpoint: this.config.endpoint,
@@ -16701,26 +16743,30 @@ class ConfigurationClient {
         });
     }
     async initialize() {
-        // Initialize experimentation client if present
+        const configData = await this.fetchConfigData();
+        this.providerCache.initConfig(configData.default_configs, configData.contexts, configData.overrides, configData.dimensions);
         if (this.experimentationClient) {
             await this.experimentationClient.initialize();
         }
     }
+    reinitExperimentsCache(experiments, experimentGroups) {
+        if (experiments && experimentGroups) {
+            this.providerCache.initExperiments(experiments, experimentGroups);
+        }
+    }
     async eval(queryData, filterPrefixes, targetingKey) {
         try {
-            const configData = this.currentConfigData || await this.fetchConfigData();
-            let experimentationArgs;
-            if (this.experimentationClient && targetingKey) {
-                const experiments = await this.experimentationClient.getExperiments();
-                const experiment_groups = await this.experimentationClient.getExperimentGroups();
-                experimentationArgs = {
-                    experiments,
-                    experiment_groups,
-                    targeting_key: targetingKey,
-                };
+            if (!this.currentConfigData) {
+                const configData = await this.fetchConfigData();
+                this.providerCache.initConfig(configData.default_configs, configData.contexts, configData.overrides, configData.dimensions);
             }
-            const result = this.resolver.resolveConfig(configData.default_configs || {}, configData.contexts || [], configData.overrides || {}, configData.dimensions || {}, queryData, "merge", filterPrefixes, experimentationArgs);
-            return result;
+            if (this.experimentationClient &&
+                targetingKey &&
+                !this.experimentationClient.getCachedExperiments()) {
+                await this.experimentationClient.getExperiments();
+                await this.experimentationClient.getExperimentGroups();
+            }
+            return this.providerCache.evalConfig(queryData, "merge", filterPrefixes, targetingKey);
         }
         catch (error) {
             if (this.defaults) {
@@ -16760,21 +16806,17 @@ class ConfigurationClient {
     // TODO: Remove this function all together and use eval for getAllConfigValue as well
     async getAllConfigValue(defaultValue, context, targetingKey) {
         try {
-            const configData = this.currentConfigData || await this.fetchConfigData();
-            // Prepare query data with experiment variants if applicable
-            let queryData = { ...context };
-            if (this.experimentationClient && targetingKey) {
-                const experiments = await this.experimentationClient.getExperiments();
-                const experiment_groups = await this.experimentationClient.getExperimentGroups();
-                const identifier = this.experimentationOptions?.defaultIdentifier ||
-                    (targetingKey ? targetingKey : "default");
-                const variantIds = await this.getApplicableVariants(experiments, experiment_groups, this.currentConfigData?.dimensions || {}, queryData, identifier);
-                if (variantIds.length > 0) {
-                    queryData.variantIds = variantIds;
-                }
+            if (!this.currentConfigData) {
+                const configData = await this.fetchConfigData();
+                this.providerCache.initConfig(configData.default_configs, configData.contexts, configData.overrides, configData.dimensions);
             }
-            const result = this.resolver.resolveConfig(configData.default_configs || {}, configData.contexts || [], configData.overrides || {}, configData.dimensions || {}, queryData, "merge");
-            return result;
+            if (this.experimentationClient &&
+                targetingKey &&
+                !this.experimentationClient.getCachedExperiments()) {
+                await this.experimentationClient.getExperiments();
+                await this.experimentationClient.getExperimentGroups();
+            }
+            return this.providerCache.evalConfig(context, "merge", undefined, targetingKey);
         }
         catch (error) {
             if (this.defaults) {
@@ -16790,9 +16832,18 @@ class ConfigurationClient {
     }
     // Add method to close and cleanup
     async close() {
+        _cacheRegistry.unregister(this);
+        if (this.refreshInterval) {
+            clearTimeout(this.refreshInterval);
+            this.refreshInterval = null;
+        }
         if (this.experimentationClient) {
             await this.experimentationClient.close();
         }
+        if (this.providerCache) {
+            this.providerCache.free();
+            this.providerCache = null;
+        }
     }
 }
 
@@ -16857,6 +16908,11 @@ class NativeResolver {
             this.lib.core_test_connection = this.lib.func("int core_test_connection()");
             this.lib.core_parse_toml_config = this.lib.func("char* core_parse_toml_config(const char*, char*)");
             this.lib.core_parse_json_config = this.lib.func("char* core_parse_json_config(const char*, char*)");
+            this.lib.core_provider_cache_new = this.lib.func("void* core_provider_cache_new()");
+            this.lib.core_provider_cache_free = this.lib.func("void core_provider_cache_free(void*)");
+            this.lib.core_provider_cache_init_config = this.lib.func("void core_provider_cache_init_config(void*, const char*, const char*, const char*, const char*, char*)");
+            this.lib.core_provider_cache_init_experiments = this.lib.func("void core_provider_cache_init_experiments(void*, const char*, const char*, char*)");
+            this.lib.core_provider_cache_eval_config = this.lib.func("char* core_provider_cache_eval_config(void*, const char*, const char*, const char*, const char*, char*)");
             this.isAvailable = true;
         }
         catch (error) {
@@ -17185,6 +17241,51 @@ class NativeResolver {
             return false;
         }
     }
+    createProviderCache() {
+        if (!this.isAvailable) {
+            throw new Error("Native resolver is not available.");
+        }
+        const handle = this.lib.core_provider_cache_new();
+        if (!handle) {
+            throw new Error("core_provider_cache_new returned null");
+        }
+        const lib = this.lib;
+        return {
+            initConfig(defaultConfigs, contexts, overrides, dimensions) {
+                const ebuf = Buffer$1.alloc(ERROR_BUFFER_SIZE);
+                lib.core_provider_cache_init_config(handle, JSON.stringify(defaultConfigs || {}), JSON.stringify(contexts || []), JSON.stringify(overrides || {}), JSON.stringify(dimensions || {}), ebuf);
+                const err = ebuf.toString('utf8').split('\0')[0];
+                if (err.length !== 0)
+                    throw new Error("ffi: " + err);
+            },
+            initExperiments(experiments, experimentGroups) {
+                const ebuf = Buffer$1.alloc(ERROR_BUFFER_SIZE);
+                lib.core_provider_cache_init_experiments(handle, JSON.stringify(experiments || []), JSON.stringify(experimentGroups || []), ebuf);
+                const err = ebuf.toString('utf8').split('\0')[0];
+                if (err.length !== 0)
+                    throw new Error("ffi: " + err);
+            },
+            evalConfig(queryData, mergeStrategy = "merge", filterPrefixes, targetingKey) {
+                const ebuf = Buffer$1.alloc(ERROR_BUFFER_SIZE);
+                const filterPrefixesJson = filterPrefixes && filterPrefixes.length > 0
+                    ? JSON.stringify(filterPrefixes)
+                    : null;
+                const result = lib.core_provider_cache_eval_config(handle, JSON.stringify(queryData || {}), mergeStrategy, filterPrefixesJson, targetingKey || null, ebuf);
+                const err = ebuf.toString('utf8').split('\0')[0];
+                if (err.length !== 0)
+                    throw new Error("ffi: " + err);
+                const configStr = typeof result === "string"
+                    ? result
+                    : lib.decode(result, "string");
+                if (typeof result !== "string")
+                    lib.core_free_string(result);
+                return JSON.parse(configStr);
+            },
+            free() {
+                lib.core_provider_cache_free(handle);
+            },
+        };
+    }
     throwFFIError(err) {
         throw new Error("ffi: " + err);
     }