@configdirector/nuxt-sdk 1.10.0 → 1.11.0

package/dist/runtime/nitro/plugin.mjs

@@ -1,35 +1,13 @@
 import { t as admitContext } from "../context-kind-D6YBNij2.mjs";
+import { a as ConfigDirectorValidationError, i as ConfigDirectorInitializationError, n as encodeNativeValue, r as ConfigDirectorConnectionError } from "../native-values-DZJjFBvk.mjs";
 import EventEmitter, { EventEmitter as EventEmitter$1 } from "node:events";
 import { createHash, randomUUID } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
 import * as semver from "semver";
 import { rapidhash } from "rapidhash-js";
 import { defineNitroPlugin, useRuntimeConfig } from "nitropack/runtime";
 import { consola } from "consola";
-//#region ../shared/src/errors.ts
-var ConfigDirectorConnectionError = class ConfigDirectorConnectionError extends Error {
-	name = "ConfigDirectorConnectionError";
-	status;
-	constructor(message, status) {
-		super(message);
-		this.status = status;
-		Object.setPrototypeOf(this, ConfigDirectorConnectionError.prototype);
-	}
-};
-var ConfigDirectorValidationError = class ConfigDirectorValidationError extends Error {
-	name = "ConfigDirectorValidationError";
-	constructor(message) {
-		super(message);
-		Object.setPrototypeOf(this, ConfigDirectorValidationError.prototype);
-	}
-};
-var ConfigDirectorInitializationError = class ConfigDirectorInitializationError extends Error {
-	name = "ConfigDirectorInitializationError";
-	constructor(message) {
-		super(message);
-		Object.setPrototypeOf(this, ConfigDirectorInitializationError.prototype);
-	}
-};
-//#endregion
 //#region ../eventsource/src/errors.ts
 var StreamClosedError = class StreamClosedError extends Error {
 	name = "StreamClosedError";
@@ -636,6 +614,150 @@ var PollingTransport = class extends AbstractPollingTransport {
 	}
 };
 //#endregion
+//#region ../js-server-sdk/src/native-values.ts
+const unconditionalConfig = (id, key, value) => {
+	const encoded = encodeNativeValue(key, value);
+	return {
+		id,
+		key,
+		type: encoded.type,
+		variations: [{
+			name: null,
+			value: encoded.value
+		}],
+		target: {
+			defaultValue: encoded.value,
+			rules: []
+		}
+	};
+};
+//#endregion
+//#region ../js-server-sdk/src/OfflineTransport.ts
+const OFFLINE_ENVIRONMENT = {
+	environmentId: "offline",
+	projectId: "offline"
+};
+var OfflineTransport = class {
+	emitter = new EventEmitter();
+	connected = false;
+	constructor(source) {
+		this.source = source;
+	}
+	async connect() {
+		const configs = await loadOfflineConfigs(this.source);
+		this.connected = true;
+		this.emitter.emit("configBundleReceived", {
+			...OFFLINE_ENVIRONMENT,
+			kind: "full",
+			configs
+		});
+		return this;
+	}
+	get isConnected() {
+		return this.connected;
+	}
+	on(name, handler) {
+		this.emitter.on(name, handler);
+	}
+	off(name, handler) {
+		if (handler) this.emitter.off(name, handler);
+		else this.emitter.removeAllListeners(name);
+	}
+	close() {
+		this.connected = false;
+	}
+	dispose() {
+		this.close();
+		this.emitter.removeAllListeners();
+	}
+};
+const loadOfflineConfigs = async (source) => {
+	switch (source.kind) {
+		case "in-code-defaults": return {};
+		case "values": return encodeOfflineValues(source.values, "The offline values");
+		case "file": return encodeOfflineValues(await readOfflineValuesFile(source.path), `The offline values file '${source.path}'`);
+		case "rejected": throw new ConfigDirectorInitializationError(source.message);
+	}
+};
+const readOfflineValuesFile = async (path) => {
+	let text;
+	try {
+		text = await readFile(resolve(path), "utf8");
+	} catch (error) {
+		throw new ConfigDirectorInitializationError(`The offline values file '${path}' could not be read: ${messageOf(error)}`);
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (error) {
+		throw new ConfigDirectorInitializationError(`The offline values file '${path}' is not valid JSON: ${messageOf(error)}`);
+	}
+	if (!isJsonObject(parsed)) throw new ConfigDirectorInitializationError(`The offline values file '${path}' must hold a JSON object with one value per config key, but holds ${describeJson(parsed)}.`);
+	return parsed;
+};
+const encodeOfflineValues = (values, subject) => {
+	try {
+		return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, unconditionalConfig(`offline:${key}`, key, value)]));
+	} catch (error) {
+		if (error instanceof ConfigDirectorValidationError) throw new ConfigDirectorInitializationError(`${subject} could not be loaded. ${error.message}`);
+		throw error;
+	}
+};
+const isJsonObject = (parsed) => typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
+const describeJson = (parsed) => {
+	if (parsed === null) return "null";
+	if (Array.isArray(parsed)) return "an array";
+	return `a ${typeof parsed}`;
+};
+const messageOf = (error) => error instanceof Error ? error.message : String(error);
+//#endregion
+//#region ../js-server-sdk/src/connection-plan.ts
+const defaultBaseUrl = new URL("https://server-sdk-api.configdirector.com");
+const planConnection = (serverSdkKey, connection) => {
+	if (connection?.mode === "offline") return {
+		kind: "stay-offline",
+		source: offlineSourceOf(connection)
+	};
+	const mode = connection?.mode ?? "streaming";
+	if (!serverSdkKey || serverSdkKey.trim().length == 0) throw new ConfigDirectorValidationError("No server SDK key was provided, the client cannot be instantiated without a valid server SDK key");
+	if (connection?.file !== void 0 || connection?.values !== void 0) return {
+		kind: "stay-offline",
+		source: {
+			kind: "rejected",
+			message: `The connection options 'file' and 'values' apply only when the connection mode is 'offline', but the mode is '${mode}'.`
+		}
+	};
+	return {
+		kind: "connect",
+		mode,
+		serverSdkKey,
+		baseUrl: baseUrlOf(connection?.url)
+	};
+};
+const baseUrlOf = (url) => {
+	if (!url) return defaultBaseUrl;
+	try {
+		return new URL(url);
+	} catch (error) {
+		throw new ConfigDirectorValidationError(`Invalid base URL '${url}'. Parsing failed: ${error}`);
+	}
+};
+const offlineSourceOf = (connection) => {
+	if (connection.file !== void 0 && connection.values !== void 0) return {
+		kind: "rejected",
+		message: "An offline connection takes either 'file' or 'values', not both."
+	};
+	if (connection.file !== void 0) return {
+		kind: "file",
+		path: connection.file
+	};
+	if (connection.values !== void 0) return {
+		kind: "values",
+		values: connection.values
+	};
+	return { kind: "in-code-defaults" };
+};
+//#endregion
 //#region ../config-evaluator/src/json-pointer.ts
 const ARRAY_INDEX_PATTERN = /^(?:0|[1-9][0-9]*)$/;
 const INVALID_ESCAPE_PATTERN = /~(?![01])/;
@@ -7949,6 +8071,14 @@ var ServerTelemetryEventCollector = class extends TelemetryEventCollector {
 	}
 };
 //#endregion
+//#region ../js-server-sdk/src/telemetry/discarding.ts
+const discardingTelemetryClient = {
+	start: () => {},
+	evaluatedConfig: () => {},
+	recordInvalidContext: () => "new-kind-sample",
+	close: async () => {}
+};
+//#endregion
 //#region ../shared/src/base62-encoder.ts
 const BASE62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
 const toBase62 = (buf, length) => {
@@ -7971,9 +8101,12 @@ const generateValueId = async (v) => {
 };
 //#endregion
 //#region ../js-server-sdk/src/DefaultConfigDirectorClient.ts
-const defaultBaseUrl = new URL("https://server-sdk-api.configdirector.com");
 const DEFAULT_FLUSH_INTERVAL = 3e4;
 const DEFAULT_EVENT_QUEUE_LIMIT = 5e3;
+const liveTimeoutWarningDetails = {
+	streaming: "The client will continue to retry since there were no fatal errors detected. Configs will return the default value until the connection succeeds.",
+	polling: "Since the client was configured without streaming, configs may not update and always return the default value."
+};
 const logInvalidContext = {
 	"new-kind-sample": (logger, kindSample) => logger.error(`[ConfigDirectorClient] Ignored a context with the invalid kind '${kindSample}' and evaluated as if no context was supplied. A context kind has 1 to 64 characters, using only lowercase letters, digits, '-' and '_'.`),
 	"known-kind-sample": () => {},
@@ -7981,7 +8114,7 @@ const logInvalidContext = {
 	"beyond-sample-limit": () => {}
 };
 const usesAnySegment = (definition, segmentIds) => (definition.target?.rules ?? []).some((rule) => rule.type === "conditional" && (rule.conditions ?? []).some((condition) => condition.kind === "segment" && segmentIds.has(condition.segmentId)));
-var DefaultConfigDirectorClient = class {
+var DefaultConfigDirectorClient = class DefaultConfigDirectorClient {
 	logger;
 	usageEventCollector;
 	configSet;
@@ -7993,19 +8126,21 @@ var DefaultConfigDirectorClient = class {
 	readyPromise;
 	readyResolve;
 	readyTimer;
-	connectionMode;
+	connectionPlan;
 	configEvaluator;
 	metaContext;
+	static from(serverSdkKeyOrOptions, sdkOptions, clientOptions) {
+		if (typeof serverSdkKeyOrOptions === "object") return new DefaultConfigDirectorClient(void 0, sdkOptions, serverSdkKeyOrOptions);
+		return new DefaultConfigDirectorClient(serverSdkKeyOrOptions, sdkOptions, clientOptions);
+	}
 	constructor(serverSdkKey, sdkOptions, clientOptions, internalClientOptions) {
 		this.logger = clientOptions?.logger ?? createDefaultLogger$1();
 		this.timeout = clientOptions?.connection?.timeout ?? 3e3;
 		this.metaContext = clientOptions?.metadata ?? {};
-		this.validateSdkKeyPresence(serverSdkKey);
+		this.connectionPlan = planConnection(serverSdkKey, clientOptions?.connection);
 		this.configEvaluator = new ConfigEvaluator(this.logger);
-		const baseUrl = this.parseUrl(clientOptions?.connection?.url) ?? defaultBaseUrl;
-		this.connectionMode = clientOptions?.connection?.mode ?? "streaming";
-		this.usageEventCollector = internalClientOptions?.telemetry ?? this.buildTelemetryCollector(serverSdkKey, sdkOptions, baseUrl, clientOptions);
-		this.transport = internalClientOptions?.transport ?? this.buildTransport(serverSdkKey, sdkOptions, baseUrl, clientOptions);
+		this.usageEventCollector = internalClientOptions?.telemetry ?? this.buildTelemetryClient(sdkOptions, clientOptions);
+		this.transport = internalClientOptions?.transport ?? this.buildTransport(sdkOptions, clientOptions);
 		this.transport.on("configBundleReceived", (configBundle) => {
 			this.readyResolve?.(false);
 			const removedKeys = this.findKeysRemovedBy(configBundle);
@@ -8067,16 +8202,20 @@ var DefaultConfigDirectorClient = class {
 				})]);
 				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}`);
-			}
+			if (!this.ready) this.logger.warn(`[ConfigDirectorClient] Timed out waiting for initialization after ${this.timeout}ms. ${this.timeoutWarningDetails()}`);
 		} catch (error) {
+			if (error instanceof ConfigDirectorInitializationError) throw error;
 			this.logger.error("[ConfigDirectorClient] An error occurred during initialization: ", error);
 		}
 	}
-	resolvePollingIntervalForMode(configuredSeconds) {
-		if (this.connectionMode !== "polling") return;
+	timeoutWarningDetails() {
+		switch (this.connectionPlan.kind) {
+			case "connect": return liveTimeoutWarningDetails[this.connectionPlan.mode];
+			case "stay-offline": return "The offline values were not delivered, so configs return the default value.";
+		}
+	}
+	pollingIntervalFor(mode, configuredSeconds) {
+		if (mode !== "polling") return;
 		const resolved = resolvePollingInterval(configuredSeconds, {
 			defaultSeconds: 300,
 			minimumSeconds: 60
@@ -8084,38 +8223,48 @@ var DefaultConfigDirectorClient = class {
 		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
-		});
+	buildTelemetryClient(sdkOptions, clientOptions) {
+		const plan = this.connectionPlan;
+		switch (plan.kind) {
+			case "stay-offline": return discardingTelemetryClient;
+			case "connect": {
+				const queueLimit = clientOptions?.telemetry?.eventQueueLimit ?? DEFAULT_EVENT_QUEUE_LIMIT;
+				return new ServerTelemetryEventCollector({
+					sdkKey: plan.serverSdkKey,
+					sdkIdentity: sdkOptions,
+					metaContext: clientOptions?.metadata ?? {},
+					logger: this.logger,
+					baseUrl: plan.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)
-		});
+	buildTransport(sdkOptions, clientOptions) {
+		const plan = this.connectionPlan;
+		switch (plan.kind) {
+			case "stay-offline": return new OfflineTransport(plan.source);
+			case "connect": return new (this.getTransportConstructor(plan.mode))({
+				serverSdkKey: plan.serverSdkKey,
+				baseUrl: plan.baseUrl,
+				metaContext: {
+					...clientOptions?.metadata,
+					sdkName: sdkOptions.sdkName,
+					sdkVersion: sdkOptions.sdkVersion
+				},
+				logger: this.logger,
+				pollingInterval: this.pollingIntervalFor(plan.mode, clientOptions?.connection?.pollingInterval)
+			});
+		}
 	}
 	getTransportConstructor(mode) {
 		switch (mode) {
 			case "polling": return PollingTransport;
-			default: return StreamingTransport;
+			case "streaming": return StreamingTransport;
 		}
 	}
 	findKeysRemovedBy(configBundle) {
@@ -8230,17 +8379,6 @@ var DefaultConfigDirectorClient = class {
 	dispatchEvaluationEvent(event) {
 		setTimeout(() => this.eventEmitter.emit("configEvaluated", { evaluation: event }), 0);
 	}
-	parseUrl(url) {
-		if (!url) return;
-		try {
-			return new URL(url);
-		} catch (error) {
-			throw new ConfigDirectorValidationError(`Invalid base URL '${url}'. Parsing failed: ${error}`);
-		}
-	}
-	validateSdkKeyPresence(sdkKey) {
-		if (!sdkKey || sdkKey.trim().length == 0) throw new ConfigDirectorValidationError("No server SDK key was provided, the client cannot be instantiated without a valid server SDK key");
-	}
 	validateDefaultValue(defaultValue) {
 		if (defaultValue === void 0 || defaultValue === null) throw new ConfigDirectorValidationError("Invalid default value. The default value for a config must be defined and non-null.");
 		if (typeof defaultValue === "function") throw new ConfigDirectorValidationError("Invalid default value. The default value for a config cannot be a function.");
@@ -8304,27 +8442,38 @@ const createDefaultLogger = (level) => {
 var plugin_default = defineNitroPlugin((nitroApp) => {
 	const runtimeConfig = useRuntimeConfig();
 	const logger = createDefaultLogger(runtimeConfig.configdirector?.logLevel);
-	if (!runtimeConfig.configdirector.serverSdkKey) {
+	const { serverSdkKey, baseUrl, connection } = runtimeConfig.configdirector;
+	const connectionMode = connection?.mode || "streaming";
+	if (connectionMode !== "offline" && !serverSdkKey) {
 		const message = "The ConfigDirector serverSdkKey must be configured for the plugin to initialize. You can provide it in nuxt.config.ts under 'runtimeConfig.configdirector.serverSdkKey' or as a runtime environment variable named NUXT_CONFIGDIRECTOR_SERVER_SDK_KEY";
 		logger.error(message);
 		throw new ConfigDirectorInitializationError(message);
 	}
 	logger.debug("Initializing ConfigDirector Nitro plugin");
-	const { serverSdkKey, baseUrl, connection } = runtimeConfig.configdirector;
-	const client = new DefaultConfigDirectorClient(serverSdkKey, {
+	const client = new DefaultConfigDirectorClient(serverSdkKey || void 0, {
 		sdkName: "nuxt-sdk",
-		sdkVersion: "1.10.0"
+		sdkVersion: "1.11.0"
 	}, {
 		logger,
 		connection: {
 			url: baseUrl || void 0,
-			mode: connection?.mode || void 0,
+			mode: connectionMode,
+			file: connection?.file || void 0,
+			values: connection?.values,
 			pollingInterval: connection?.pollingInterval || void 0,
 			timeout: connection?.timeout || void 0
 		}
 	});
+	const initialization = client.initialize();
+	initialization.catch((error) => {
+		logger.error("The ConfigDirector server client could not initialize, so every request fails:", error);
+	});
 	nitroApp.configDirectorClient = client;
-	nitroApp.configDirectorInitialization = client.initialize();
+	nitroApp.configDirectorConnectionMode = connectionMode;
+	nitroApp.configDirectorInitialization = initialization;
+	nitroApp.hooks.hook("request", (event) => {
+		useRuntimeConfig(event).public.configdirector.serverConnectionMode = connectionMode;
+	});
 });
 //#endregion
 export { plugin_default as default };