@workos-inc/node 8.9.0 → 8.11.0

package/lib/{factory-ClnPnWTz.mjs → factory-DA0LsbEO.mjs}

@@ -1,3 +1,4 @@
+import { EventEmitter } from "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 ??= import("./webapi-oTg8yaNv.mjs");
+	return _josePromise ??= import("./webapi-CxKOxXjo.mjs");
 }
 //#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 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";
@@ -4724,6 +5054,6 @@ function createWorkOS(options) {
 	return new WorkOS(options);
 }
 //#endregion
-export { FetchHttpClient as A, RateLimitExceededException as C, BadRequestException as D, NoApiKeyProvidedException as E, GenericServerException as O, SignatureVerificationException as S, NotFoundException as T, PKCE as _, OrganizationDomainVerificationStrategy as a, UnprocessableEntityException as b, WarrantOp as c, CheckOp as d, CookieSession as f, AutoPaginatable as g, AuthenticateWithSessionCookieFailureReason as h, OrganizationDomainState as i, SubtleCryptoProvider as j, ApiKeyRequiredException as k, ResourceOp as l, serializeRevokeSessionOptions as m, ConnectionType as n, DomainDataState as o, RefreshSessionFailureReason as p, GeneratePortalLinkIntent as r, WorkOS as s, createWorkOS as t, CheckResult as u, Webhooks as v, OauthException as w, UnauthorizedException as x, Actions as y };
+export { ApiKeyRequiredException as A, SignatureVerificationException as C, NoApiKeyProvidedException as D, NotFoundException as E, SubtleCryptoProvider as M, BadRequestException as O, UnauthorizedException as S, OauthException as T, AutoPaginatable as _, OrganizationDomainVerificationStrategy as a, Actions as b, FeatureFlagsRuntimeClient as c, CheckResult as d, CheckOp as f, AuthenticateWithSessionCookieFailureReason as g, serializeRevokeSessionOptions as h, OrganizationDomainState as i, FetchHttpClient as j, GenericServerException as k, WarrantOp as l, RefreshSessionFailureReason as m, ConnectionType as n, DomainDataState as o, CookieSession as p, GeneratePortalLinkIntent as r, WorkOS as s, createWorkOS as t, ResourceOp as u, PKCE as v, RateLimitExceededException as w, UnprocessableEntityException as x, Webhooks as y };
 
-//# sourceMappingURL=factory-ClnPnWTz.mjs.map
+//# sourceMappingURL=factory-DA0LsbEO.mjs.map