flipflag-sdk 1.1.21 → 1.1.23

package/dist/next.js

@@ -8,6 +8,9 @@ class FlipFlagSDK {
         this.cache = new Map();
         this.defaultBaseUrl = "https://app.flipflag.ru";
         this.stateListeners = new Set();
+        this.maxListeners = 100; // Maximum number of listeners to prevent memory leaks
+        // Validate required configuration
+        this.validateConfig(config);
         this.config = {
             baseUrl: this.defaultBaseUrl,
             cacheTimeout: 30000, // 30 seconds
@@ -32,9 +35,18 @@ class FlipFlagSDK {
      * Identify user for A/B testing and user-specific flags
      */
     identifyUser(options) {
+        if (!options || typeof options !== "object") {
+            throw new Error("options must be an object");
+        }
+        if (!options.userId || typeof options.userId !== "string") {
+            throw new Error("userId is required and must be a string");
+        }
+        if (options.userProperties && typeof options.userProperties !== "object") {
+            throw new Error("userProperties must be an object");
+        }
         this.config.userId = options.userId;
         // Clear A/B test cache since user changed
-        this.clearABTestCache();
+        this.clearAllABTestCache();
         // If we have a user, we might want to refresh immediately
         if (this.config.pullInterval && this.config.pullInterval > 0) {
             this.pullData();
@@ -50,6 +62,9 @@ class FlipFlagSDK {
      * Subscribe to state changes
      */
     subscribe(callback) {
+        if (this.stateListeners.size >= this.maxListeners) {
+            console.warn(`Maximum number of listeners (${this.maxListeners}) reached. This may cause memory leaks.`);
+        }
         this.stateListeners.add(callback);
         // Return unsubscribe function
         return () => {
@@ -160,6 +175,8 @@ class FlipFlagSDK {
             }
             catch (error) {
                 console.error("State listener error:", error);
+                // Remove faulty listener to prevent repeated errors
+                this.stateListeners.delete(callback);
             }
         });
     }
@@ -196,9 +213,9 @@ class FlipFlagSDK {
         }
     }
     /**
-     * Clear A/B test cache
+     * Clear all A/B test cache (private method)
      */
-    clearABTestCache() {
+    clearAllABTestCache() {
         const abTestKeys = Array.from(this.cache.keys()).filter((key) => key.startsWith("abtest:"));
         abTestKeys.forEach((key) => this.cache.delete(key));
     }
@@ -224,6 +241,15 @@ class FlipFlagSDK {
      */
     async getFlag(flagName, projectId = this.config.projectId, environment) {
         var _a, _b;
+        if (!flagName || typeof flagName !== "string") {
+            throw new Error("flagName is required and must be a string");
+        }
+        if (!projectId || typeof projectId !== "string") {
+            throw new Error("projectId must be a string");
+        }
+        if (environment && typeof environment !== "string") {
+            throw new Error("environment must be a string");
+        }
         // If we have the flag in state, return it immediately
         if (this.state.flags[flagName] !== undefined) {
             return {
@@ -235,20 +261,18 @@ class FlipFlagSDK {
             };
         }
         // Check if we're currently loading data (pullData in progress)
-        // In this case, wait a bit and check state again
+        // In this case, wait for loading to complete using Promise
         if (this.state.isLoading) {
-            // Wait up to 5 seconds for loading to complete
-            for (let i = 0; i < 50; i++) {
-                await new Promise((resolve) => setTimeout(resolve, 100));
-                if (!this.state.isLoading && this.state.flags[flagName] !== undefined) {
-                    return {
-                        projectId: this.config.projectId,
-                        flagName,
-                        environment: this.config.environment || "all",
-                        value: this.state.flags[flagName],
-                        timestamp: ((_b = this.state.lastFetch) === null || _b === void 0 ? void 0 : _b.toISOString()) || new Date().toISOString(),
-                    };
-                }
+            await this.waitForLoadingComplete();
+            // After waiting, check state again
+            if (this.state.flags[flagName] !== undefined) {
+                return {
+                    projectId: this.config.projectId,
+                    flagName,
+                    environment: this.config.environment || "all",
+                    value: this.state.flags[flagName],
+                    timestamp: ((_b = this.state.lastFetch) === null || _b === void 0 ? void 0 : _b.toISOString()) || new Date().toISOString(),
+                };
             }
         }
         const cacheKey = `flag:${projectId}:${flagName}:${environment || "all"}`;
@@ -264,10 +288,76 @@ class FlipFlagSDK {
         this.setCache(cacheKey, response, this.config.cacheTimeout);
         return response;
     }
+    /**
+     * Validate configuration
+     */
+    validateConfig(config) {
+        if (!config.apiKey || typeof config.apiKey !== "string") {
+            throw new Error("apiKey is required and must be a string");
+        }
+        if (!config.projectId || typeof config.projectId !== "string") {
+            throw new Error("projectId is required and must be a string");
+        }
+        if (config.baseUrl && typeof config.baseUrl !== "string") {
+            throw new Error("baseUrl must be a string");
+        }
+        if (config.environment && typeof config.environment !== "string") {
+            throw new Error("environment must be a string");
+        }
+        if (config.userId && typeof config.userId !== "string") {
+            throw new Error("userId must be a string");
+        }
+        if (config.cacheTimeout &&
+            (typeof config.cacheTimeout !== "number" || config.cacheTimeout < 0)) {
+            throw new Error("cacheTimeout must be a non-negative number");
+        }
+        if (config.retryAttempts &&
+            (typeof config.retryAttempts !== "number" || config.retryAttempts < 0)) {
+            throw new Error("retryAttempts must be a non-negative number");
+        }
+        if (config.retryDelay &&
+            (typeof config.retryDelay !== "number" || config.retryDelay < 0)) {
+            throw new Error("retryDelay must be a non-negative number");
+        }
+        if (config.pullInterval &&
+            (typeof config.pullInterval !== "number" || config.pullInterval < 0)) {
+            throw new Error("pullInterval must be a non-negative number");
+        }
+    }
+    /**
+     * Wait for loading to complete with timeout
+     */
+    async waitForLoadingComplete(timeout = 5000) {
+        const startTime = Date.now();
+        return new Promise((resolve, reject) => {
+            const checkLoading = () => {
+                if (!this.state.isLoading) {
+                    resolve();
+                    return;
+                }
+                if (Date.now() - startTime > timeout) {
+                    reject(new Error("Timeout waiting for SDK loading to complete"));
+                    return;
+                }
+                // Check again after a short delay
+                setTimeout(checkLoading, 50);
+            };
+            checkLoading();
+        });
+    }
     /**
      * Get A/B test variant for a user
      */
     async getAbTestVariant(testName, userId, projectId = this.config.projectId) {
+        if (!testName || typeof testName !== "string") {
+            throw new Error("testName is required and must be a string");
+        }
+        if (!userId || typeof userId !== "string") {
+            throw new Error("userId is required and must be a string");
+        }
+        if (!projectId || typeof projectId !== "string") {
+            throw new Error("projectId must be a string");
+        }
         // If we have the A/B test in state, return it immediately
         const stateVariant = this.state.abTests[testName];
         if (stateVariant && stateVariant.testName === testName) {
@@ -331,6 +421,34 @@ class FlipFlagSDK {
             this.cache.clear();
         }
     }
+    /**
+     * Clear cache for specific flag
+     */
+    clearFlagCache(flagName, environment) {
+        const cacheKey = `flag:${this.config.projectId}:${flagName}:${environment || "all"}`;
+        this.cache.delete(cacheKey);
+    }
+    /**
+     * Clear cache for all flags
+     */
+    clearFlagsCache(environment) {
+        const cacheKey = `flags:${this.config.projectId}:${environment || "all"}`;
+        this.cache.delete(cacheKey);
+    }
+    /**
+     * Clear cache for A/B test variant
+     */
+    clearABTestCache(testName, userId) {
+        if (testName && userId) {
+            const cacheKey = `abtest:${this.config.projectId}:${testName}:${userId}`;
+            this.cache.delete(cacheKey);
+        }
+        else {
+            // Clear all A/B test cache
+            const abTestKeys = Array.from(this.cache.keys()).filter((key) => key.startsWith("abtest:"));
+            abTestKeys.forEach((key) => this.cache.delete(key));
+        }
+    }
     /**
      * Update configuration
      */
@@ -483,32 +601,38 @@ function useFeatureFlag(flagName, options = {}) {
         finally {
             setLoading(false);
         }
-    }, [
-        sdk,
-        flagName,
-        options.fallbackValue,
-        options.enabled,
-        shouldSkipInitialFetch,
-    ]);
+    }, [sdk, flagName, options.fallbackValue, options.enabled]);
     const refetch = react.useCallback(async () => {
         sdk.clearCache(`flag:${sdk["config"].projectId}:${flagName}:${sdk["config"].environment || "all"}`);
         await fetchFlag();
     }, [sdk, flagName, fetchFlag]);
     // Subscribe to SDK state changes for automatic updates via pullInterval
     react.useEffect(() => {
+        let lastFetchTime = null;
         const unsubscribe = sdk.subscribe((state) => {
-            // Only update if this is from pullInterval and has flag data
-            if (state.lastFetch && state.flags[flagName] !== undefined) {
+            // Only update if this is a new fetch and has flag data for this specific flag
+            if (state.lastFetch &&
+                state.lastFetch !== lastFetchTime &&
+                state.flags[flagName] !== undefined) {
+                lastFetchTime = state.lastFetch;
                 setValue(state.flags[flagName]);
                 setLoading(false);
-                setError(null);
+                setError(state.error);
             }
         });
         return unsubscribe;
     }, [sdk, flagName]);
+    // Effect to handle initial fetch and server-side state changes
     react.useEffect(() => {
-        fetchFlag();
-    }, [fetchFlag]);
+        // Only fetch if we don't have server-side data or if server-side data becomes invalid
+        if (!shouldSkipInitialFetch) {
+            fetchFlag();
+        }
+        else {
+            // If we have server-side data, just set loading to false
+            setLoading(false);
+        }
+    }, [shouldSkipInitialFetch, fetchFlag]);
     return {
         value,
         loading,
@@ -577,18 +701,16 @@ function useFeatureFlags(flagNames, options = {}) {
         finally {
             setLoading(false);
         }
-    }, [
-        sdk,
-        memoizedFlagNames,
-        memoizedFallbackValues,
-        options.enabled,
-        shouldSkipInitialFetch,
-    ]);
+    }, [sdk, memoizedFlagNames, memoizedFallbackValues, options.enabled]);
     // Subscribe to SDK state changes for automatic updates via pullInterval
     react.useEffect(() => {
+        let lastFetchTime = null;
         const unsubscribe = sdk.subscribe((state) => {
-            // Only update if this is from pullInterval (has lastFetch) and has flag data
-            if (state.lastFetch && Object.keys(state.flags).length > 0) {
+            // Only update if this is a new fetch (different from last one) and has flag data
+            if (state.lastFetch &&
+                state.lastFetch !== lastFetchTime &&
+                Object.keys(state.flags).length > 0) {
+                lastFetchTime = state.lastFetch;
                 const newFlags = {};
                 memoizedFlagNames.forEach((flagName) => {
                     var _a;
@@ -602,18 +724,32 @@ function useFeatureFlags(flagNames, options = {}) {
                 });
                 setFlags(newFlags);
                 setLoading(false);
-                setError(null);
+                setError(state.error);
             }
         });
         return unsubscribe;
     }, [sdk, memoizedFlagNames, memoizedFallbackValues]);
+    // Effect to handle initial fetch and server-side state changes
     react.useEffect(() => {
-        fetchFlags();
-    }, [fetchFlags]);
+        // Only fetch if we don't have server-side data or if server-side data becomes invalid
+        if (!shouldSkipInitialFetch) {
+            fetchFlags();
+        }
+        else {
+            // If we have server-side data, just set loading to false
+            setLoading(false);
+        }
+    }, [shouldSkipInitialFetch, fetchFlags]);
+    const refetch = react.useCallback(async () => {
+        // Clear cache for flags
+        sdk.clearCache(`flags:${sdk["config"].projectId}:${sdk["config"].environment || "all"}`);
+        await fetchFlags();
+    }, [sdk, fetchFlags]);
     return {
         flags,
         loading,
         error,
+        refetch,
     };
 }
 
@@ -644,7 +780,7 @@ function useABTest(testName, options) {
         finally {
             setLoading(false);
         }
-    }, [sdk, testName, options.userId, options.enabled]);
+    }, [sdk, testName, options.userId]);
     const recordEvent = react.useCallback(async (event, eventData) => {
         if (!variantId) {
             console.warn("Cannot record event: no variant assigned yet");
@@ -659,21 +795,33 @@ function useABTest(testName, options) {
     }, [sdk, testName, options.userId, variantId]);
     // Subscribe to SDK state changes for automatic updates via pullInterval
     react.useEffect(() => {
+        let lastFetchTime = null;
         const unsubscribe = sdk.subscribe((state) => {
-            // Only update if this is from pullInterval and has A/B test data
-            if (state.lastFetch && state.abTests[testName]) {
+            if (!options.enabled && options.enabled !== undefined) {
+                return;
+            }
+            // Only update if this is a new fetch and has A/B test data
+            if (state.lastFetch &&
+                state.lastFetch !== lastFetchTime &&
+                state.abTests[testName]) {
+                lastFetchTime = state.lastFetch;
                 const newABTest = state.abTests[testName];
-                setVariant(newABTest.variant.value);
-                setVariantId(newABTest.variantId);
-                setLoading(false);
-                setError(null);
+                if (newABTest.variantId !== variantId) {
+                    setVariant(newABTest.variant.value);
+                    setVariantId(newABTest.variantId);
+                    setLoading(false);
+                    setError(state.error);
+                }
             }
         });
         return unsubscribe;
-    }, [sdk, testName]);
+    }, [sdk, testName, options.enabled, variantId]);
+    // Initial fetch effect
     react.useEffect(() => {
-        fetchVariant();
-    }, [fetchVariant]);
+        if (options.enabled !== false) {
+            fetchVariant();
+        }
+    }, [options.enabled, fetchVariant]);
     return {
         variant,
         variantId,
@@ -686,20 +834,8 @@ function useABTest(testName, options) {
 /**
  * Fetch feature flags on the server side for SSR
  */
-async function getServerSideFlags(configOrFlagNames, flagNames) {
-    let config;
-    let flagList;
-    // Handle different calling patterns
-    if (Array.isArray(configOrFlagNames)) {
-        // Called with flagNames only - this should not happen in normal usage
-        // We'll need to get config from somewhere else, but for now throw error
-        throw new Error("getServerSideFlags must be called with config when used outside of FlipflagProvider context");
-    }
-    else if (configOrFlagNames) {
-        config = configOrFlagNames;
-        flagList = flagNames;
-    }
-    else {
+async function getServerSideFlags(config, flagNames) {
+    if (!config) {
         throw new Error("getServerSideFlags requires config parameter");
     }
     const sdk = new FlipFlagSDK({
@@ -711,31 +847,16 @@ async function getServerSideFlags(configOrFlagNames, flagNames) {
     });
     try {
         const response = await sdk.getFlags();
-        let flags = response.flags;
-        // If specific flag names are requested, filter the response
-        if (flagList && flagList.length > 0) {
-            flags = {};
-            flagList.forEach((flagName) => {
-                var _a;
-                flags[flagName] = (_a = response.flags[flagName]) !== null && _a !== void 0 ? _a : false;
-            });
-        }
         return {
-            flags,
+            flags: response.flags,
             timestamp: Date.now(),
         };
     }
     catch (error) {
         console.error("Failed to fetch server-side flags:", error);
-        // Return fallback values
-        const fallbackFlags = {};
-        if (flagList) {
-            flagList.forEach((flagName) => {
-                fallbackFlags[flagName] = false;
-            });
-        }
+        // Return empty flags object on error
         return {
-            flags: fallbackFlags,
+            flags: {},
             timestamp: Date.now(),
         };
     }