@workos-inc/node 8.9.0 → 8.11.0

package/lib/{factory-DlHvKYOI.cjs → factory-CFeJhRhj.cjs}

@@ -1,3 +1,4 @@
+let node_events = require("node:events");
 //#region src/common/crypto/crypto-provider.ts
 /**
 * Interface encapsulating the various crypto computations used by the library,
@@ -117,7 +118,7 @@ var HttpClient = class HttpClient {
 	}
 	addClientToUserAgent(userAgent) {
 		if (userAgent.indexOf(" ") > -1) return userAgent.replace(/\b\s/, `/${this.getClientName()} `);
-		else return userAgent += `/${this.getClientName()}`;
+		else return `${userAgent}/${this.getClientName()}`;
 	}
 	static getResourceURL(baseURL, path, params) {
 		const queryString = HttpClient.getQueryString(params);
@@ -1292,6 +1293,53 @@ const deserializeFeatureFlag = (featureFlag) => ({
 	updatedAt: featureFlag.updated_at
 });
 //#endregion
+//#region src/vault/serializers/vault-event.serializer.ts
+const deserializeVaultActor = (actor) => ({
+	actorId: actor.actor_id,
+	actorSource: actor.actor_source,
+	actorName: actor.actor_name
+});
+const deserializeVaultDataCreatedEvent = (data) => ({
+	...deserializeVaultActor(data),
+	kvName: data.kv_name,
+	keyId: data.key_id,
+	keyContext: data.key_context
+});
+const deserializeVaultDataUpdatedEvent = (data) => ({
+	...deserializeVaultActor(data),
+	kvName: data.kv_name,
+	keyId: data.key_id,
+	keyContext: data.key_context
+});
+const deserializeVaultDataReadEvent = (data) => ({
+	...deserializeVaultActor(data),
+	kvName: data.kv_name,
+	keyId: data.key_id
+});
+const deserializeVaultDataDeletedEvent = (data) => ({
+	...deserializeVaultActor(data),
+	kvName: data.kv_name
+});
+const deserializeVaultMetadataReadEvent = (data) => ({
+	...deserializeVaultActor(data),
+	kvName: data.kv_name
+});
+const deserializeVaultNamesListedEvent = (data) => deserializeVaultActor(data);
+const deserializeVaultKekCreatedEvent = (data) => ({
+	...deserializeVaultActor(data),
+	keyName: data.key_name,
+	keyId: data.key_id
+});
+const deserializeVaultDekReadEvent = (data) => ({
+	...deserializeVaultActor(data),
+	keyIds: data.key_ids,
+	keyContext: data.key_context
+});
+const deserializeVaultDekDecryptedEvent = (data) => ({
+	...deserializeVaultActor(data),
+	keyId: data.key_id
+});
+//#endregion
 //#region src/common/serializers/event.serializer.ts
 const deserializeEvent = (event) => {
 	const eventBase = {
@@ -1465,6 +1513,51 @@ const deserializeEvent = (event) => {
 			event: event.event,
 			data: deserializeFeatureFlag(event.data)
 		};
+		case "vault.data.created": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultDataCreatedEvent(event.data)
+		};
+		case "vault.data.updated": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultDataUpdatedEvent(event.data)
+		};
+		case "vault.data.read": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultDataReadEvent(event.data)
+		};
+		case "vault.data.deleted": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultDataDeletedEvent(event.data)
+		};
+		case "vault.names.listed": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultNamesListedEvent(event.data)
+		};
+		case "vault.metadata.read": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultMetadataReadEvent(event.data)
+		};
+		case "vault.kek.created": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultKekCreatedEvent(event.data)
+		};
+		case "vault.dek.read": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultDekReadEvent(event.data)
+		};
+		case "vault.dek.decrypted": return {
+			...eventBase,
+			event: event.event,
+			data: deserializeVaultDekDecryptedEvent(event.data)
+		};
 	}
 };
 //#endregion
@@ -1671,7 +1764,8 @@ const serializeListEventOptions = (options) => ({
 	range_start: options.rangeStart,
 	range_end: options.rangeEnd,
 	limit: options.limit,
-	after: options.after
+	after: options.after,
+	order: options.order
 });
 //#endregion
 //#region src/events/events.ts
@@ -1693,6 +1787,7 @@ const deserializeRole = (role) => ({
 	slug: role.slug,
 	description: role.description,
 	permissions: role.permissions,
+	resourceTypeSlug: role.resource_type_slug,
 	type: role.type,
 	createdAt: role.created_at,
 	updatedAt: role.updated_at
@@ -2700,7 +2795,7 @@ let _josePromise;
 * @returns Promise that resolves to the jose module
 */
 function getJose() {
-	return _josePromise ??= Promise.resolve().then(() => require("./webapi-DoOhnR2U.cjs"));
+	return _josePromise ??= Promise.resolve().then(() => require("./webapi-N7c2LUJd.cjs"));
 }
 //#endregion
 //#region src/user-management/session.ts
@@ -3626,6 +3721,236 @@ 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 node_events.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);
+		});
+	}
+	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) {
@@ -3654,6 +3979,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
@@ -4222,7 +4550,9 @@ var Vault = class {
 	async listObjects(options) {
 		const url = new URL("/vault/v1/kv", this.workos.baseURL);
 		if (options?.after) url.searchParams.set("after", options.after);
+		if (options?.before) url.searchParams.set("before", options.before);
 		if (options?.limit) url.searchParams.set("limit", options.limit.toString());
+		if (options?.order) url.searchParams.set("order", options.order);
 		const { data } = await this.workos.get(url.toString());
 		return deserializeListObjects(data);
 	}
@@ -4346,7 +4676,7 @@ function extractBunVersionFromUserAgent() {
 }
 //#endregion
 //#region package.json
-var version = "8.9.0";
+var version = "8.11.0";
 //#endregion
 //#region src/workos.ts
 const DEFAULT_HOSTNAME = "api.workos.com";
@@ -4784,6 +5114,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() {
@@ -4911,4 +5247,4 @@ Object.defineProperty(exports, "serializeRevokeSessionOptions", {
 	}
 });
 
-//# sourceMappingURL=factory-DlHvKYOI.cjs.map
+//# sourceMappingURL=factory-CFeJhRhj.cjs.map