@configdirector/nuxt-sdk 1.7.0 → 1.8.0

package/README.md

@@ -31,6 +31,40 @@ const { value: darkMode } = useConfigDirectorValue("dark-mode", false);
 
 Full details are in the [official documentation](https://docs.configdirector.com/sdks/meta/nuxt).
 
+## Test your code
+
+`@configdirector/nuxt-sdk/testing` creates a real client connected to an in-memory server that your
+test controls. Install it before the Nuxt app is created, at the top level of a test file or a
+vitest setup file, and the ConfigDirector plugin provides it to the app instead of building a
+client. Tests run in the `nuxt` environment of `@nuxt/test-utils` 4 (which needs vitest 4).
+
+```ts
+import { nextTick } from "vue";
+import { mountSuspended } from "@nuxt/test-utils/runtime";
+import { createTestClient, installTestClient } from "@configdirector/nuxt-sdk/testing";
+import Checkout from "~/components/Checkout.vue";
+
+const testClient = createTestClient({ values: { "dark-mode": true } });
+installTestClient(testClient);
+
+test("renders the dark mode", async () => {
+  const component = await mountSuspended(Checkout);
+  expect(component.text()).toContain("dark-mode: true");
+
+  testClient.setValue("dark-mode", false);
+  await nextTick();
+  expect(component.text()).toContain("dark-mode: false");
+});
+```
+
+`@nuxt/test-utils` 4 creates the app once per test file, inside a `beforeAll` hook, so install at
+module level rather than in a hook, and reset the values between tests with `replaceValues`.
+`@nuxt/test-utils` 3 creates the app before the test file loads, so the plugin cannot see a test
+client installed there; upgrade to use the testing entry. While
+installed, the plugin needs no `clientSdkKey`. Await `nextTick()` after `setValue`, `removeValue`,
+and `replaceValues`. The test client also holds or fails `initialize` and `updateContext`, and
+records every context in `contextUpdates`.
+
 ## Documentation
 
 Refer to the [official documentation for the Nuxt SDK](https://docs.configdirector.com/sdks/meta/nuxt).

package/dist/module.d.mts

@@ -92,6 +92,32 @@ interface ConfigDirectorPublicRuntimeConfig {
    * Can be set via the NUXT_PUBLIC_CONFIGDIRECTOR_BASE_URL environment variable.
    */
   baseUrl?: string;
+  /**
+   * Connection options for the browser client used on the client side.
+   */
+  connection?: {
+    /**
+     * The connection mode, one of `streaming` (default) or `polling`. In `streaming` mode the
+     * connection stays open and receives config updates as they happen. In `polling` mode configs
+     * are fetched once during initialization and then again on every `pollingInterval`.
+     * Can be set via the NUXT_PUBLIC_CONFIGDIRECTOR_CONNECTION_MODE environment variable.
+     */
+    mode?: ConnectionMode;
+    /**
+     * The polling interval in seconds when `mode` is `polling`. Has no effect in `streaming` mode.
+     * When omitted (or `0`), it defaults to 60 seconds. A value below the minimum of 30 seconds is
+     * raised to 30 seconds and a warning is logged.
+     * Can be set via the NUXT_PUBLIC_CONFIGDIRECTOR_CONNECTION_POLLING_INTERVAL environment variable.
+     */
+    pollingInterval?: number;
+    /**
+     * How long, in milliseconds, the browser client waits for its initial config payload during
+     * initialization before the app renders with default values. When omitted (or `0`), it defaults
+     * to 2000 milliseconds.
+     * Can be set via the NUXT_PUBLIC_CONFIGDIRECTOR_CONNECTION_TIMEOUT environment variable.
+     */
+    timeout?: number;
+  };
 }
 declare module "nuxt/schema" {
   interface RuntimeConfig {

package/dist/module.json

@@ -4,5 +4,5 @@
   "compatibility": {
     "nuxt": ">=4.0.0"
   },
-  "version": "1.7.0"
+  "version": "1.8.0"
 }

package/dist/module.mjs

@@ -25,14 +25,19 @@ var module_default = defineNuxtModule({
 			...serverDefaults,
 			logLevel: options.logLevel
 		} : serverDefaults);
-		nuxt.options.runtimeConfig.public.configdirector = defu(nuxt.options.runtimeConfig.public.configdirector, options.logLevel !== void 0 ? {
-			clientSdkKey: "",
-			logLevel: options.logLevel,
-			baseUrl: ""
-		} : {
+		const publicDefaults = {
 			clientSdkKey: "",
-			baseUrl: ""
-		});
+			baseUrl: "",
+			connection: {
+				mode: "streaming",
+				pollingInterval: 0,
+				timeout: 0
+			}
+		};
+		nuxt.options.runtimeConfig.public.configdirector = defu(nuxt.options.runtimeConfig.public.configdirector, options.logLevel !== void 0 ? {
+			...publicDefaults,
+			logLevel: options.logLevel
+		} : publicDefaults);
 		logger.debug("ConfigDirector Nuxt module setup complete");
 		addServerPlugin(resolver.resolve("./runtime/nitro/plugin"));
 		addServerHandler({

package/dist/runtime/app/composables/useConfigDirectorClient.d.mts

@@ -1,4 +1,4 @@
-import { n as ConfigDirectorClient } from "../../types-BPvGEzJY.mjs";
+import { n as ConfigDirectorClient } from "../../types-CvmjergQ.mjs";
 
 //#region src/runtime/app/composables/useConfigDirectorClient.d.ts
 declare const useConfigDirectorClient: () => {

package/dist/runtime/app/composables/useConfigDirectorClient.d.ts

@@ -1,4 +1,4 @@
-import { n as ConfigDirectorClient } from "../../types-BPvGEzJY.mjs";
+import { n as ConfigDirectorClient } from "../../types-CvmjergQ.mjs";
 
 //#region src/runtime/app/composables/useConfigDirectorClient.d.ts
 declare const useConfigDirectorClient: () => {

package/dist/runtime/app/composables/useConfigDirectorClientHooks.d.mts

@@ -1,4 +1,4 @@
-import { t as ClientHooks } from "../../types-BPvGEzJY.mjs";
+import { t as ClientHooks } from "../../types-CvmjergQ.mjs";
 
 //#region src/runtime/app/composables/useConfigDirectorClientHooks.d.ts
 declare const useConfigDirectorClientHooks: (hooks: ClientHooks) => void;

package/dist/runtime/app/composables/useConfigDirectorClientHooks.d.ts

@@ -1,4 +1,4 @@
-import { t as ClientHooks } from "../../types-BPvGEzJY.mjs";
+import { t as ClientHooks } from "../../types-CvmjergQ.mjs";
 
 //#region src/runtime/app/composables/useConfigDirectorClientHooks.d.ts
 declare const useConfigDirectorClientHooks: (hooks: ClientHooks) => void;

package/dist/runtime/app/composables/useConfigDirectorContext.mjs

@@ -16,9 +16,14 @@ const useConfigDirectorContext = () => {
 		state.value = rawContext;
 		if (oldContext != newContext) {
 			const timeout = getEffectiveTimeout(options?.timeoutMilliseconds);
-			await Promise.race([client.updateContext(rawContext), new Promise((resolve) => {
-				setTimeout(() => resolve(), timeout);
-			})]);
+			let timer;
+			try {
+				await Promise.race([client.updateContext(rawContext), new Promise((resolve) => {
+					timer = setTimeout(() => resolve(), timeout);
+				})]);
+			} finally {
+				clearTimeout(timer);
+			}
 		}
 	};
 	return {

package/dist/runtime/nitro/plugin.d.mts

@@ -1,4 +1,4 @@
-import { n as ConfigDirectorClient } from "../types-C54FjC1D.mjs";
+import { n as ConfigDirectorClient } from "../types-Bgx2-3dY.mjs";
 import * as _$nitropack from "nitropack";
 
 //#region src/runtime/nitro/plugin.d.ts

package/dist/runtime/nitro/plugin.d.ts

@@ -1,4 +1,4 @@
-import { n as ConfigDirectorClient } from "../types-C54FjC1D.mjs";
+import { n as ConfigDirectorClient } from "../types-Bgx2-3dY.mjs";
 import * as _$nitropack from "nitropack";
 
 //#region src/runtime/nitro/plugin.d.ts

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,17 +7069,10 @@ 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
@@ -7223,7 +7249,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 +7444,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 +7657,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 +7862,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 +7874,26 @@ 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.configSet.configs = {
-					...this.configSet.configs,
-					...configBundle.configs
-				};
-				this.eventEmitter.emit("configsUpdated", { keys: configKeys });
-				this.updateWatchers(configBundle.configs);
-			}
-			this.logger.debug(`[ConfigDirectorClient] ConfigSet updated from server with ${configKeys.length} key(s)`, { keys: configKeys });
+			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
+			};
+			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 +7914,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 +7939,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);
 		});
 	}
@@ -8051,9 +8126,15 @@ var DefaultConfigDirectorClient = class {
 		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 +8161,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.8.0"
 	}, {
 		logger,
 		connection: {