devflare 1.0.0-next.4 → 1.0.0-next.40

package/dist/_chunks/preview-BhqDmq8I.js

@@ -0,0 +1,456 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, resolve } from "pathe";
+//#region src/config/env-vars.ts
+const ENV_DESCRIPTOR_FLAG = "__devflareEnvDescriptor";
+function createDescriptor(state) {
+	return {
+		[ENV_DESCRIPTOR_FLAG]: true,
+		__state: state,
+		optional() {
+			return createDescriptor({
+				...state,
+				optional: true
+			});
+		},
+		parse(parser) {
+			return createDescriptor({
+				...state,
+				parser
+			});
+		},
+		parser(parser) {
+			return this.parse(parser);
+		},
+		default(value) {
+			return createDescriptor({
+				...state,
+				defaultValue: value,
+				hasDefault: true,
+				optional: false
+			});
+		},
+		dev(value) {
+			return createDescriptor({
+				...state,
+				devValue: value,
+				hasDevDefault: true
+			});
+		}
+	};
+}
+function createEnvVarDescriptor(name) {
+	return createDescriptor({
+		name,
+		optional: false,
+		hasDefault: false,
+		hasDevDefault: false
+	});
+}
+/**
+* Config-time environment variable descriptor factory.
+*
+* Accessing a property creates a descriptor for the exact environment variable
+* name, so `env.SECRET` reads `SECRET=...` from Devflare-loaded `.env` files or
+* from `process.env`.
+*
+* @example
+* ```ts
+* import { defineConfig, env } from 'devflare/config'
+*
+* export default defineConfig({
+*   vars: {
+*     secret: env.SECRET,
+*     mongo: {
+*       uri: env.MONGOURI,
+*       database: env.MONGODATABASE
+*     },
+*     retries: env.RETRIES.parse(Number)
+*   }
+* })
+* ```
+*/
+const env = new Proxy({}, { get(_target, prop) {
+	if (typeof prop !== "string") return;
+	return createEnvVarDescriptor(prop);
+} });
+/**
+* Return whether a value was created by the config-time {@link env} proxy.
+*
+* @example
+* ```ts
+* isEnvVarDescriptor(env.SECRET) // true
+* ```
+*/
+function isEnvVarDescriptor(value) {
+	return Boolean(value && typeof value === "object" && value[ENV_DESCRIPTOR_FLAG] === true);
+}
+function parseEnvValue(rawValue) {
+	const trimmed = rawValue.trim();
+	const quote = trimmed[0];
+	if ((quote === "\"" || quote === "'" || quote === "`") && trimmed.endsWith(quote) && trimmed.length >= 2) {
+		const inner = trimmed.slice(1, -1);
+		if (quote !== "\"") return inner;
+		return inner.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+	}
+	return trimmed;
+}
+/**
+* Parse `.env` file contents with Devflare's no-expansion rules.
+*
+* Devflare intentionally does not expand `$OTHER_VARIABLE` references, so
+* values are read as written instead of going through Bun's environment-file
+* parser.
+*
+* @example
+* ```ts
+* parseDevflareEnvFile('TOKEN=abc$123')
+* // { TOKEN: 'abc$123' }
+* ```
+*/
+function parseDevflareEnvFile(contents) {
+	const values = {};
+	for (const line of contents.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const assignment = trimmed.startsWith("export ") ? trimmed.slice(7).trimStart() : trimmed;
+		const equalsIndex = assignment.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		const key = assignment.slice(0, equalsIndex).trim();
+		if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+		values[key] = parseEnvValue(assignment.slice(equalsIndex + 1));
+	}
+	return values;
+}
+function collectAncestorDirectories(startDir) {
+	const directories = [];
+	let current = resolve(startDir);
+	while (true) {
+		directories.push(current);
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return directories.reverse();
+}
+/**
+* Return `.env.dev` and `.env` candidate paths from the filesystem root to a
+* project directory.
+*
+* Paths are ordered in the same precedence order as loading: parent files
+* first, then closer files, with `.env` after `.env.dev` for each directory.
+*
+* @example
+* ```ts
+* getDevflareDotenvPaths(process.cwd())
+* ```
+*/
+function getDevflareDotenvPaths(startDir) {
+	return collectAncestorDirectories(startDir).flatMap((directory) => [resolve(directory, ".env.dev"), resolve(directory, ".env")]);
+}
+/**
+* Load Devflare `.env.dev` and `.env` files without mutating `process.env`.
+*
+* Parent directories are loaded first, closer directories override them, and
+* `.env` overrides `.env.dev` within the same directory.
+*
+* @example
+* ```ts
+* const { values } = await loadDevflareDotenv(process.cwd())
+* ```
+*/
+async function loadDevflareDotenv(startDir) {
+	const values = {};
+	const files = [];
+	for (const filePath of getDevflareDotenvPaths(startDir)) {
+		if (!existsSync(filePath)) continue;
+		Object.assign(values, parseDevflareEnvFile(await readFile(filePath, "utf8")));
+		files.push(filePath);
+	}
+	return {
+		values,
+		files
+	};
+}
+/**
+* Load Devflare `.env` values into `process.env` without overwriting existing
+* process-level values.
+*
+* @example
+* ```ts
+* await loadDevflareDotenvIntoProcess(process.cwd())
+* ```
+*/
+async function loadDevflareDotenvIntoProcess(startDir) {
+	const loaded = await loadDevflareDotenv(startDir);
+	for (const [key, value] of Object.entries(loaded.values)) if (process.env[key] === void 0) process.env[key] = value;
+	return loaded;
+}
+function formatMissingEnvTree(missing) {
+	const root = {};
+	for (const item of missing) {
+		let current = root;
+		for (const segment of item.path.slice(0, -1)) {
+			const next = current[segment];
+			if (!next || typeof next !== "object") current[segment] = {};
+			current = current[segment];
+		}
+		current[item.path[item.path.length - 1] ?? item.name] = item.name;
+	}
+	const lines = [];
+	const writeNode = (node, depth) => {
+		const indent = "	".repeat(depth);
+		for (const [key, value] of Object.entries(node)) if (value && typeof value === "object") {
+			lines.push(`${indent}${key}:`);
+			writeNode(value, depth + 1);
+		} else lines.push(`${indent}${key}: ${String(value)}`);
+	};
+	writeNode(root, 1);
+	return lines.join("\n");
+}
+var EnvVarResolutionError = class extends Error {
+	code = "ENV_VARS_MISSING";
+	constructor(missing, mode) {
+		super([
+			"These environment variables are missing:",
+			"",
+			formatMissingEnvTree(missing)
+		].join("\n"));
+		this.missing = missing;
+		this.mode = mode;
+		this.name = "EnvVarResolutionError";
+	}
+};
+var EnvVarParseError = class extends Error {
+	code = "ENV_VAR_PARSE_FAILED";
+	constructor(variableName, path, cause) {
+		super(`Could not parse environment variable ${variableName} for vars.${path.join(".")}.\nParser error: ${cause instanceof Error ? cause.message : String(cause)}`);
+		this.variableName = variableName;
+		this.path = path;
+		this.name = "EnvVarParseError";
+	}
+};
+function isPlainObject(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value) || isEnvVarDescriptor(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+const OMIT_VALUE = Symbol("omit optional env var");
+function resolveDescriptorValue(descriptor, sources, path, mode, missing) {
+	const state = descriptor.__state;
+	const rawValue = sources[state.name];
+	if (rawValue !== void 0) try {
+		return state.parser ? state.parser(rawValue) : rawValue;
+	} catch (error) {
+		throw new EnvVarParseError(state.name, path, error);
+	}
+	if (mode === "dev" && state.hasDevDefault) return state.devValue;
+	if (state.hasDefault) return state.defaultValue;
+	if (state.optional) return OMIT_VALUE;
+	missing.push({
+		path,
+		name: state.name
+	});
+	return OMIT_VALUE;
+}
+function resolveVarValue(value, sources, path, mode, missing) {
+	if (isEnvVarDescriptor(value)) return resolveDescriptorValue(value, sources, path, mode, missing);
+	if (Array.isArray(value)) return value.map((item, index) => resolveVarValue(item, sources, [...path, String(index)], mode, missing)).filter((item) => item !== OMIT_VALUE);
+	if (isPlainObject(value)) {
+		const resolved = {};
+		for (const [key, childValue] of Object.entries(value)) {
+			const child = resolveVarValue(childValue, sources, [...path, key], mode, missing);
+			if (child !== OMIT_VALUE) resolved[key] = child;
+		}
+		return resolved;
+	}
+	return value;
+}
+function resolveVarsObject(vars, sources, mode, missing) {
+	if (!vars) return vars;
+	const resolved = resolveVarValue(vars, sources, [], mode, missing);
+	return resolved === OMIT_VALUE ? void 0 : resolved;
+}
+/**
+* Resolve all `env.NAME` descriptors under a config's `vars` object.
+*
+* @throws {EnvVarResolutionError} When required environment variables are missing.
+* @throws {EnvVarParseError} When a descriptor parser throws.
+*
+* @example
+* ```ts
+* const resolved = await resolveConfigEnvVars(config, {
+*   cwd: process.cwd(),
+*   mode: 'build'
+* })
+* ```
+*/
+async function resolveConfigEnvVars(config, options) {
+	const sources = {
+		...(await loadDevflareDotenv(options.configPath ? dirname(resolve(options.cwd, options.configPath)) : options.cwd)).values,
+		...process.env
+	};
+	const missing = [];
+	const vars = resolveVarsObject(config.vars, sources, options.mode, missing);
+	if (missing.length > 0) throw new EnvVarResolutionError(missing, options.mode);
+	return vars === config.vars ? config : {
+		...config,
+		vars
+	};
+}
+//#endregion
+//#region src/config/preview.ts
+const PREVIEW_SCOPED_NAME_PREFIX = "__DEVFLARE_PREVIEW_SCOPE__:";
+function getPreviewScopedSeparator(options) {
+	return options?.separator ?? "-";
+}
+function encodePreviewScopedName(value) {
+	return `${PREVIEW_SCOPED_NAME_PREFIX}${JSON.stringify(value)}`;
+}
+function invalidPreviewScopedName(reason) {
+	throw new Error(`Invalid Devflare preview-scoped value: ${reason}. Recreate it with preview.scope(...) instead of constructing preview markers manually.`);
+}
+function decodePreviewScopedName(value) {
+	const payload = value.slice(27);
+	let parsed;
+	try {
+		parsed = JSON.parse(payload);
+	} catch {
+		invalidPreviewScopedName("the encoded payload is not valid JSON");
+	}
+	const baseName = typeof parsed.baseName === "string" ? parsed.baseName : "";
+	if (!baseName.trim()) invalidPreviewScopedName("the encoded payload is missing a non-empty baseName");
+	return {
+		baseName,
+		separator: typeof parsed.separator === "string" && parsed.separator.length > 0 ? parsed.separator : "-"
+	};
+}
+function normalizePreviewFragment(rawValue) {
+	let normalized = rawValue.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+	if (!normalized) normalized = "preview";
+	if (!/^[a-z]/.test(normalized)) normalized = `b-${normalized}`;
+	return normalized;
+}
+function getPreviewIdentifierFromEnv(env) {
+	const explicitIdentifier = env.DEVFLARE_PREVIEW_IDENTIFIER?.trim();
+	if (explicitIdentifier) return {
+		identifier: normalizePreviewFragment(explicitIdentifier),
+		source: "env-identifier"
+	};
+	const previewPr = env.DEVFLARE_PREVIEW_PR?.trim();
+	if (previewPr) return {
+		identifier: normalizePreviewFragment(`pr-${previewPr}`),
+		source: "env-pr"
+	};
+	const previewBranch = env.DEVFLARE_PREVIEW_BRANCH?.trim();
+	if (previewBranch) return {
+		identifier: normalizePreviewFragment(previewBranch),
+		source: "env-branch"
+	};
+	return {
+		identifier: void 0,
+		source: "none"
+	};
+}
+function resolvePreviewIdentifier(options = {}) {
+	if (options.identifier?.trim()) return {
+		identifier: normalizePreviewFragment(options.identifier),
+		source: "identifier"
+	};
+	const envIdentifier = getPreviewIdentifierFromEnv(options.env ?? process.env);
+	if (envIdentifier.identifier) return envIdentifier;
+	return options.environment === "preview" ? {
+		identifier: "preview",
+		source: "environment"
+	} : {
+		identifier: void 0,
+		source: "none"
+	};
+}
+function mapRecordValues(record, mapper) {
+	return Object.fromEntries(Object.entries(record).map(([key, value]) => [key, mapper(value)]));
+}
+const preview = { scope(defaults = {}) {
+	return (baseName, options = {}) => {
+		if (!baseName.trim()) throw new Error("preview.scope(...) requires a non-empty baseName.");
+		return encodePreviewScopedName({
+			baseName,
+			separator: getPreviewScopedSeparator({
+				...defaults,
+				...options
+			})
+		});
+	};
+} };
+function isPreviewScopedName(value) {
+	return typeof value === "string" && value.startsWith(PREVIEW_SCOPED_NAME_PREFIX);
+}
+function materializePreviewScopedString(value, options = {}) {
+	if (!isPreviewScopedName(value)) return value;
+	const scoped = decodePreviewScopedName(value);
+	const previewIdentifier = resolvePreviewIdentifier(options).identifier;
+	return previewIdentifier ? `${scoped.baseName}${scoped.separator}${previewIdentifier}` : scoped.baseName;
+}
+function materializePreviewScopedConfig(config, options = {}) {
+	if (!config.bindings) return config;
+	const bindings = config.bindings;
+	const hasPreviewIdentifier = Boolean(resolvePreviewIdentifier(options).identifier);
+	return {
+		...config,
+		bindings: {
+			...bindings,
+			...bindings.kv ? { kv: mapRecordValues(bindings.kv, (binding) => {
+				return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+			}) } : {},
+			...bindings.d1 ? { d1: mapRecordValues(bindings.d1, (binding) => {
+				return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+			}) } : {},
+			...bindings.r2 ? { r2: mapRecordValues(bindings.r2, (binding) => {
+				return materializePreviewScopedString(binding, options);
+			}) } : {},
+			...bindings.queues ? { queues: {
+				...bindings.queues,
+				...bindings.queues.producers ? { producers: mapRecordValues(bindings.queues.producers, (queueName) => {
+					return materializePreviewScopedString(queueName, options);
+				}) } : {},
+				...bindings.queues.consumers ? { consumers: bindings.queues.consumers.map((consumer) => ({
+					...consumer,
+					queue: materializePreviewScopedString(consumer.queue, options),
+					...consumer.deadLetterQueue ? { deadLetterQueue: materializePreviewScopedString(consumer.deadLetterQueue, options) } : {}
+				})) } : {}
+			} } : {},
+			...bindings.services ? { services: mapRecordValues(bindings.services, (binding) => ({
+				...binding,
+				service: materializePreviewScopedString(binding.service, options)
+			})) } : {},
+			...bindings.vectorize ? { vectorize: mapRecordValues(bindings.vectorize, (binding) => ({
+				...binding,
+				indexName: materializePreviewScopedString(binding.indexName, options)
+			})) } : {},
+			...bindings.hyperdrive ? { hyperdrive: mapRecordValues(bindings.hyperdrive, (binding) => {
+				if (typeof binding === "string") return materializePreviewScopedString(binding, options);
+				if (binding && typeof binding === "object" && "name" in binding && typeof binding.name === "string") {
+					if (hasPreviewIdentifier && binding.previewId) return {
+						id: binding.previewId,
+						...binding.localConnectionString && { localConnectionString: binding.localConnectionString },
+						...!binding.localConnectionString && binding.previewLocalConnectionString && { localConnectionString: binding.previewLocalConnectionString }
+					};
+					return {
+						...binding,
+						name: materializePreviewScopedString(binding.name, options)
+					};
+				}
+				return binding;
+			}) } : {},
+			...bindings.browser ? { browser: mapRecordValues(bindings.browser, (binding) => {
+				return typeof binding === "string" ? materializePreviewScopedString(binding, options) : binding;
+			}) } : {},
+			...bindings.analyticsEngine ? { analyticsEngine: mapRecordValues(bindings.analyticsEngine, (binding) => ({
+				...binding,
+				dataset: materializePreviewScopedString(binding.dataset, options)
+			})) } : {}
+		}
+	};
+}
+//#endregion
+export { resolvePreviewIdentifier as a, getDevflareDotenvPaths as c, resolveConfigEnvVars as d, preview as i, isEnvVarDescriptor as l, materializePreviewScopedConfig as n, EnvVarResolutionError as o, materializePreviewScopedString as r, env as s, isPreviewScopedName as t, loadDevflareDotenvIntoProcess as u };