void 0.20.3 → 0.21.1

package/dist/cf-build-output-CTdlo6Rt.mjs

@@ -0,0 +1,520 @@
+import { a as join, i as isAbsolute, l as relative, n as dirname, r as extname, t as basename, u as resolve } from "./dist-4WkAWhWx.mjs";
+import { copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { tmpdir } from "node:os";
+import { spawnSync } from "node:child_process";
+import { isDeepStrictEqual } from "node:util";
+import { build } from "vite";
+import { getWorkerBundleDir, normalizeDirectoryName, readBuildOutput, writeAssets, writeContainerConfig, writeRootConfig, writeWorkerConfig } from "@cloudflare/build-output-utils";
+import { InputConfigSchema, OutputContainerSchema } from "@cloudflare/config";
+import ignore from "ignore";
+//#region src/cli/cf-config-migrate.ts
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function empty(value) {
+	return value === void 0 || value === null || Array.isArray(value) && value.length === 0 || record(value) !== null && Object.keys(value).length === 0;
+}
+/** Remove build-only fields and settings translated into cf's typed config below. */
+function migrationInput(raw) {
+	const result = { ...raw };
+	if (!empty(result.rules) && !isDeepStrictEqual(result.rules, [{
+		type: "ESModule",
+		globs: ["**/*.js", "**/*.mjs"]
+	}])) throw new Error("cf cannot yet preserve custom Worker module rules in a prebuilt bundle.");
+	if (empty(result.logfwdr) || isDeepStrictEqual(result.logfwdr, { bindings: [] })) delete result.logfwdr;
+	for (const key of [
+		"configPath",
+		"userConfigPath",
+		"topLevelName",
+		"main",
+		"jsx_factory",
+		"jsx_fragment",
+		"rules",
+		"python_modules",
+		"dev",
+		"no_bundle",
+		"build",
+		"keep_vars",
+		"keep_secrets",
+		"keep_assets",
+		"send_metrics",
+		"workflows"
+	]) delete result[key];
+	for (const [key, value] of Object.entries(result)) if (empty(value)) delete result[key];
+	return result;
+}
+function applyPreservationFlags(raw, worker) {
+	const keepBindings = [...raw.keep_vars === true ? ["plain_text", "json"] : [], ...raw.keep_secrets === true ? ["secret_text", "secret_key"] : []];
+	if (keepBindings.length === 0 && raw.keep_assets !== true) return;
+	const unsafe = record(worker.unsafe) ?? {};
+	const metadata = record(unsafe.metadata) ?? {};
+	const previous = metadata.keep_bindings;
+	if (previous !== void 0 && (!Array.isArray(previous) || !previous.every((value) => typeof value === "string"))) throw new Error("Invalid keep_bindings in the built Cloudflare config.");
+	worker.unsafe = {
+		...unsafe,
+		metadata: {
+			...metadata,
+			...keepBindings.length > 0 ? { keep_bindings: [.../* @__PURE__ */ new Set([...previous ?? [], ...keepBindings])] } : {},
+			...raw.keep_assets === true ? { keep_assets: true } : {}
+		}
+	};
+}
+function applyWorkflows(raw, worker) {
+	if (raw.workflows === void 0 || empty(raw.workflows)) return;
+	if (!Array.isArray(raw.workflows)) throw new Error("Invalid Workflow bindings in the built Cloudflare config.");
+	const env = record(worker.env) ?? {};
+	const exports = record(worker.exports) ?? {};
+	for (const item of raw.workflows) {
+		const workflow = record(item);
+		if (!workflow || typeof workflow.binding !== "string" || typeof workflow.name !== "string" || typeof workflow.class_name !== "string" || workflow.script_name !== void 0 && typeof workflow.script_name !== "string") throw new Error("Invalid Workflow binding in the built Cloudflare config.");
+		const allowed = /* @__PURE__ */ new Set([
+			"binding",
+			"name",
+			"class_name",
+			"script_name",
+			"limits",
+			"concurrency",
+			"schedules",
+			"default_retention"
+		]);
+		for (const key of Object.keys(workflow)) if (!allowed.has(key)) throw new Error(`cf cannot migrate Workflow setting ${key}.`);
+		if (Object.hasOwn(env, workflow.binding)) throw new Error(`Duplicate Worker binding ${workflow.binding}.`);
+		env[workflow.binding] = {
+			type: "workflow",
+			name: workflow.name,
+			worker: workflow.script_name ?? worker.name,
+			exportName: workflow.class_name
+		};
+		if (workflow.script_name !== void 0 && workflow.script_name !== worker.name) continue;
+		const retention = record(workflow.default_retention);
+		if (Object.hasOwn(exports, workflow.class_name)) throw new Error(`Duplicate Worker export ${workflow.class_name}.`);
+		const schedules = Array.isArray(workflow.schedules) && workflow.schedules.length === 0 ? void 0 : workflow.schedules;
+		exports[workflow.class_name] = {
+			type: "workflow",
+			name: workflow.name,
+			...workflow.limits !== void 0 ? { limits: workflow.limits } : {},
+			...workflow.concurrency !== void 0 ? { concurrency: workflow.concurrency } : {},
+			...schedules !== void 0 ? { schedules } : {},
+			...retention ? { defaultRetention: {
+				...retention.success_retention !== void 0 ? { successRetention: retention.success_retention } : {},
+				...retention.error_retention !== void 0 ? { errorRetention: retention.error_retention } : {}
+			} } : {}
+		};
+	}
+	worker.env = env;
+	worker.exports = exports;
+}
+function uncredentialedEnvironment() {
+	const env = { ...process.env };
+	for (const key of Object.keys(env)) if (/^(?:CLOUDFLARE|CF_|WRANGLER|VOID_PLATFORM_|DATABASE_URL|VOID_ACCESS_)/i.test(key)) delete env[key];
+	env.CF_DELEGATION = "1";
+	return env;
+}
+function migrationFollowUps(output) {
+	return [...output.matchAll(/\[required\] ([^:\n]+): ([^\n]+)/g)].map((match) => ({
+		path: match[1],
+		message: match[2]
+	}));
+}
+function assertHandledFollowUps(output) {
+	for (const item of migrationFollowUps(output)) if (!(item.path === "assets.directory" && item.message.includes("assets directory") || /^d1_databases\.\d+$/.test(item.path) && /`migrations_(?:dir|table)`/.test(item.message) || /^durable_objects\.bindings\.\d+$/.test(item.path) || item.path === "migrations" || item.path === "containers")) throw new Error(`cf cannot migrate Cloudflare setting ${item.path}: ${item.message}`);
+}
+function durableObjectExports(raw) {
+	const migrations = raw.migrations;
+	if (migrations === void 0 || Array.isArray(migrations) && migrations.length === 0) return {};
+	if (!Array.isArray(migrations) || !migrations.every((entry) => record(entry))) throw new Error("Invalid Durable Object migrations in the built Cloudflare config.");
+	const exports = {};
+	for (const migration of migrations) {
+		const known = /* @__PURE__ */ new Set([
+			"tag",
+			"new_classes",
+			"new_sqlite_classes",
+			"renamed_classes",
+			"deleted_classes"
+		]);
+		for (const key of Object.keys(migration)) if (!known.has(key)) throw new Error(`cf cannot migrate Durable Object migration setting ${key}.`);
+		for (const [field, storage] of [["new_classes", "legacy-kv"], ["new_sqlite_classes", "sqlite"]]) {
+			const classes = migration[field] ?? [];
+			if (!Array.isArray(classes) || !classes.every((name) => typeof name === "string")) throw new Error(`Invalid ${field} in the built Cloudflare config.`);
+			for (const name of classes) exports[name] = {
+				type: "durable-object",
+				storage
+			};
+		}
+		const renamed = migration.renamed_classes ?? [];
+		if (!Array.isArray(renamed) || !renamed.every((entry) => record(entry))) throw new Error("Invalid renamed_classes in the built Cloudflare config.");
+		for (const item of renamed) {
+			if (typeof item.from !== "string" || typeof item.to !== "string") throw new Error("Invalid Durable Object class rename in the built Cloudflare config.");
+			const old = record(exports[item.from]);
+			if (!old || old.storage !== "sqlite" && old.storage !== "legacy-kv") throw new Error(`Cannot determine the storage of renamed Durable Object ${item.from}.`);
+			exports[item.from] = {
+				type: "durable-object",
+				state: "renamed",
+				renamedTo: item.to
+			};
+			exports[item.to] = {
+				type: "durable-object",
+				storage: old.storage
+			};
+		}
+		const deleted = migration.deleted_classes ?? [];
+		if (!Array.isArray(deleted) || !deleted.every((name) => typeof name === "string")) throw new Error("Invalid deleted_classes in the built Cloudflare config.");
+		for (const name of deleted) exports[name] = {
+			type: "durable-object",
+			state: "deleted"
+		};
+	}
+	return exports;
+}
+function containersFromWrangler(raw, exports) {
+	const values = raw.containers;
+	if (values === void 0) return [];
+	if (!Array.isArray(values) || !values.every((value) => record(value))) throw new Error("Invalid Containers in the built Cloudflare config.");
+	return values.map((value) => {
+		if (typeof value.name !== "string" || typeof value.class_name !== "string" || typeof value.image !== "string") throw new Error("cf requires a name, class_name and image for each Container.");
+		const fields = /* @__PURE__ */ new Set([
+			"name",
+			"class_name",
+			"image",
+			"max_instances",
+			"instance_type"
+		]);
+		for (const key of Object.keys(value)) if (!fields.has(key)) throw new Error(`cf cannot migrate Container setting ${key}.`);
+		const declaration = record(exports[value.class_name]);
+		if (!declaration || declaration.storage !== "sqlite") throw new Error(`Container ${value.name} needs a SQLite Durable Object export.`);
+		declaration.container = value.name;
+		return {
+			name: value.name,
+			schedulingPolicy: "durable-object",
+			images: { default: { reference: value.image } },
+			...typeof value.max_instances === "number" ? { maxInstances: value.max_instances } : {},
+			...typeof value.instance_type === "string" ? { instanceType: value.instance_type } : {}
+		};
+	});
+}
+/**
+* Ask the pinned cf CLI to translate the Vite plugin's generated JSON config.
+* Migration runs on a disposable copy without Cloudflare credentials; its
+* generated module is evaluated in a second uncredentialed Node process.
+*/
+function migrateBuiltWranglerConfig(raw) {
+	const cfPackage = fileURLToPath(import.meta.resolve("cf/package.json"));
+	const cfBinary = join(dirname(cfPackage), "bin", "cf");
+	const directory = mkdtempSync(join(tmpdir(), "void-cf-config-"));
+	try {
+		mkdirSync(join(directory, "node_modules"));
+		symlinkSync(dirname(cfPackage), join(directory, "node_modules", "cf"), "junction");
+		writeFileSync(join(directory, "package.json"), JSON.stringify({
+			name: "void-private-cf-build",
+			private: true,
+			type: "module",
+			dependencies: {
+				cf: "1.0.0",
+				"@cloudflare/vite-plugin": "1.0.0"
+			}
+		}), { mode: 384 });
+		const configPath = join(directory, "wrangler.json");
+		writeFileSync(configPath, JSON.stringify(migrationInput(raw)), { mode: 384 });
+		const env = uncredentialedEnvironment();
+		const migrated = spawnSync(process.execPath, [
+			cfBinary,
+			"migrate",
+			configPath,
+			"--bundler",
+			"vite",
+			"--no-install",
+			"--force"
+		], {
+			cwd: directory,
+			env,
+			encoding: "utf8",
+			timeout: 3e4,
+			maxBuffer: 4194304
+		});
+		const generatedPath = join(directory, "cloudflare.config.ts");
+		if (!existsSync(generatedPath) || migrated.error) throw new Error("cf could not translate the built Cloudflare configuration.");
+		assertHandledFollowUps(migrated.stdout);
+		const generated = readFileSync(generatedPath, "utf8");
+		const executable = generated.replace(/^throw new Error\("Migration incomplete\.[^\n]*\);\s*$/m, "");
+		if (executable === generated && migrated.status !== 0) throw new Error("cf did not provide a usable Cloudflare configuration.");
+		const executablePath = join(directory, "cloudflare.config.mjs");
+		writeFileSync(executablePath, executable, { mode: 384 });
+		const evaluated = spawnSync(process.execPath, [
+			"--input-type=module",
+			"-e",
+			"const mod = await import(process.argv[1]); process.stdout.write(JSON.stringify(mod.default));",
+			pathToFileURL(executablePath).href
+		], {
+			cwd: directory,
+			env,
+			encoding: "utf8",
+			timeout: 1e4,
+			maxBuffer: 4194304
+		});
+		if (evaluated.status !== 0 || evaluated.error) throw new Error("cf generated a configuration that Void could not validate.");
+		const result = record(JSON.parse(evaluated.stdout));
+		const worker = record(result?.worker);
+		if (!result || !worker) throw new Error("cf did not generate a Worker configuration.");
+		applyPreservationFlags(raw, worker);
+		applyWorkflows(raw, worker);
+		const exports = {
+			...record(worker.exports),
+			...durableObjectExports(raw)
+		};
+		const containers = containersFromWrangler(raw, exports);
+		if (containers.length > 0) {
+			const envBindings = record(worker.env);
+			const durableBindings = record(raw.durable_objects)?.bindings;
+			if (!envBindings || !Array.isArray(durableBindings)) throw new Error("A Container Durable Object binding was not found in the built config.");
+			for (const container of containers) {
+				const className = raw.containers.find((entry) => entry.name === container.name)?.class_name;
+				const binding = durableBindings.find((entry) => record(entry)?.class_name === className);
+				if (!record(binding) || typeof binding.name !== "string" || binding.script_name !== void 0 && binding.script_name !== worker.name) throw new Error(`Container ${container.name} must use a local Durable Object binding.`);
+				envBindings[binding.name] = {
+					type: "unsafe:durable_object_namespace",
+					class_name: className
+				};
+			}
+		}
+		if (Object.keys(exports).length > 0) worker.exports = exports;
+		if (containers.length > 0) result.containers = containers;
+		return InputConfigSchema.parse(result);
+	} finally {
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+//#region src/cli/cf-build-output.ts
+function object(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+const moduleTypes = {
+	".js": "esm",
+	".mjs": "esm",
+	".cjs": "cjs",
+	".wasm": "wasm",
+	".bin": "data",
+	".txt": "text",
+	".html": "text",
+	".sql": "text",
+	".json": "json",
+	".map": "sourcemap"
+};
+function copyBundle(source, destination) {
+	const modules = {};
+	for (const entry of readdirSync(source, {
+		recursive: true,
+		withFileTypes: true
+	})) {
+		if (!entry.isFile() && !entry.isSymbolicLink()) continue;
+		const absolute = join(entry.parentPath, entry.name);
+		if (entry.isSymbolicLink()) {
+			const target = realpathSync(absolute);
+			const targetRelative = relative(realpathSync(source), target).replace(/\\/g, "/");
+			if (!targetRelative || targetRelative === ".." || targetRelative.startsWith("../") || isAbsolute(targetRelative)) throw new Error("The built Worker contains a symlink outside its output directory.");
+		}
+		const name = relative(source, absolute);
+		if (name === "wrangler.json" || name === ".dev.vars" || name === join(".vite", "manifest.json") || name.endsWith(".css") || name.endsWith(".css.map")) continue;
+		const type = moduleTypes[extname(entry.name).toLowerCase()];
+		if (!type) return null;
+		const destinationPath = join(destination, name);
+		mkdirSync(dirname(destinationPath), { recursive: true });
+		if (entry.isSymbolicLink()) copyFileSync(realpathSync(absolute), destinationPath);
+		else cpSync(absolute, destinationPath);
+		modules[name] = { type };
+	}
+	return modules;
+}
+/** Create a private cf Build Output tree from Void's verified Vite artifact. */
+async function prepareCfBuildOutput(workerDirectory, accountId) {
+	const source = resolve(workerDirectory);
+	const raw = object(JSON.parse(readFileSync(join(source, "wrangler.json"), "utf8")));
+	if (!raw) return null;
+	if (typeof raw.account_id === "string" && raw.account_id !== accountId) return null;
+	const config = migrateBuiltWranglerConfig(raw);
+	if (!config.worker) throw new Error("cf did not produce a Worker configuration.");
+	const main = raw.main;
+	if (typeof main !== "string" || basename(main) !== main || !existsSync(join(source, main))) return null;
+	const assetsDirectory = object(raw.assets)?.directory;
+	if (assetsDirectory !== void 0 && typeof assetsDirectory !== "string") return null;
+	const directory = mkdtempSync(join(tmpdir(), "void-cf-deploy-"));
+	try {
+		const bundle = getWorkerBundleDir(directory);
+		mkdirSync(bundle, { recursive: true });
+		const modules = copyBundle(source, bundle);
+		if (!modules) {
+			rmSync(directory, {
+				recursive: true,
+				force: true
+			});
+			return null;
+		}
+		await writeRootConfig(directory, { accountId }, {
+			isPreview: false,
+			mode: "production"
+		});
+		await writeWorkerConfig({
+			root: directory,
+			config: config.worker,
+			manifest: {
+				type: "complete",
+				mainModule: main,
+				modules
+			}
+		});
+		for (const container of config.containers ?? []) await writeContainerConfig({
+			root: directory,
+			config: OutputContainerSchema.parse(container),
+			directoryName: normalizeDirectoryName(container.name)
+		});
+		if (typeof assetsDirectory === "string") {
+			const assetPath = resolve(source, assetsDirectory);
+			if (!existsSync(assetPath)) {
+				rmSync(directory, {
+					recursive: true,
+					force: true
+				});
+				return null;
+			}
+			await writeAssets({
+				root: directory,
+				sourceDirectory: assetPath
+			});
+		}
+		await readBuildOutput(directory);
+		return {
+			directory,
+			...typeof assetsDirectory === "string" ? { assetsDirectory: resolve(source, assetsDirectory) } : {},
+			dispose: () => rmSync(directory, {
+				recursive: true,
+				force: true
+			})
+		};
+	} catch (error) {
+		rmSync(directory, {
+			recursive: true,
+			force: true
+		});
+		throw error;
+	}
+}
+/** Bundle Void's generated thin static Worker before handing it to cf as prebuilt output. */
+async function prepareCfStaticBuildOutput(options) {
+	const raw = object(JSON.parse(readFileSync(options.configPath, "utf8")));
+	if (!raw || typeof raw.main !== "string" || basename(raw.main) !== raw.main) return null;
+	const entry = join(dirname(options.configPath), raw.main);
+	if (!existsSync(entry)) return null;
+	const scratch = mkdtempSync(join(tmpdir(), "void-cf-static-"));
+	try {
+		await build({
+			configFile: false,
+			root: options.projectRoot,
+			publicDir: false,
+			logLevel: "error",
+			build: {
+				outDir: scratch,
+				emptyOutDir: true,
+				lib: {
+					entry,
+					formats: ["es"],
+					fileName: "index"
+				},
+				target: "es2022"
+			}
+		});
+		writeFileSync(join(scratch, "wrangler.json"), JSON.stringify({
+			...raw,
+			main: "index.js",
+			assets: {
+				...object(raw.assets),
+				directory: resolve(options.assetsDirectory)
+			}
+		}), { mode: 384 });
+		return await prepareCfBuildOutput(scratch, options.accountId);
+	} finally {
+		rmSync(scratch, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+/** Bundle an adapter-produced Worker and copy only its public framework assets. */
+async function prepareCfFrameworkBuildOutput(options) {
+	const raw = object(JSON.parse(readFileSync(options.configPath, "utf8")));
+	const assets = object(raw?.assets);
+	if (!raw || typeof raw.main !== "string" || typeof assets?.directory !== "string") return null;
+	const configDirectory = dirname(options.configPath);
+	const entry = resolve(configDirectory, raw.main);
+	const sourceAssets = resolve(configDirectory, assets.directory);
+	if (!existsSync(entry) || !existsSync(sourceAssets)) return null;
+	const scratch = mkdtempSync(join(tmpdir(), "void-cf-framework-"));
+	const publicAssets = mkdtempSync(join(tmpdir(), "void-cf-framework-assets-"));
+	try {
+		const ignored = ignore();
+		const ignorePath = join(sourceAssets, ".assetsignore");
+		if (existsSync(ignorePath)) ignored.add(readFileSync(ignorePath, "utf8"));
+		const realAssets = realpathSync(sourceAssets);
+		for (const file of readdirSync(sourceAssets, {
+			recursive: true,
+			withFileTypes: true
+		})) {
+			if (file.isDirectory()) continue;
+			const absolute = join(file.parentPath, file.name);
+			const name = relative(sourceAssets, absolute).replaceAll("\\", "/");
+			if (name === ".assetsignore" || ignored.ignores(name)) continue;
+			const destination = join(publicAssets, name);
+			mkdirSync(dirname(destination), { recursive: true });
+			if (file.isSymbolicLink()) {
+				const target = realpathSync(absolute);
+				const targetRelative = relative(realAssets, target);
+				if (targetRelative === ".." || targetRelative.startsWith("../") || isAbsolute(targetRelative)) throw new Error("The framework assets contain a symlink outside the asset directory.");
+				copyFileSync(target, destination);
+			} else if (file.isFile()) copyFileSync(absolute, destination);
+		}
+		await build({
+			configFile: false,
+			root: options.projectRoot,
+			publicDir: false,
+			logLevel: "error",
+			build: {
+				outDir: scratch,
+				emptyOutDir: true,
+				lib: {
+					entry,
+					formats: ["es"],
+					fileName: "index"
+				},
+				rollupOptions: { external: [/^cloudflare:/, /^node:/] },
+				target: "es2022"
+			}
+		});
+		writeFileSync(join(scratch, "wrangler.json"), JSON.stringify({
+			...raw,
+			main: "index.js",
+			assets: {
+				...assets,
+				directory: publicAssets
+			}
+		}), { mode: 384 });
+		const prepared = await prepareCfBuildOutput(scratch, options.accountId);
+		return prepared ? {
+			...prepared,
+			assetsDirectory: sourceAssets
+		} : null;
+	} finally {
+		rmSync(scratch, {
+			recursive: true,
+			force: true
+		});
+		rmSync(publicAssets, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+//#endregion
+export { migrateBuiltWranglerConfig as i, prepareCfFrameworkBuildOutput as n, prepareCfStaticBuildOutput as r, prepareCfBuildOutput as t };

package/dist/cli/cf-compat.d.mts

@@ -0,0 +1 @@
+export {}