@workos-inc/node 8.10.0 → 8.11.1

package/lib/{factory-DwdIHLNE.cjs → factory-BraleEZU.cjs}

@@ -1,3 +1,4 @@
+let eventemitter3 = require("eventemitter3");
 //#region src/common/crypto/crypto-provider.ts
 /**
 * Interface encapsulating the various crypto computations used by the library,
@@ -2794,7 +2795,7 @@ let _josePromise;
 * @returns Promise that resolves to the jose module
 */
 function getJose() {
-	return _josePromise ??= Promise.resolve().then(() => require("./webapi-Dk3R7830.cjs"));
+	return _josePromise ??= Promise.resolve().then(() => require("./webapi-N7c2LUJd.cjs"));
 }
 //#endregion
 //#region src/user-management/session.ts
@@ -3720,6 +3721,240 @@ var FGA = class {
 	}
 };
 //#endregion
+//#region src/feature-flags/in-memory-store.ts
+var InMemoryStore = class {
+	flags = {};
+	swap(newFlags) {
+		this.flags = { ...newFlags };
+	}
+	get(slug) {
+		return this.flags[slug];
+	}
+	getAll() {
+		return { ...this.flags };
+	}
+	get size() {
+		return Object.keys(this.flags).length;
+	}
+};
+//#endregion
+//#region src/feature-flags/evaluator.ts
+var Evaluator = class {
+	constructor(store) {
+		this.store = store;
+	}
+	isEnabled(flagKey, context = {}, defaultValue = false) {
+		const entry = this.store.get(flagKey);
+		if (!entry) return defaultValue;
+		if (!entry.enabled) return false;
+		if (context.userId) {
+			const userTarget = entry.targets.users.find((t) => t.id === context.userId);
+			if (userTarget) return userTarget.enabled;
+		}
+		if (context.organizationId) {
+			const orgTarget = entry.targets.organizations.find((t) => t.id === context.organizationId);
+			if (orgTarget) return orgTarget.enabled;
+		}
+		return entry.default_value;
+	}
+	getAllFlags(context = {}) {
+		const flags = this.store.getAll();
+		const result = {};
+		for (const slug of Object.keys(flags)) result[slug] = this.isEnabled(slug, context);
+		return result;
+	}
+};
+//#endregion
+//#region src/feature-flags/runtime-client.ts
+const DEFAULT_POLLING_INTERVAL_MS = 3e4;
+const MIN_POLLING_INTERVAL_MS = 5e3;
+const MIN_DELAY_MS = 1e3;
+const DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+const JITTER_FACTOR = .1;
+const INITIAL_RETRY_MS = 1e3;
+const MAX_RETRY_MS = 6e4;
+const BACKOFF_MULTIPLIER = 2;
+var FeatureFlagsRuntimeClient = class extends eventemitter3.EventEmitter {
+	store;
+	evaluator;
+	pollingIntervalMs;
+	requestTimeoutMs;
+	logger;
+	closed = false;
+	initialized = false;
+	consecutiveErrors = 0;
+	pollTimer = null;
+	pollAbortController = null;
+	readyResolve = null;
+	readyReject = null;
+	readyPromise;
+	stats = {
+		pollCount: 0,
+		pollErrorCount: 0,
+		lastPollAt: null,
+		lastSuccessfulPollAt: null,
+		cacheAge: null,
+		flagCount: 0
+	};
+	constructor(workos, options = {}) {
+		super();
+		this.workos = workos;
+		this.pollingIntervalMs = Math.max(MIN_POLLING_INTERVAL_MS, options.pollingIntervalMs ?? DEFAULT_POLLING_INTERVAL_MS);
+		this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+		this.logger = options.logger;
+		this.store = new InMemoryStore();
+		this.evaluator = new Evaluator(this.store);
+		this.readyPromise = new Promise((resolve, reject) => {
+			this.readyResolve = resolve;
+			this.readyReject = reject;
+		});
+		this.readyPromise.catch(() => {});
+		if (options.bootstrapFlags) {
+			this.store.swap(options.bootstrapFlags);
+			this.stats.flagCount = this.store.size;
+			this.resolveReady();
+		}
+		setTimeout(() => this.poll(), 0);
+	}
+	async waitUntilReady(options) {
+		if (!options?.timeoutMs) return this.readyPromise;
+		let timeoutId;
+		const timeoutPromise = new Promise((_, reject) => {
+			timeoutId = setTimeout(() => reject(/* @__PURE__ */ new Error("waitUntilReady timed out")), options.timeoutMs);
+		});
+		timeoutPromise.catch(() => {});
+		return Promise.race([this.readyPromise, timeoutPromise]).finally(() => {
+			clearTimeout(timeoutId);
+		});
+	}
+	emit(event, ...args) {
+		if (event === "error" && this.listenerCount(event) === 0) throw args[0] instanceof Error ? args[0] : new Error(String(args[0]));
+		return super.emit(event, ...args);
+	}
+	close() {
+		this.closed = true;
+		this.pollAbortController?.abort();
+		if (this.pollTimer) {
+			clearTimeout(this.pollTimer);
+			this.pollTimer = null;
+		}
+		this.removeAllListeners();
+	}
+	isEnabled(flagKey, context, defaultValue) {
+		return this.evaluator.isEnabled(flagKey, context, defaultValue);
+	}
+	getAllFlags(context) {
+		return this.evaluator.getAllFlags(context);
+	}
+	getFlag(flagKey) {
+		return this.store.get(flagKey);
+	}
+	getStats() {
+		return {
+			...this.stats,
+			cacheAge: this.stats.lastSuccessfulPollAt ? Date.now() - this.stats.lastSuccessfulPollAt.getTime() : null
+		};
+	}
+	resolveReady() {
+		if (this.readyResolve) {
+			this.readyResolve();
+			this.readyResolve = null;
+		}
+	}
+	async poll() {
+		if (this.closed) return;
+		const previousFlags = this.store.getAll();
+		try {
+			this.stats.pollCount++;
+			this.stats.lastPollAt = /* @__PURE__ */ new Date();
+			const data = await this.fetchWithTimeout();
+			this.store.swap(data);
+			this.stats.lastSuccessfulPollAt = /* @__PURE__ */ new Date();
+			this.stats.flagCount = this.store.size;
+			this.consecutiveErrors = 0;
+			if (this.initialized) this.emitChanges(previousFlags, data);
+			this.initialized = true;
+			this.resolveReady();
+			this.logger?.debug("Poll successful", { flagCount: this.store.size });
+		} catch (error) {
+			if (this.closed) return;
+			this.consecutiveErrors++;
+			this.stats.pollErrorCount++;
+			this.emit("error", error);
+			this.logger?.error("Poll failed", error);
+			if (error instanceof UnauthorizedException) {
+				this.emit("failed", error);
+				if (!this.initialized && this.readyReject) {
+					this.readyReject(error);
+					this.readyReject = null;
+				}
+				return;
+			}
+		}
+		this.scheduleNextPoll();
+	}
+	async fetchWithTimeout() {
+		this.pollAbortController = new AbortController();
+		const { signal } = this.pollAbortController;
+		let timeoutId;
+		const fetchPromise = this.workos.get("/sdk/feature-flags").then(({ data }) => data);
+		const timeoutPromise = new Promise((_, reject) => {
+			timeoutId = setTimeout(() => {
+				this.pollAbortController?.abort();
+				reject(/* @__PURE__ */ new Error("Request timed out"));
+			}, this.requestTimeoutMs);
+		});
+		const abortPromise = new Promise((_, reject) => {
+			if (signal.aborted) {
+				reject(/* @__PURE__ */ new Error("Poll aborted"));
+				return;
+			}
+			signal.addEventListener("abort", () => reject(/* @__PURE__ */ new Error("Poll aborted")), { once: true });
+		});
+		return Promise.race([
+			fetchPromise,
+			timeoutPromise,
+			abortPromise
+		]).finally(() => {
+			clearTimeout(timeoutId);
+		});
+	}
+	scheduleNextPoll() {
+		if (this.closed) return;
+		let baseDelay = this.pollingIntervalMs;
+		if (this.consecutiveErrors > 0) {
+			const backoff = Math.min(INITIAL_RETRY_MS * Math.pow(BACKOFF_MULTIPLIER, this.consecutiveErrors - 1), MAX_RETRY_MS);
+			baseDelay = Math.max(baseDelay, backoff);
+		}
+		const jitter = 1 + (Math.random() * 2 - 1) * JITTER_FACTOR;
+		const delay = Math.max(MIN_DELAY_MS, baseDelay * jitter);
+		this.pollTimer = setTimeout(() => this.poll(), delay);
+	}
+	emitChanges(previous, current) {
+		if (!previous || !current) return;
+		const allKeys = new Set([...Object.keys(previous), ...Object.keys(current)]);
+		for (const key of allKeys) {
+			const prev = previous[key];
+			const curr = current[key];
+			if (this.hasEntryChanged(prev, curr)) this.emit("change", {
+				key,
+				previous: prev ?? null,
+				current: curr ?? null
+			});
+		}
+	}
+	hasEntryChanged(a, b) {
+		if (!a || !b) return a !== b;
+		if (a.enabled !== b.enabled || a.default_value !== b.default_value) return true;
+		const targetsChanged = (xs, ys) => {
+			if (xs.length !== ys.length) return true;
+			const map = new Map(ys.map((t) => [t.id, t.enabled]));
+			return xs.some((t) => map.get(t.id) !== t.enabled);
+		};
+		return targetsChanged(a.targets.users, b.targets.users) || targetsChanged(a.targets.organizations, b.targets.organizations);
+	}
+};
+//#endregion
 //#region src/feature-flags/feature-flags.ts
 var FeatureFlags = class {
 	constructor(workos) {
@@ -3748,6 +3983,9 @@ var FeatureFlags = class {
 		const { slug, targetId } = options;
 		await this.workos.delete(`/feature-flags/${slug}/targets/${targetId}`);
 	}
+	createRuntimeClient(options) {
+		return new FeatureFlagsRuntimeClient(this.workos, options);
+	}
 };
 //#endregion
 //#region src/widgets/interfaces/get-token.ts
@@ -4442,7 +4680,7 @@ function extractBunVersionFromUserAgent() {
 }
 //#endregion
 //#region package.json
-var version = "8.10.0";
+var version = "8.11.1";
 //#endregion
 //#region src/workos.ts
 const DEFAULT_HOSTNAME = "api.workos.com";
@@ -4880,6 +5118,12 @@ Object.defineProperty(exports, "DomainDataState", {
 		return DomainDataState;
 	}
 });
+Object.defineProperty(exports, "FeatureFlagsRuntimeClient", {
+	enumerable: true,
+	get: function() {
+		return FeatureFlagsRuntimeClient;
+	}
+});
 Object.defineProperty(exports, "FetchHttpClient", {
 	enumerable: true,
 	get: function() {
@@ -5007,4 +5251,4 @@ Object.defineProperty(exports, "serializeRevokeSessionOptions", {
 	}
 });
 
-//# sourceMappingURL=factory-DwdIHLNE.cjs.map
+//# sourceMappingURL=factory-BraleEZU.cjs.map