@configdirector/nuxt-sdk 1.7.0 → 1.9.0

package/dist/runtime/nitro/plugin.mjs

@@ -1,6 +1,5 @@
 import EventEmitter, { EventEmitter as EventEmitter$1 } from "node:events";
 import { createHash, randomUUID } from "node:crypto";
-import { findByPointer } from "@jsonjoy.com/json-pointer";
 import * as semver from "semver";
 import { rapidhash } from "rapidhash-js";
 import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
@@ -413,6 +412,7 @@ var StreamingTransport = class {
 				shouldReconnect: (state) => {
 					const reconnect = !this.isStatusFatal(state.status);
 					if (!reconnect) {
+						this.stopHeartbeat();
 						const error = this.prepareFatalError(state.status, state.error);
 						this.eventEmitter.emit("connectionError", error);
 						reject(error);
@@ -433,9 +433,14 @@ var StreamingTransport = class {
 			this.eventSource.connect();
 		});
 		this.heartbeatTimer = setInterval(() => this.sendHeartbeat(), HEARTBEAT_INTERVAL_MS);
-		return Promise.race([eventSourcePromise, new Promise((resolve) => {
-			setTimeout(() => resolve(this), timeout);
-		})]);
+		let connectTimer;
+		try {
+			return await Promise.race([eventSourcePromise, new Promise((resolve) => {
+				connectTimer = setTimeout(() => resolve(this), timeout);
+			})]);
+		} finally {
+			clearTimeout(connectTimer);
+		}
 	}
 	get sessionId() {
 		return this._sessionId;
@@ -491,9 +496,12 @@ var StreamingTransport = class {
 	clear() {
 		this.eventEmitter.removeAllListeners();
 	}
-	close() {
+	stopHeartbeat() {
 		clearInterval(this.heartbeatTimer);
 		this.heartbeatTimer = void 0;
+	}
+	close() {
+		this.stopHeartbeat();
 		this.eventSource?.close();
 	}
 	dispose() {
@@ -506,7 +514,6 @@ var StreamingTransport = class {
 var AbstractPollingTransport = class {
 	fatalError = false;
 	pollingInterval;
-	pollingIntervalSeconds = 60;
 	clearPollingInterval() {
 		clearInterval(this.pollingInterval);
 	}
@@ -555,6 +562,7 @@ var AbstractPollingTransport = class {
 //#endregion
 //#region ../js-server-sdk/src/PollingTransport.ts
 var PollingTransport = class extends AbstractPollingTransport {
+	pollingIntervalSeconds;
 	logger;
 	eventEmitter = new EventEmitter$1();
 	url;
@@ -627,6 +635,31 @@ var PollingTransport = class extends AbstractPollingTransport {
 	}
 };
 //#endregion
+//#region ../config-evaluator/src/json-pointer.ts
+const ARRAY_INDEX_PATTERN = /^(?:0|[1-9][0-9]*)$/;
+const INVALID_ESCAPE_PATTERN = /~(?![01])/;
+const isSerializedMember = Object.prototype.propertyIsEnumerable;
+const decodeReferenceToken = (token) => {
+	if (INVALID_ESCAPE_PATTERN.test(token)) return;
+	return token.replace(/~1/g, "/").replace(/~0/g, "~");
+};
+const step = (current, token) => {
+	if (Array.isArray(current)) return ARRAY_INDEX_PATTERN.test(token) && isSerializedMember.call(current, token) ? current[Number(token)] : void 0;
+	if (typeof current === "object" && current !== null) return isSerializedMember.call(current, token) ? current[token] : void 0;
+};
+const resolveJsonPointer = (pointer, document) => {
+	if (pointer === "") return document;
+	if (!pointer.startsWith("/")) return;
+	let current = document;
+	for (const encodedToken of pointer.slice(1).split("/")) {
+		const token = decodeReferenceToken(encodedToken);
+		if (token === void 0) return;
+		current = step(current, token);
+		if (current === void 0) return;
+	}
+	return current;
+};
+//#endregion
 //#region ../config-evaluator/src/text-comparison.ts
 /**
 * Text comparisons.
@@ -7036,19 +7069,46 @@ var ConditionEvaluator = class {
 			case "appVersion": return orAbsent(context?.metadata?.appVersion);
 			case "traits":
 				if (!condition.trait) return ABSENT;
-				return orAbsent(this.findTraitValue(context?.context?.traits, condition.trait));
+				return orAbsent(resolveJsonPointer(condition.trait, context?.context?.traits));
 			default: return UNKNOWN_ATTRIBUTE;
 		}
 	}
-	findTraitValue(traits, path) {
-		try {
-			return findByPointer(path, traits).val;
-		} catch {
-			return;
+};
+const orAbsent = (value) => value === void 0 || value === null ? ABSENT : value;
+//#endregion
+//#region ../config-evaluator/src/SegmentEvaluator.ts
+var SegmentEvaluator = class {
+	constructor(conditionEvaluator) {
+		this.conditionEvaluator = conditionEvaluator;
+	}
+	explain(condition, segments, context) {
+		const segment = segments?.[condition.segmentId];
+		if (segment === void 0 || !holdsAttributeConditionsOnly(segment)) return {
+			matched: false,
+			segmentFound: false,
+			matchedGroupIndex: void 0
+		};
+		const matchedGroupIndex = this.matchingGroupIndex(segment, context);
+		const member = matchedGroupIndex !== void 0;
+		return {
+			matched: this.operatorHolds(condition, member),
+			segmentFound: true,
+			matchedGroupIndex
+		};
+	}
+	operatorHolds(condition, member) {
+		switch (condition.operator.toLowerCase()) {
+			case "in": return member;
+			case "not in": return !member;
+			default: return false;
 		}
 	}
+	matchingGroupIndex(segment, context) {
+		const index = (segment.groups ?? []).findIndex((group) => (group ?? []).every((condition) => this.conditionEvaluator.evaluate(condition, context)));
+		return index === -1 ? void 0 : index;
+	}
 };
-const orAbsent = (value) => value === void 0 || value === null ? ABSENT : value;
+const holdsAttributeConditionsOnly = (segment) => (segment.groups ?? []).every((group) => (group ?? []).every((condition) => condition.kind === void 0 || condition.kind === "attribute"));
 //#endregion
 //#region ../config-evaluator/src/percent-hashing.ts
 const SEED = 15426857351n;
@@ -7060,26 +7120,28 @@ const assignPercentage = (data) => {
 //#region ../config-evaluator/src/ConfigEvaluator.ts
 var ConfigEvaluator = class {
 	conditionEvaluator = new ConditionEvaluator();
+	segmentEvaluator = new SegmentEvaluator(this.conditionEvaluator);
 	constructor(logger) {
 		this.logger = logger;
 		if (!logger || !logger.warn || !logger.error || !logger.info) throw new TypeError("The provided logger is not a valid 'ConfigDirectorLogger'");
 		this.logger = logger;
 	}
-	evaluate(config, context) {
+	evaluate(config, context, segments) {
 		return {
 			id: config.id,
 			key: config.key,
 			type: config.type,
-			value: this.explain(config, context).value
+			value: this.explain(config, context, segments).value
 		};
 	}
 	/**
 	* Evaluate a config for a context and record how the value was reached: every rule in the
 	* order it was walked with its outcome, the conditions that were checked with what they
 	* resolved to, and the share a rollout assigned the context to. `evaluate` is this walk with
-	* only the value kept, so the two cannot disagree.
+	* only the value kept, so the two cannot disagree. `segments` is the payload's segments map,
+	* which a segment condition looks its segment up in; a segment it does not hold never matches.
 	*/
-	explain(config, context) {
+	explain(config, context, segments) {
 		const rules = [...config.target?.rules ?? []].sort((a, b) => (a.order ?? Number.MAX_SAFE_INTEGER) - (b.order ?? Number.MAX_SAFE_INTEGER));
 		const explanations = [];
 		let served;
@@ -7093,7 +7155,7 @@ var ConfigEvaluator = class {
 				});
 				continue;
 			}
-			const result = this.explainRule(rule, config, context);
+			const result = this.explainRule(rule, config, context, segments);
 			explanations.push(result.explanation);
 			if (result.value !== void 0) served = {
 				ruleId: rule.id,
@@ -7109,7 +7171,7 @@ var ConfigEvaluator = class {
 			rules: explanations
 		};
 	}
-	explainRule(rule, config, context) {
+	explainRule(rule, config, context, segments) {
 		const explanation = {
 			ruleId: rule.id,
 			outcome: "not-matched",
@@ -7119,7 +7181,7 @@ var ConfigEvaluator = class {
 		try {
 			let value;
 			if (rule.type == "percentage") value = this.explainPercentage(rule.percentages ?? [], config, context, explanation);
-			else if (rule.type == "conditional") value = this.explainConditionalRule(rule, config, context, explanation);
+			else if (rule.type == "conditional") value = this.explainConditionalRule(rule, config, context, segments, explanation);
 			if (value !== void 0) explanation.outcome = "matched";
 			return {
 				explanation,
@@ -7171,7 +7233,7 @@ var ConfigEvaluator = class {
 		};
 		return selected?.value != null ? selected.value.toString() : void 0;
 	}
-	explainConditionalRule(rule, config, context, explanation) {
+	explainConditionalRule(rule, config, context, segments, explanation) {
 		let failed = false;
 		for (const condition of rule.conditions ?? []) {
 			if (failed) {
@@ -7181,19 +7243,35 @@ var ConfigEvaluator = class {
 				});
 				continue;
 			}
-			const check = this.conditionEvaluator.explain(condition, context);
-			explanation.conditions.push({
-				conditionId: condition.id,
-				outcome: check.matched ? "matched" : "not-matched",
-				resolvedValue: check.resolvedValue,
-				resolvedType: check.resolvedType
-			});
-			failed = !check.matched;
+			const checked = this.explainCondition(condition, context, segments);
+			explanation.conditions.push(checked);
+			failed = checked.outcome !== "matched";
 		}
 		if (failed) return;
 		if (rule.target == "value") return rule.value != null ? rule.value.toString() : void 0;
 		if (rule.target == "percentage") return this.explainPercentage(rule.percentages ?? [], config, context, explanation);
 	}
+	explainCondition(condition, context, segments) {
+		if (condition.kind === "segment") {
+			const check = this.segmentEvaluator.explain(condition, segments, context);
+			return {
+				conditionId: condition.id,
+				kind: "segment",
+				outcome: check.matched ? "matched" : "not-matched",
+				segmentId: condition.segmentId,
+				segmentFound: check.segmentFound,
+				matchedGroupIndex: check.matchedGroupIndex
+			};
+		}
+		const check = this.conditionEvaluator.explain(condition, context);
+		return {
+			conditionId: condition.id,
+			kind: "attribute",
+			outcome: check.matched ? "matched" : "not-matched",
+			resolvedValue: check.resolvedValue,
+			resolvedType: check.resolvedType
+		};
+	}
 };
 //#endregion
 //#region ../shared/src/value-parser.ts
@@ -7223,7 +7301,7 @@ const configTypesNotReadableAsString = new Set([
 const parseConfigValue = (configState, defaultValue) => {
 	const value = configState.value;
 	const requestedType = getRequestedType(defaultValue);
-	if (value == null) return {
+	if (value == null || value === "") return {
 		parsedValue: defaultValue,
 		parsedValueId: void 0,
 		requestedType,
@@ -7418,6 +7496,22 @@ const createDefaultLogger$1 = (level, messageDecorator) => {
 //#region ../shared/src/url.ts
 const defaultUrlFactory = (input, base) => new URL(input, base?.toString());
 //#endregion
+//#region ../shared/src/transport/pollingInterval.ts
+const resolvePollingInterval = (configuredSeconds, defaults) => {
+	if (configuredSeconds === void 0) return {
+		seconds: defaults.defaultSeconds,
+		warning: void 0
+	};
+	if (configuredSeconds >= defaults.minimumSeconds) return {
+		seconds: configuredSeconds,
+		warning: void 0
+	};
+	return {
+		seconds: defaults.minimumSeconds,
+		warning: `pollingInterval of ${configuredSeconds} seconds is below the minimum of ${defaults.minimumSeconds} seconds. Using ${defaults.minimumSeconds} seconds.`
+	};
+};
+//#endregion
 //#region ../shared/src/telemetry/utils.ts
 const CONFIG_VALUE_MAX_LENGTH = 500;
 const compactTelemetryValue = async (tv, valueIdGenerator) => {
@@ -7615,12 +7709,18 @@ var TelemetryEventCollector = class {
 	flushIntervalDelay;
 	flushTimeout;
 	collectEvents = true;
+	initialFlushIntervalDelay;
+	started = false;
 	constructor(options) {
 		this.logger = options.logger;
 		this.evaluationEventQueue = new EventQueue(options.evaluationQueueLimit ?? 1e3);
 		this.flushIntervalDelay = options.flushIntervalDelay ?? 3e4;
-		const initialDelay = options.initialFlushIntervalDelay ?? 5e3;
-		this.flushTimeout = setTimeout(() => this.flushAndScheduleNext(), initialDelay);
+		this.initialFlushIntervalDelay = options.initialFlushIntervalDelay ?? 5e3;
+	}
+	start() {
+		if (this.started || !this.collectEvents) return;
+		this.started = true;
+		this.flushTimeout = setTimeout(() => this.flushAndScheduleNext(), this.initialFlushIntervalDelay);
 	}
 	async flushAndScheduleNext() {
 		if (!this.collectEvents) return;
@@ -7814,10 +7914,11 @@ var DefaultConfigDirectorClient = class {
 	ready = false;
 	readyPromise;
 	readyResolve;
+	readyTimer;
 	connectionMode;
 	configEvaluator;
 	metaContext;
-	constructor(serverSdkKey, sdkOptions, clientOptions) {
+	constructor(serverSdkKey, sdkOptions, clientOptions, internalClientOptions) {
 		this.logger = clientOptions?.logger ?? createDefaultLogger$1();
 		this.timeout = clientOptions?.connection?.timeout ?? 3e3;
 		this.metaContext = clientOptions?.metadata ?? {};
@@ -7825,47 +7926,32 @@ var DefaultConfigDirectorClient = class {
 		this.configEvaluator = new ConfigEvaluator(this.logger);
 		const baseUrl = this.parseUrl(clientOptions?.connection?.url) ?? defaultBaseUrl;
 		this.connectionMode = clientOptions?.connection?.mode ?? "streaming";
-		const transportConstructor = this.getTransportConstructor(this.connectionMode);
-		const queueLimit = clientOptions?.telemetry?.eventQueueLimit ?? DEFAULT_EVENT_QUEUE_LIMIT;
-		this.usageEventCollector = new ServerTelemetryEventCollector({
-			sdkKey: serverSdkKey,
-			sdkIdentity: sdkOptions,
-			metaContext: clientOptions?.metadata ?? {},
-			logger: this.logger,
-			baseUrl,
-			flushIntervalDelay: clientOptions?.telemetry?.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
-			evaluationQueueLimit: Math.ceil(queueLimit * .7),
-			contextLimit: Math.floor(queueLimit * .3),
-			urlFactory: defaultUrlFactory,
-			valueIdGenerator: generateValueId
-		});
-		this.transport = new transportConstructor({
-			serverSdkKey,
-			baseUrl,
-			metaContext: {
-				...clientOptions?.metadata,
-				sdkName: sdkOptions.sdkName,
-				sdkVersion: sdkOptions.sdkVersion
-			},
-			logger: this.logger,
-			pollingInterval: clientOptions?.connection?.pollingInterval
-		});
+		this.usageEventCollector = internalClientOptions?.telemetry ?? this.buildTelemetryCollector(serverSdkKey, sdkOptions, baseUrl, clientOptions);
+		this.transport = internalClientOptions?.transport ?? this.buildTransport(serverSdkKey, sdkOptions, baseUrl, clientOptions);
 		this.transport.on("configBundleReceived", (configBundle) => {
-			this.readyResolve?.();
-			const configKeys = Object.keys(configBundle.configs);
-			if (!this.configSet || configBundle.kind == "full") {
-				this.configSet = configBundle;
-				this.eventEmitter.emit("configsUpdated", { keys: configKeys });
-				this.updateWatchers(configBundle.configs);
-			} else {
+			this.readyResolve?.(false);
+			const removedKeys = this.findKeysRemovedBy(configBundle);
+			if (!this.configSet || configBundle.kind == "full") this.configSet = configBundle;
+			else {
 				this.configSet.configs = {
 					...this.configSet.configs,
 					...configBundle.configs
 				};
-				this.eventEmitter.emit("configsUpdated", { keys: configKeys });
-				this.updateWatchers(configBundle.configs);
+				this.configSet.segments = {
+					...this.configSet.segments,
+					...configBundle.segments
+				};
 			}
-			this.logger.debug(`[ConfigDirectorClient] ConfigSet updated from server with ${configKeys.length} key(s)`, { keys: configKeys });
+			const keys = Object.keys(configBundle.configs);
+			this.eventEmitter.emit("configsUpdated", {
+				keys,
+				removedKeys
+			});
+			this.updateWatchers([...keys, ...removedKeys]);
+			this.logger.debug(`[ConfigDirectorClient] ConfigSet updated from server with ${keys.length} key(s) and ${removedKeys.length} removed key(s)`, {
+				keys,
+				removedKeys
+			});
 		});
 		this.transport.on("connectionError", (error) => {
 			this.logger.error("[ConfigDirectorClient] The connection encountered an unrecoverable error and will not be retried. Configs will no longer receive updates.", error);
@@ -7886,18 +7972,23 @@ var DefaultConfigDirectorClient = class {
 			this.ready = false;
 			this.readyPromise = new Promise((resolve) => {
 				this.readyResolve = resolve;
-			}).then(() => {
+			}).then((cancelled) => {
+				if (cancelled) return;
 				this.ready = true;
 				this.eventEmitter.emit("clientReady");
 				this.logger.debug("[ConfigDirectorClient] Received initial payload from the server, client is ready");
 			});
+			this.usageEventCollector.start();
 			const startTime = (/* @__PURE__ */ new Date()).getTime();
 			await this.transport.connect(this.timeout);
 			const elapsedTime = (/* @__PURE__ */ new Date()).getTime() - startTime;
 			const remainingTimeout = this.timeout - elapsedTime;
-			if (remainingTimeout > 0) await Promise.race([this.readyPromise, new Promise((resolve) => {
-				setTimeout(() => resolve(), remainingTimeout);
-			})]);
+			if (remainingTimeout > 0) {
+				await Promise.race([this.readyPromise, new Promise((resolve) => {
+					this.readyTimer = setTimeout(() => resolve(), remainingTimeout);
+				})]);
+				this.clearReadyTimer();
+			}
 			if (!this.ready) {
 				const warningDetails = this.connectionMode === "streaming" ? "The client will continue to retry since there were no fatal errors detected. Configs will return the default value until the connection succeeds." : "Since the client was configured without streaming, configs may not update and always return the default value.";
 				this.logger.warn(`[ConfigDirectorClient] Timed out waiting for initialization after ${this.timeout}ms. ${warningDetails}`);
@@ -7906,18 +7997,60 @@ var DefaultConfigDirectorClient = class {
 			this.logger.error("[ConfigDirectorClient] An error occurred during initialization: ", error);
 		}
 	}
+	resolvePollingIntervalForMode(configuredSeconds) {
+		if (this.connectionMode !== "polling") return;
+		const resolved = resolvePollingInterval(configuredSeconds, {
+			defaultSeconds: 300,
+			minimumSeconds: 60
+		});
+		if (resolved.warning) this.logger.warn(`[ConfigDirectorClient] ${resolved.warning}`);
+		return resolved.seconds;
+	}
+	buildTelemetryCollector(serverSdkKey, sdkOptions, baseUrl, clientOptions) {
+		const queueLimit = clientOptions?.telemetry?.eventQueueLimit ?? DEFAULT_EVENT_QUEUE_LIMIT;
+		return new ServerTelemetryEventCollector({
+			sdkKey: serverSdkKey,
+			sdkIdentity: sdkOptions,
+			metaContext: clientOptions?.metadata ?? {},
+			logger: this.logger,
+			baseUrl,
+			flushIntervalDelay: clientOptions?.telemetry?.flushInterval ?? DEFAULT_FLUSH_INTERVAL,
+			evaluationQueueLimit: Math.ceil(queueLimit * .7),
+			contextLimit: Math.floor(queueLimit * .3),
+			urlFactory: defaultUrlFactory,
+			valueIdGenerator: generateValueId
+		});
+	}
+	buildTransport(serverSdkKey, sdkOptions, baseUrl, clientOptions) {
+		return new (this.getTransportConstructor(this.connectionMode))({
+			serverSdkKey,
+			baseUrl,
+			metaContext: {
+				...clientOptions?.metadata,
+				sdkName: sdkOptions.sdkName,
+				sdkVersion: sdkOptions.sdkVersion
+			},
+			logger: this.logger,
+			pollingInterval: this.resolvePollingIntervalForMode(clientOptions?.connection?.pollingInterval)
+		});
+	}
 	getTransportConstructor(mode) {
 		switch (mode) {
 			case "polling": return PollingTransport;
 			default: return StreamingTransport;
 		}
 	}
-	updateWatchers(configsMap) {
-		Object.values(configsMap).forEach((v) => this.updateWatchersForConfig(v));
+	findKeysRemovedBy(configBundle) {
+		if (!this.configSet || configBundle.kind != "full") return [];
+		return Object.keys(this.configSet.configs).filter((key) => !Object.prototype.hasOwnProperty.call(configBundle.configs, key));
+	}
+	updateWatchers(configKeys) {
+		configKeys.forEach((configKey) => this.updateWatchersForConfig(configKey));
 	}
-	updateWatchersForConfig(configDefinition) {
-		this.handlersMap.get(configDefinition.key)?.forEach((h) => {
-			const value = this.getValueFromConfigDefinition(configDefinition.key, configDefinition, h.defaultValue, h.context);
+	updateWatchersForConfig(configKey) {
+		const configDefinition = this.configSet?.configs[configKey];
+		this.handlersMap.get(configKey)?.forEach((h) => {
+			const value = this.getValueFromConfigDefinition(configKey, configDefinition, h.defaultValue, h.context);
 			h.handler(value);
 		});
 	}
@@ -7952,7 +8085,7 @@ var DefaultConfigDirectorClient = class {
 			const configState = this.configEvaluator.evaluate(configDefinition, {
 				context,
 				metadata: this.metaContext
-			});
+			}, this.configSet?.segments);
 			const parseResult = parseConfigValue(configState, defaultValue);
 			this.usageEventCollector.evaluatedConfig({
 				context,
@@ -8044,16 +8177,22 @@ var DefaultConfigDirectorClient = class {
 		return Object.fromEntries(filtered.map(([key, config]) => [key, this.configEvaluator.evaluate(config, {
 			context: options?.context,
 			metadata: this.metaContext
-		})]));
+		}, this.configSet?.segments)]));
 	}
 	closeConnection() {
 		this.logger.debug("[ConfigDirectorClient] closeConnection() has been called, closing connection to server");
 		this.transport.close();
 		this.ready = false;
 	}
+	clearReadyTimer() {
+		clearTimeout(this.readyTimer);
+		this.readyTimer = void 0;
+	}
 	dispose() {
 		this.removeAllObservers();
 		this.closeConnection();
+		this.readyResolve?.(true);
+		this.clearReadyTimer();
 		this.usageEventCollector.close().catch((error) => {
 			this.logger.warn("[ConfigDirectorClient] Error flushing telemetry while disposing the client: ", error);
 		});
@@ -8080,7 +8219,7 @@ var plugin_default = defineNitroPlugin((nitroApp) => {
 	const { serverSdkKey, baseUrl, connection } = runtimeConfig.configdirector;
 	const client = new DefaultConfigDirectorClient(serverSdkKey, {
 		sdkName: "nuxt-sdk",
-		sdkVersion: "1.7.0"
+		sdkVersion: "1.9.0"
 	}, {
 		logger,
 		connection: {