@configdirector/nuxt-sdk 0.1.1 → 0.5.0

package/dist/runtime/nitro/plugin.mjs

@@ -380,7 +380,7 @@ var StreamingTransport = class {
 					this.dispatchMessage(data);
 				},
 				onConnect: () => {
-					this.logger.debug("[EventSourceTransport] Connected");
+					this.logger.debug("[StreamingTransport] Connected");
 					resolve(this);
 				},
 				shouldReconnect: (state) => {
@@ -390,11 +390,13 @@ var StreamingTransport = class {
 				},
 				calculateReconnectDelay: (state) => {
 					const delay = Math.pow(2, Math.min(state.attempt, MAX_EXPONENTIAL_DELAY)) * 1e3;
-					this.logger.warn(`[EventSourceTransport] Scheduling reconnect in ${delay}ms.`);
+					const logMessage = `[StreamingTransport] Scheduling reconnect attempt #${state.attempt} in ${delay}ms.`;
+					if (state.attempt <= 5) this.logger.info(logMessage);
+					else this.logger.warn(logMessage);
 					return delay;
 				},
 				onDisconnect: () => {
-					this.logger.debug("[EventSourceTransport] Disconnected");
+					this.logger.debug("[StreamingTransport] Disconnected");
 				}
 			});
 			this.eventSource.connect();
@@ -408,7 +410,7 @@ var StreamingTransport = class {
 			const json = JSON.parse(data);
 			this.eventEmitter.emit("configBundleReceived", json);
 		} catch (error) {
-			this.logger.error("[EventSourceTransport] Error parsing and dispatching config data update: ", error);
+			this.logger.error("[StreamingTransport] Error parsing and dispatching config data update: ", error);
 		}
 	}
 	prepareFatalError(responseStatus, error) {
@@ -440,6 +442,148 @@ var StreamingTransport = class {
 	}
 };
 //#endregion
+//#region ../shared/src/transport/AbstractPollingTransport.ts
+var AbstractPollingTransport = class {
+	fatalError = false;
+	pollingInterval;
+	pollingIntervalSeconds = 60;
+	clearPollingInterval() {
+		clearInterval(this.pollingInterval);
+	}
+	schedulePollingInterval(callback) {
+		clearInterval(this.pollingInterval);
+		if (this.pollingIntervalSeconds <= 0) return;
+		this.pollingInterval = setInterval(callback, this.pollingIntervalSeconds * 1e3);
+	}
+	async handleNonOkResponse(response) {
+		if (!response.ok) if (this.isStatusFatal(response.status)) {
+			this.fatalError = true;
+			throw this.prepareFatalResponseStatusError(response.status, await response.text());
+		} else throw new ConfigDirectorConnectionError(`Connection failed with status: ${response.status}`, response.status);
+	}
+	handleFetchError(fetchError) {
+		if (this.isFetchErrorFatal(fetchError)) {
+			this.fatalError = true;
+			this.close();
+			throw new ConfigDirectorConnectionError(`Connection failed with fatal error: ${fetchError}. This is an unrecoverable error, retry attempts will be ignored.`);
+		} else if (fetchError instanceof SyntaxError) throw new ConfigDirectorConnectionError(`Failed to parse the response from the server: ${fetchError}`);
+		else throw new ConfigDirectorConnectionError(`Connection failed with error: ${fetchError}.`);
+	}
+	prepareFatalResponseStatusError(responseStatus, errorBody) {
+		const status = responseStatus ?? 0;
+		return new ConfigDirectorConnectionError(`${`Connection failed with status: ${responseStatus ?? "unknown"}`}${(errorBody?.trim()?.length ?? 0) > 0 ? ` (${errorBody})` : ""}. This is an unrecoverable error, retry attempts will be ignored.`, status);
+	}
+	isStatusFatal(status) {
+		return !!status && status >= 400 && status < 500;
+	}
+	isFetchErrorFatal(fetchError) {
+		if (fetchError?.name === "NotAllowedError") return true;
+		else if (fetchError instanceof TypeError) return true;
+		return false;
+	}
+	get isConnected() {
+		return this.pollingInterval !== void 0;
+	}
+	close() {
+		clearInterval(this.pollingInterval);
+		this.pollingInterval = void 0;
+	}
+	dispose() {
+		this.close();
+		this.clear();
+	}
+};
+//#endregion
+//#region ../shared/src/fetchWithTimeout.ts
+const fetchWithTimeout = async (timeout, resource, options, logger) => {
+	const abortController = new AbortController();
+	const abortTimeoutId = setTimeout(() => {
+		logger.debug("[fetchWithTimeout] Reached timeout, aborting request");
+		abortController.abort();
+	}, timeout);
+	try {
+		const response = await fetch(typeof resource === "string" || resource instanceof Request ? resource : resource.toString(), {
+			...options,
+			signal: abortController.signal
+		});
+		clearTimeout(abortTimeoutId);
+		return response;
+	} catch (error) {
+		logger.warn("[fetchWithTimeout] Fetch error: ", error);
+		clearTimeout(abortTimeoutId);
+		throw error;
+	}
+};
+//#endregion
+//#region ../js-server-sdk/src/PollingTransport.ts
+var PollingTransport = class extends AbstractPollingTransport {
+	logger;
+	eventEmitter = new EventEmitter$1();
+	url;
+	lastUpdateTimestamp;
+	constructor(options) {
+		super();
+		this.options = options;
+		this.options = options;
+		this.logger = options.logger;
+		this.url = new URL("server/polling/v1", options.baseUrl);
+		this.pollingIntervalSeconds = options.pollingInterval ?? 60;
+	}
+	async connect(timeout) {
+		this.clearPollingInterval();
+		await this.fetchConfigs(timeout);
+		this.schedulePollingInterval(() => {
+			this.fetchConfigs(timeout).catch((error) => {
+				this.logger.error("[PollingTransport] Error during polling:", error);
+			});
+		});
+		return this;
+	}
+	async fetchConfigs(timeout) {
+		if (this.fatalError) {
+			this.logger.warn("[PollingTransport] There was a prior unrecoverable error. Ignoring attempt to reconnect.");
+			return;
+		}
+		try {
+			const response = await fetchWithTimeout(timeout, this.url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					metaContext: this.options.metaContext,
+					serverSdkKey: this.options.serverSdkKey,
+					lastUpdateTimestamp: this.lastUpdateTimestamp
+				})
+			}, this.logger);
+			await this.handleNonOkResponse(response);
+			if (response.status === 200) {
+				const json = JSON.parse(await response.text());
+				this.lastUpdateTimestamp = json.timestamp;
+				this.eventEmitter.emit("configBundleReceived", json);
+			}
+		} catch (fetchError) {
+			this.handleFetchError(fetchError);
+		}
+	}
+	on(name, handler) {
+		this.eventEmitter.on(name, handler);
+	}
+	off(name, handler) {
+		if (handler) this.eventEmitter.off(name, handler);
+		else this.eventEmitter.removeAllListeners(name);
+	}
+	clear() {
+		this.eventEmitter.removeAllListeners();
+	}
+};
+//#endregion
+//#region ../js-server-sdk/src/OneTimeTransport.ts
+var OneTimeTransport = class extends PollingTransport {
+	constructor(options) {
+		super(options);
+		this.pollingIntervalSeconds = 0;
+	}
+};
+//#endregion
 //#region ../config-evaluator/src/text-comparison.ts
 const compareText = (value, operator, targetValues) => {
 	switch (operator.toLowerCase()) {
@@ -709,6 +853,7 @@ const parseConfigValue = (configState, defaultValue) => {
 		usedDefault: true,
 		reason: "value-missing"
 	};
+	if (configState.type === "json") return parseJson(value, defaultValue, requestedType);
 	if (typeof defaultValue === "string") return {
 		parsedValue: value,
 		requestedType,
@@ -770,6 +915,29 @@ const parseConfigFloat = (value) => {
 	if (isNaN(num) || !isFinite(num)) return;
 	return num;
 };
+const parseJson = (jsonString, defaultValue, requestedType) => {
+	if (typeof defaultValue === "string") return {
+		parsedValue: jsonString,
+		requestedType,
+		usedDefault: false,
+		reason: "found-match"
+	};
+	try {
+		return {
+			parsedValue: JSON.parse(jsonString),
+			requestedType,
+			usedDefault: false,
+			reason: "found-match"
+		};
+	} catch {
+		return {
+			parsedValue: defaultValue,
+			requestedType,
+			usedDefault: true,
+			reason: "invalid-json"
+		};
+	}
+};
 //#endregion
 //#region ../shared/src/logger.ts
 const LEVELS = {
@@ -840,7 +1008,7 @@ const defaultUrlFactory = (input, base) => new URL(input, base?.toString());
 //#region ../shared/src/telemetry/utils.ts
 const CONFIG_VALUE_MAX_LENGTH = 500;
 const sanitizeValue = (value, type) => {
-	if (type === "json") try {
+	if (type === "json" || type == null && typeof value === "object") try {
 		return djb2Hash(JSON.stringify(value));
 	} catch {
 		return value.toString().slice(0, CONFIG_VALUE_MAX_LENGTH);
@@ -872,27 +1040,6 @@ const isDroppedEventsEmpty = (droppedEvents) => {
 	return true;
 };
 //#endregion
-//#region ../shared/src/fetchWithTimeout.ts
-const fetchWithTimeout = async (timeout, resource, options, logger) => {
-	const abortController = new AbortController();
-	const abortTimeoutId = setTimeout(() => {
-		logger.debug("[fetchWithTimeout] Reached timeout, aborting request");
-		abortController.abort();
-	}, timeout);
-	try {
-		const response = await fetch(typeof resource === "string" || resource instanceof Request ? resource : resource.toString(), {
-			...options,
-			signal: abortController.signal
-		});
-		clearTimeout(abortTimeoutId);
-		return response;
-	} catch (error) {
-		logger.warn("[fetchWithTimeout] Fetch error: ", error);
-		clearTimeout(abortTimeoutId);
-		throw error;
-	}
-};
-//#endregion
 //#region ../js-server-sdk/src/telemetry/ServerEventReporter.ts
 var ServerEventReporter = class {
 	sdkKey;
@@ -1180,7 +1327,7 @@ var DefaultConfigDirectorClient = class {
 	ready = false;
 	readyPromise;
 	readyResolve;
-	streaming;
+	connectionMode;
 	configEvaluator;
 	metaContext;
 	constructor(serverSdkKey, sdkOptions, clientOptions) {
@@ -1189,8 +1336,8 @@ var DefaultConfigDirectorClient = class {
 		this.metaContext = clientOptions?.metadata ?? {};
 		this.configEvaluator = new ConfigEvaluator(this.logger);
 		const baseUrl = this.parseUrl(clientOptions?.connection?.url) ?? defaultBaseUrl;
-		this.streaming = clientOptions?.connection?.streaming === false ? false : true;
-		const transportConstructor = StreamingTransport;
+		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,
@@ -1209,7 +1356,8 @@ var DefaultConfigDirectorClient = class {
 				sdkName: sdkOptions.sdkName,
 				sdkVersion: sdkOptions.sdkVersion
 			},
-			logger: this.logger
+			logger: this.logger,
+			pollingInterval: clientOptions?.connection?.pollingInterval
 		});
 		this.transport.on("configBundleReceived", (configBundle) => {
 			this.readyResolve?.();
@@ -1247,13 +1395,20 @@ var DefaultConfigDirectorClient = class {
 				setTimeout(() => resolve(), remainingTimeout);
 			})]);
 			if (!this.ready) {
-				const warningDetails = this.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.";
+				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}`);
 			}
 		} catch (error) {
 			this.logger.error("[ConfigDirectorClient] An error occurred during initialization: ", error);
 		}
 	}
+	getTransportConstructor(mode) {
+		switch (mode) {
+			case "one-time": return OneTimeTransport;
+			case "polling": return PollingTransport;
+			default: return StreamingTransport;
+		}
+	}
 	updateWatchers(configsMap) {
 		Object.values(configsMap).forEach((v) => this.updateWatchersForConfig(v));
 	}
@@ -1291,14 +1446,16 @@ var DefaultConfigDirectorClient = class {
 	}
 	getValueFromConfigDefinition(configKey, configDefinition, defaultValue, context) {
 		if (configDefinition) {
-			const parseResult = parseConfigValue(this.configEvaluator.evaluate(configDefinition, {
+			const configState = this.configEvaluator.evaluate(configDefinition, {
 				context,
 				metadata: this.metaContext
-			}), defaultValue);
+			});
+			const parseResult = parseConfigValue(configState, defaultValue);
 			this.usageEventCollector.evaluatedConfig({
 				context,
 				evaluation: {
 					key: configKey,
+					type: configState.type,
 					defaultValue,
 					requestedType: parseResult.requestedType,
 					evaluatedValue: parseResult.parsedValue,
@@ -1354,6 +1511,15 @@ var DefaultConfigDirectorClient = class {
 	unwatchAll() {
 		this.handlersMap.clear();
 	}
+	getAllConfigs(options) {
+		if (!this.configSet) return {};
+		const entries = Object.entries(this.configSet.configs);
+		const filtered = options?.configKeys ? entries.filter(([key]) => options.configKeys?.includes(key)) : entries;
+		return Object.fromEntries(filtered.map(([key, config]) => [key, this.configEvaluator.evaluate(config, {
+			context: options?.context,
+			metadata: this.metaContext
+		})]));
+	}
 	closeConnection() {
 		this.logger.debug("[ConfigDirectorClient] closeConnection() has been called, closing connection to server");
 		this.transport.close();
@@ -1385,7 +1551,7 @@ var plugin_default = defineNitroPlugin((nitroApp) => {
 	const { serverSdkKey, baseUrl } = runtimeConfig.configdirector;
 	const client = new DefaultConfigDirectorClient(serverSdkKey, {
 		sdkName: "nuxt-sdk",
-		sdkVersion: "0.1.1"
+		sdkVersion: "0.5.0"
 	}, {
 		logger,
 		...baseUrl ? { connection: { url: baseUrl } } : {}