@flipfeatureflag/core 0.1.5 → 0.1.7

package/dist/index.d.mts

@@ -102,6 +102,10 @@ declare class FlipFlagClient {
     private metricsTimer?;
     private metricsBuffer;
     private context;
+    private started;
+    private refreshInFlight?;
+    private pendingFlagKeys;
+    private pendingFullRefresh;
     constructor(options: FlipFlagClientOptions);
     start(): Promise<void>;
     stop(): void;

package/dist/index.d.ts

@@ -102,6 +102,10 @@ declare class FlipFlagClient {
     private metricsTimer?;
     private metricsBuffer;
     private context;
+    private started;
+    private refreshInFlight?;
+    private pendingFlagKeys;
+    private pendingFullRefresh;
     constructor(options: FlipFlagClientOptions);
     start(): Promise<void>;
     stop(): void;

package/dist/index.js

@@ -139,6 +139,9 @@ var FlipFlagClient = class {
     this.status = { ready: false };
     this.evaluations = /* @__PURE__ */ new Map();
     this.metricsBuffer = new MetricsBuffer();
+    this.started = false;
+    this.pendingFlagKeys = /* @__PURE__ */ new Set();
+    this.pendingFullRefresh = false;
     if (!options.url) {
       throw new Error("flipFeatureFlag SDK requires url");
     }
@@ -159,6 +162,10 @@ var FlipFlagClient = class {
     });
   }
   async start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
     await this.refresh();
     if (!this.options.disableRefresh) {
       this.refreshTimer = setInterval(() => {
@@ -180,6 +187,7 @@ var FlipFlagClient = class {
       clearInterval(this.metricsTimer);
       this.metricsTimer = void 0;
     }
+    this.started = false;
   }
   on(event, listener) {
     this.emitter.on(event, listener);
@@ -223,7 +231,9 @@ var FlipFlagClient = class {
     if (cached) {
       return this.recordEvaluation(flagKey, cached);
     }
-    void this.refresh([flagKey]);
+    if (!this.options.disableRefresh) {
+      void this.refresh([flagKey]);
+    }
     return this.recordEvaluation(flagKey, {
       value: defaultValue,
       variationKey: "default",
@@ -238,25 +248,46 @@ var FlipFlagClient = class {
     return evaluation;
   }
   async refresh(flagKeys) {
-    try {
-      const response = await this.http.evaluate({
-        env: this.options.env,
-        context: this.context,
-        flagKeys
-      });
-      this.applyEvaluate(response);
-      if (!this.status.ready) {
-        this.status.ready = true;
-        this.emitter.emit("ready");
+    if (flagKeys && flagKeys.length > 0) {
+      for (const key of flagKeys) {
+        this.pendingFlagKeys.add(key);
       }
-      this.emitter.emit("update");
-    } catch (error) {
-      this.status.error = error;
-      this.emitter.emit("error", error);
+    } else {
+      this.pendingFullRefresh = true;
+    }
+    if (this.refreshInFlight) {
+      return this.refreshInFlight;
     }
+    this.refreshInFlight = (async () => {
+      const shouldFull = this.pendingFullRefresh;
+      const keys = shouldFull ? void 0 : Array.from(this.pendingFlagKeys);
+      this.pendingFlagKeys.clear();
+      this.pendingFullRefresh = false;
+      try {
+        const response = await this.http.evaluate({
+          env: this.options.env,
+          context: this.context,
+          flagKeys: keys
+        });
+        this.applyEvaluate(response);
+        if (!this.status.ready) {
+          this.status.ready = true;
+          this.emitter.emit("ready");
+        }
+        this.emitter.emit("update");
+      } catch (error) {
+        this.status.error = error;
+        this.emitter.emit("error", error);
+      } finally {
+        this.refreshInFlight = void 0;
+      }
+      if (this.pendingFullRefresh || this.pendingFlagKeys.size > 0) {
+        return this.refresh();
+      }
+    })();
+    return this.refreshInFlight;
   }
   applyEvaluate(response) {
-    this.evaluations.clear();
     for (const [key, evaluation] of Object.entries(response.flags)) {
       this.evaluations.set(key, evaluation);
     }

package/dist/index.mjs

@@ -113,6 +113,9 @@ var FlipFlagClient = class {
     this.status = { ready: false };
     this.evaluations = /* @__PURE__ */ new Map();
     this.metricsBuffer = new MetricsBuffer();
+    this.started = false;
+    this.pendingFlagKeys = /* @__PURE__ */ new Set();
+    this.pendingFullRefresh = false;
     if (!options.url) {
       throw new Error("flipFeatureFlag SDK requires url");
     }
@@ -133,6 +136,10 @@ var FlipFlagClient = class {
     });
   }
   async start() {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
     await this.refresh();
     if (!this.options.disableRefresh) {
       this.refreshTimer = setInterval(() => {
@@ -154,6 +161,7 @@ var FlipFlagClient = class {
       clearInterval(this.metricsTimer);
       this.metricsTimer = void 0;
     }
+    this.started = false;
   }
   on(event, listener) {
     this.emitter.on(event, listener);
@@ -197,7 +205,9 @@ var FlipFlagClient = class {
     if (cached) {
       return this.recordEvaluation(flagKey, cached);
     }
-    void this.refresh([flagKey]);
+    if (!this.options.disableRefresh) {
+      void this.refresh([flagKey]);
+    }
     return this.recordEvaluation(flagKey, {
       value: defaultValue,
       variationKey: "default",
@@ -212,25 +222,46 @@ var FlipFlagClient = class {
     return evaluation;
   }
   async refresh(flagKeys) {
-    try {
-      const response = await this.http.evaluate({
-        env: this.options.env,
-        context: this.context,
-        flagKeys
-      });
-      this.applyEvaluate(response);
-      if (!this.status.ready) {
-        this.status.ready = true;
-        this.emitter.emit("ready");
+    if (flagKeys && flagKeys.length > 0) {
+      for (const key of flagKeys) {
+        this.pendingFlagKeys.add(key);
       }
-      this.emitter.emit("update");
-    } catch (error) {
-      this.status.error = error;
-      this.emitter.emit("error", error);
+    } else {
+      this.pendingFullRefresh = true;
+    }
+    if (this.refreshInFlight) {
+      return this.refreshInFlight;
     }
+    this.refreshInFlight = (async () => {
+      const shouldFull = this.pendingFullRefresh;
+      const keys = shouldFull ? void 0 : Array.from(this.pendingFlagKeys);
+      this.pendingFlagKeys.clear();
+      this.pendingFullRefresh = false;
+      try {
+        const response = await this.http.evaluate({
+          env: this.options.env,
+          context: this.context,
+          flagKeys: keys
+        });
+        this.applyEvaluate(response);
+        if (!this.status.ready) {
+          this.status.ready = true;
+          this.emitter.emit("ready");
+        }
+        this.emitter.emit("update");
+      } catch (error) {
+        this.status.error = error;
+        this.emitter.emit("error", error);
+      } finally {
+        this.refreshInFlight = void 0;
+      }
+      if (this.pendingFullRefresh || this.pendingFlagKeys.size > 0) {
+        return this.refresh();
+      }
+    })();
+    return this.refreshInFlight;
   }
   applyEvaluate(response) {
-    this.evaluations.clear();
     for (const [key, evaluation] of Object.entries(response.flags)) {
       this.evaluations.set(key, evaluation);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flipfeatureflag/core",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "flipFeatureFlag core SDK",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",

package/src/client.ts

@@ -26,6 +26,10 @@ export class FlipFlagClient {
   private metricsTimer?: ReturnType<typeof setInterval>;
   private metricsBuffer = new MetricsBuffer();
   private context: SdkContext;
+  private started = false;
+  private refreshInFlight?: Promise<void>;
+  private pendingFlagKeys = new Set<string>();
+  private pendingFullRefresh = false;
 
   constructor(options: FlipFlagClientOptions) {
     if (!options.url) {
@@ -52,6 +56,10 @@ export class FlipFlagClient {
   }
 
   async start(): Promise<void> {
+    if (this.started) {
+      return;
+    }
+    this.started = true;
     await this.refresh();
 
     if (!this.options.disableRefresh) {
@@ -76,6 +84,7 @@ export class FlipFlagClient {
       clearInterval(this.metricsTimer);
       this.metricsTimer = undefined;
     }
+    this.started = false;
   }
 
   on(event: FlipFlagEvent, listener: FlipFlagListener) {
@@ -129,7 +138,9 @@ export class FlipFlagClient {
       return this.recordEvaluation(flagKey, cached);
     }
 
-    void this.refresh([flagKey]);
+    if (!this.options.disableRefresh) {
+      void this.refresh([flagKey]);
+    }
     return this.recordEvaluation(flagKey, {
       value: defaultValue,
       variationKey: "default",
@@ -145,29 +156,55 @@ export class FlipFlagClient {
     return evaluation;
   }
 
-  private async refresh(flagKeys?: string[]) {
-    try {
-      const response = await this.http.evaluate({
-        env: this.options.env,
-        context: this.context,
-        flagKeys,
-      });
-      this.applyEvaluate(response);
-
-      if (!this.status.ready) {
-        this.status.ready = true;
-        this.emitter.emit("ready");
+  private async refresh(flagKeys?: string[]): Promise<void> {
+    if (flagKeys && flagKeys.length > 0) {
+      for (const key of flagKeys) {
+        this.pendingFlagKeys.add(key);
       }
+    } else {
+      this.pendingFullRefresh = true;
+    }
 
-      this.emitter.emit("update");
-    } catch (error) {
-      this.status.error = error as Error;
-      this.emitter.emit("error", error);
+    if (this.refreshInFlight) {
+      return this.refreshInFlight;
     }
+
+    this.refreshInFlight = (async () => {
+      const shouldFull = this.pendingFullRefresh;
+      const keys = shouldFull ? undefined : Array.from(this.pendingFlagKeys);
+      this.pendingFlagKeys.clear();
+      this.pendingFullRefresh = false;
+
+      try {
+        const response = await this.http.evaluate({
+          env: this.options.env,
+          context: this.context,
+          flagKeys: keys,
+        });
+        this.applyEvaluate(response);
+
+        if (!this.status.ready) {
+          this.status.ready = true;
+          this.emitter.emit("ready");
+        }
+
+        this.emitter.emit("update");
+      } catch (error) {
+        this.status.error = error as Error;
+        this.emitter.emit("error", error);
+      } finally {
+        this.refreshInFlight = undefined;
+      }
+
+      if (this.pendingFullRefresh || this.pendingFlagKeys.size > 0) {
+        return this.refresh();
+      }
+    })();
+
+    return this.refreshInFlight;
   }
 
   private applyEvaluate(response: SdkEvaluateResponse) {
-    this.evaluations.clear();
     for (const [key, evaluation] of Object.entries(response.flags)) {
       this.evaluations.set(key, evaluation);
     }