void 0.20.2 → 0.21.0

package/dist/sse-BaC1jXko.mjs

@@ -0,0 +1,172 @@
+//#region src/runtime/sse.ts
+const DEFAULT_KEEP_ALIVE_INTERVAL_MS = 15e3;
+const DEFAULT_KEEP_ALIVE_COMMENT = "keep-alive";
+var SseStreamClosedError = class extends Error {
+	constructor(message = "sse: stream is closed.") {
+		super(message);
+		this.name = "SseStreamClosedError";
+	}
+};
+function formatSse(message) {
+	const textMessage = {
+		event: message.event,
+		id: message.id,
+		retry: message.retry
+	};
+	if ("data" in message) textMessage.data = serializeData(message.data);
+	return formatSseText(textMessage);
+}
+function formatSseText(message) {
+	const lines = [];
+	if (message.id != null) {
+		assertControlField("id", message.id);
+		lines.push(`id: ${message.id}`);
+	}
+	if (message.event != null) {
+		assertControlField("event", message.event);
+		lines.push(`event: ${message.event}`);
+	}
+	if (message.retry != null) {
+		assertRetry(message.retry);
+		lines.push(`retry: ${message.retry}`);
+	}
+	if ("data" in message) {
+		if (typeof message.data !== "string") throw new Error("sse: data must be a string.");
+		for (const line of splitLines(message.data)) lines.push(`data: ${line}`);
+	}
+	return `${lines.join("\n")}\n\n`;
+}
+function getLastEventId(request) {
+	return request.headers.get("Last-Event-ID");
+}
+function eventStream(start, options = {}) {
+	const encoder = new TextEncoder();
+	const { readable, writable } = new TransformStream();
+	const writer = writable.getWriter();
+	const signalController = new AbortController();
+	const headers = buildSseHeaders(options.headers);
+	const keepAlive = normalizeKeepAlive(options.keepAlive);
+	let keepAliveTimer;
+	let closedOnce = false;
+	let closeResolve;
+	const closed = new Promise((resolve) => {
+		closeResolve = resolve;
+	});
+	const markClosed = () => {
+		if (closedOnce) return;
+		closedOnce = true;
+		if (!signalController.signal.aborted) signalController.abort();
+		if (keepAliveTimer != null) {
+			clearInterval(keepAliveTimer);
+			keepAliveTimer = void 0;
+		}
+		closeResolve();
+	};
+	async function close() {
+		if (closedOnce) return;
+		markClosed();
+		await writer.close().catch(() => {});
+	}
+	async function fail(error) {
+		if (closedOnce) return;
+		markClosed();
+		await writer.abort(error).catch(() => {});
+	}
+	async function write(text) {
+		if (closedOnce) throw new SseStreamClosedError();
+		try {
+			await writer.write(encoder.encode(text));
+		} catch {
+			await close();
+			throw new SseStreamClosedError();
+		}
+	}
+	const stream = {
+		signal: signalController.signal,
+		closed,
+		send(message) {
+			return write(formatSse(message));
+		},
+		comment(text = "") {
+			return write(formatComment(text));
+		},
+		close
+	};
+	writer.closed.catch(() => {
+		close();
+	});
+	if (options.signal?.aborted) close();
+	else options.signal?.addEventListener("abort", () => void close(), { once: true });
+	if (keepAlive) keepAliveTimer = setInterval(() => {
+		stream.comment(keepAlive.comment).catch(() => close());
+	}, keepAlive.intervalMs);
+	queueMicrotask(() => {
+		(async () => {
+			try {
+				await start(stream);
+				await close();
+			} catch (error) {
+				await fail(error);
+			}
+		})();
+	});
+	return new Response(readable, { headers });
+}
+function buildSseHeaders(headers) {
+	const result = new Headers(headers);
+	if (!result.has("Content-Type")) result.set("Content-Type", "text/event-stream; charset=utf-8");
+	if (!result.has("Cache-Control")) result.set("Cache-Control", "no-cache, no-transform");
+	if (!result.has("X-Accel-Buffering")) result.set("X-Accel-Buffering", "no");
+	return result;
+}
+function normalizeKeepAlive(keepAlive) {
+	if (keepAlive === false) return null;
+	if (keepAlive === true || keepAlive == null) return {
+		intervalMs: DEFAULT_KEEP_ALIVE_INTERVAL_MS,
+		comment: DEFAULT_KEEP_ALIVE_COMMENT
+	};
+	const intervalMs = keepAlive.intervalMs ?? DEFAULT_KEEP_ALIVE_INTERVAL_MS;
+	if (!Number.isFinite(intervalMs) || intervalMs <= 0) throw new Error("sse: keepAlive.intervalMs must be a positive finite number.");
+	return {
+		intervalMs,
+		comment: keepAlive.comment ?? DEFAULT_KEEP_ALIVE_COMMENT
+	};
+}
+function formatComment(text) {
+	if (typeof text !== "string") throw new Error("sse: comment text must be a string.");
+	return `${splitLines(text).map((line) => `: ${line}`).join("\n")}\n\n`;
+}
+function assertControlField(name, value) {
+	if (typeof value !== "string") throw new Error(`sse: ${name} must be a string.`);
+	if (hasControlFieldSeparator(value)) throw new Error(`sse: ${name} must not contain CR, LF, or NUL characters.`);
+}
+function hasControlFieldSeparator(value) {
+	return value.includes("\r") || value.includes("\n") || value.includes("\0");
+}
+function assertRetry(value) {
+	if (!Number.isInteger(value) || value < 0) throw new Error("sse: retry must be a non-negative integer.");
+}
+function isBinaryData(data) {
+	return data instanceof ArrayBuffer || ArrayBuffer.isView(data) || typeof Blob !== "undefined" && data instanceof Blob || typeof File !== "undefined" && data instanceof File;
+}
+function serializeData(data) {
+	if (typeof data === "string") return data;
+	if (data == null) return data === null ? "null" : throwDataSerializationError(data);
+	if (typeof data === "function" || typeof data === "symbol") return throwDataSerializationError(data);
+	if (isBinaryData(data)) throw new Error("sse: binary data is not supported.");
+	try {
+		const serialized = JSON.stringify(data);
+		if (typeof serialized !== "string") return throwDataSerializationError(data);
+		return serialized;
+	} catch (error) {
+		throw new Error(`sse: data must be JSON-serializable. ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+function throwDataSerializationError(data) {
+	throw new Error(`sse: unsupported data value ${String(data)}.`);
+}
+function splitLines(value) {
+	return value.split(/\r\n|\r|\n/);
+}
+//#endregion
+export { getLastEventId as a, formatSseText as i, eventStream as n, formatSse as r, SseStreamClosedError as t };

package/dist/{subcommand-prompt-Bmyn5Rlc.mjs → subcommand-prompt-Gj3VzLIh.mjs}

@@ -1,4 +1,5 @@
-import { S as S_STEP_SUBMIT, _ as S_CHECKBOX_INACTIVE, b as S_RADIO_INACTIVE, c as import_picocolors, g as S_CHECKBOX_ACTIVE, h as S_BAR_END, m as S_BAR, x as S_STEP_ACTIVE, y as S_RADIO_ACTIVE, z as wrapAnsi } from "./output-B0cfNSx5.mjs";
+import { c as import_picocolors } from "./output-urU86XeT.mjs";
+import { S as S_STEP_SUBMIT, _ as S_RADIO_ACTIVE, c as S_CHECKBOX_INACTIVE, i as S_BAR_END, q as wrapAnsi, r as S_BAR, s as S_CHECKBOX_ACTIVE, v as S_RADIO_INACTIVE, y as S_STEP_ACTIVE } from "./dist-Dn6nn2IU.mjs";
 //#region src/cli/subcommand-prompt.ts
 function promptSubcommand(command, subcommands) {
 	return new Promise((resolve) => {

package/dist/sveltekit.d.mts

@@ -9,7 +9,8 @@ export type VoidSvelteKitTsconfigOptions = {
 };
 /**
  * Merge Void's generated tsconfig fragment into SvelteKit's generated
- * tsconfig. Use from `kit.typescript.config` in `svelte.config.js`.
+ * tsconfig. Use from `typescript.config` in `sveltekit()` or from
+ * `kit.typescript.config` in `svelte.config.js`.
  */
 export declare function mergeVoidSvelteKitTsconfig(config: Tsconfig, options?: VoidSvelteKitTsconfigOptions): Tsconfig;
 /**

package/dist/sveltekit.mjs

@@ -1,9 +1,10 @@
-import { a as isAbsolute, c as relative, l as resolve, o as join } from "./dist-BrsS7cai.mjs";
+import { a as join, i as isAbsolute, l as relative, u as resolve } from "./dist-4WkAWhWx.mjs";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/sveltekit.ts
 /**
 * Merge Void's generated tsconfig fragment into SvelteKit's generated
-* tsconfig. Use from `kit.typescript.config` in `svelte.config.js`.
+* tsconfig. Use from `typescript.config` in `sveltekit()` or from
+* `kit.typescript.config` in `svelte.config.js`.
 */
 function mergeVoidSvelteKitTsconfig(config, options = {}) {
 	const root = options.root ?? process.cwd();

package/dist/validate-DqJ33oHj.mjs

@@ -0,0 +1,2 @@
+import { i as validateMigrations } from "./validate-qNhV00PD.mjs";
+export { validateMigrations };

package/dist/validate-qNhV00PD.mjs

@@ -0,0 +1,180 @@
+import { a as join } from "./dist-4WkAWhWx.mjs";
+import { n as readJournal, r as stripSqlExt } from "./collect-DXHNWHcT.mjs";
+import { t as DESTRUCTIVE_PRAGMA, u as tokenizeSql } from "./plan-BEZ8VJW0.mjs";
+import { existsSync, readdirSync } from "node:fs";
+//#region src/migrations/validate.ts
+/**
+* Destructive SQL patterns that are rejected unless the migration
+* contains the `-- void:allow-destructive` pragma comment.
+*/
+const DESTRUCTIVE_PATTERNS = [
+	/\bDROP\s+TABLE\b/i,
+	/\bDROP\s+VIEW\b/i,
+	/\bDROP\s+INDEX\b/i,
+	/\bDROP\s+TRIGGER\b/i,
+	/\bALTER\s+TABLE\b[\s\S]*\bDROP\s+COLUMN\b/i,
+	/\bALTER\s+TABLE\b[\s\S]*\bRENAME\s+TO\b/i,
+	/\bALTER\s+TABLE\b[\s\S]*\bRENAME\s+COLUMN\b/i,
+	/\bALTER\s+TABLE\b[\s\S]*\bRENAME\b[\s\S]*\bTO\b/i,
+	/\bTRUNCATE\b/i,
+	/\bINSERT\s+OR\s+REPLACE\b/i
+];
+function splitExecutableStatements(sql) {
+	return sql.split(";").map((statement) => statement.trim()).filter(Boolean);
+}
+function hasTopLevelKeyword(statement, keyword) {
+	let depth = 0;
+	for (let index = 0; index < statement.length; index++) {
+		const character = statement[index];
+		if (character === "(") {
+			depth++;
+			continue;
+		}
+		if (character === ")") {
+			depth = Math.max(0, depth - 1);
+			continue;
+		}
+		if (depth !== 0) continue;
+		if (statement.slice(index, index + keyword.length).toUpperCase() === keyword && !/[A-Z0-9_]/i.test(statement[index - 1] ?? "") && !/[A-Z0-9_]/i.test(statement[index + keyword.length] ?? "")) return true;
+	}
+	return false;
+}
+function hasUnboundedWrite(statement) {
+	if (/^(?:CREATE\s+(?:(?:TEMP|TEMPORARY|UNLOGGED)\s+)?|ALTER\s+)TABLE\b/i.test(statement)) return false;
+	if (/\bDELETE\s+FROM\b/i.test(statement)) return !hasTopLevelKeyword(statement, "WHERE");
+	if (/\bUPDATE\b[\s\S]*\bSET\b/i.test(statement)) return !hasTopLevelKeyword(statement, "WHERE");
+	return false;
+}
+/**
+* Check if a SQL migration contains destructive operations.
+*/
+function isDestructive(sql) {
+	const normalized = sql.replace(/\r\n?/g, "\n");
+	let executable = "";
+	for (const segment of tokenizeSql(normalized)) if (segment.kind === "sql") executable += normalized.slice(segment.start, segment.end);
+	else executable += " ".repeat(segment.end - segment.start);
+	return splitExecutableStatements(executable).some((statement) => {
+		return DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(statement)) || hasUnboundedWrite(statement);
+	});
+}
+function hasDestructivePragma(sql) {
+	return sql.replace(/\r\n?/g, "\n").split("\n").some((line) => line.trim() === DESTRUCTIVE_PRAGMA);
+}
+/**
+* Validate migration files. Returns the validated list with destructive flags.
+* Throws if any destructive migration lacks the allow-destructive pragma.
+*/
+function validateMigrations(files) {
+	const results = [];
+	const errors = [];
+	for (const file of files) {
+		const destructive = isDestructive(file.sql);
+		if (destructive && !hasDestructivePragma(file.sql)) errors.push(file.name);
+		results.push({
+			name: file.name,
+			sql: file.sql,
+			destructive
+		});
+	}
+	if (errors.length > 0) throw new Error(`Destructive migrations detected without pragma:\n` + errors.map((f) => `  - ${f}`).join("\n") + `\n\nAdd "${DESTRUCTIVE_PRAGMA}" to each file to allow the migration locally and on deploy.`);
+	return results;
+}
+/**
+* Enumerate drizzle-kit metadata artifacts in a migrations directory.
+* Returns repo-relative paths like `db/migrations/meta/0000_snapshot.json`
+* and `db/migrations/migrations.js`. Empty when none are present.
+*
+* Shared across `assertJournalCoherence`, `void gen migration`, and
+* `void db rename-migrations` so all three agree on what counts as a
+* "partial drizzle-kit state" (journal gone but other metadata lingering).
+*/
+function listDrizzleArtifacts(migrationsDir) {
+	const metaDir = join(migrationsDir, "meta");
+	const snapshotFiles = existsSync(metaDir) ? readdirSync(metaDir).filter((f) => f.endsWith("_snapshot.json")) : [];
+	const bundledPath = join(migrationsDir, "migrations.js");
+	const out = [];
+	for (const f of snapshotFiles) out.push(`db/migrations/meta/${f}`);
+	if (existsSync(bundledPath)) out.push("db/migrations/migrations.js");
+	return out;
+}
+/**
+* Assert that every `.sql` file under `migrationsDir` has a matching entry
+* in `meta/_journal.json`, and vice versa.
+*
+* Drift is a silent footgun: the local/remote runners apply files directly
+* from disk, but `drizzle-kit generate` only sees what's in the journal.
+* An orphan file created by hand (or by a botched scaffold/merge) gets
+* applied to D1 without Drizzle ever acknowledging it, and a failed
+* deploy can leave the database in a state that is impossible to recover
+* from without manual SQL edits.
+*
+* A missing journal is NOT a drift error. The drift check is a diff
+* between disk and `meta/_journal.json`; with no journal, there is nothing
+* to diff against. Bare-legacy projects — hand-written `.sql` files with no
+* `db/schema.ts`, no drizzle-kit, no `meta/` directory — worked long
+* before this check existed, and the local/remote runners still track
+* applied migrations by filename via `_void_migrations`. Gating those
+* projects here would break `void deploy`, `void db migrate`, `void db
+* reset`, and `void db status` for a valid path with no migration path
+* forward (they cannot run `void db generate` because it requires
+* `db/schema.ts`). We skip the check silently and let the filename-based
+* runners take over.
+*
+* Throws a user-facing error when any mismatch is detected between the
+* journal and disk. Returns silently otherwise.
+*/
+function assertJournalCoherence(migrationsDir, collected) {
+	const journal = readJournal(migrationsDir);
+	const drizzleArtifacts = listDrizzleArtifacts(migrationsDir);
+	if (journal === void 0) {
+		if (drizzleArtifacts.length > 0) throw new Error([
+			"db/migrations/meta/_journal.json is missing, but other drizzle-kit metadata is still present:",
+			...drizzleArtifacts.map((p) => `  - ${p}`),
+			"",
+			"This is a partial drizzle-kit state. Restore _journal.json from version control, or delete the orphaned metadata files above if you intended to revert to hand-written migrations."
+		].join("\n"));
+		return;
+	}
+	if (journal === null || typeof journal !== "object" || Array.isArray(journal) || typeof journal.version !== "string" || typeof journal.dialect !== "string" || !Array.isArray(journal.entries)) throw new Error("db/migrations/meta/_journal.json is malformed: expected an object with string `version`, string `dialect`, and an `entries` array. Restore the file from version control, or delete it if you intended to revert to hand-written migrations.");
+	for (let i = 0; i < journal.entries.length; i++) {
+		const entry = journal.entries[i];
+		if (entry === null || typeof entry !== "object" || typeof entry.idx !== "number" || typeof entry.version !== "string" || typeof entry.tag !== "string" || typeof entry.breakpoints !== "boolean") throw new Error(`db/migrations/meta/_journal.json is malformed: entry at index ${i} is missing required fields (\`idx\`, \`version\`, \`tag\`, \`breakpoints\`). Restore the file from version control, or delete it if you intended to revert to hand-written migrations.`);
+	}
+	if (journal.entries.length === 0) {
+		if (drizzleArtifacts.length === 0) return;
+		throw new Error([
+			"db/migrations/meta/_journal.json has no entries, but drizzle-kit metadata is still present:",
+			...drizzleArtifacts.map((p) => `  - ${p}`),
+			"",
+			"This is a partial drizzle-kit state. Restore _journal.json from version control (or run `void db generate`), or delete the orphaned metadata files above if you intended to revert to hand-written migrations."
+		].join("\n"));
+	}
+	const tagCounts = /* @__PURE__ */ new Map();
+	for (const entry of journal.entries) tagCounts.set(entry.tag, (tagCounts.get(entry.tag) ?? 0) + 1);
+	const duplicateTags = [...tagCounts.entries()].filter(([, n]) => n > 1).map(([tag]) => tag);
+	if (duplicateTags.length > 0) throw new Error([
+		"db/migrations/meta/_journal.json has duplicate migration entries:",
+		...duplicateTags.map((t) => `  - ${t} (appears ${tagCounts.get(t)} times)`),
+		"",
+		"Each migration must have a unique tag. Restore _journal.json from version control, or hand-edit to remove the duplicates."
+	].join("\n"));
+	const journalTags = new Set(journal.entries.map((e) => e.tag));
+	const collectedTags = new Set(collected.map((m) => stripSqlExt(m.name)));
+	const orphans = collected.map((m) => m.name).filter((name) => !journalTags.has(stripSqlExt(name)));
+	const missing = journal.entries.map((e) => `${e.tag}.sql`).filter((file) => !collectedTags.has(stripSqlExt(file)));
+	if (orphans.length === 0 && missing.length === 0) return;
+	const lines = ["Migration drift detected between db/migrations/ and db/migrations/meta/_journal.json."];
+	if (orphans.length > 0) {
+		lines.push("", "These files exist on disk but are not tracked in _journal.json:");
+		for (const f of orphans) lines.push(`  - db/migrations/${f}`);
+		lines.push("", "Delete the orphan file(s), or move their contents into `db/schema.ts` and re-run `void db generate`.");
+	}
+	if (missing.length > 0) {
+		lines.push("", "These entries are in _journal.json but the matching file is missing:");
+		for (const f of missing) lines.push(`  - db/migrations/${f}`);
+		lines.push("", "Restore the missing file(s) from version control, or regenerate migrations.");
+	}
+	throw new Error(lines.join("\n"));
+}
+//#endregion
+export { validateMigrations as i, isDestructive as n, listDrizzleArtifacts as r, assertJournalCoherence as t };

package/dist/validator-BTOu0fB0.mjs

@@ -0,0 +1,72 @@
+//#region src/runtime/validator.ts
+function flattenIssues(issues) {
+	return Array.from(issues, (issue) => ({
+		message: issue.message,
+		path: issue.path?.map((p) => typeof p === "object" ? p.key : p).join(".")
+	}));
+}
+async function validateSlot(schema, value) {
+	const result = await schema["~standard"].validate(value);
+	if (result.issues) return {
+		ok: false,
+		issues: result.issues
+	};
+	return {
+		ok: true,
+		value: result.value
+	};
+}
+async function runValidation(validators, c) {
+	const input = {};
+	const allIssues = [];
+	if (validators.params) {
+		const raw = c.req.param();
+		const result = await validateSlot(validators.params, raw);
+		if (result.ok) input.params = result.value;
+		else allIssues.push({
+			slot: "params",
+			issues: flattenIssues(result.issues)
+		});
+	}
+	if (validators.query) {
+		const url = new URL(c.req.url);
+		const raw = {};
+		for (const [key, value] of url.searchParams) raw[key] = value;
+		const result = await validateSlot(validators.query, raw);
+		if (result.ok) input.query = result.value;
+		else allIssues.push({
+			slot: "query",
+			issues: flattenIssues(result.issues)
+		});
+	}
+	if (validators.body) {
+		let raw;
+		try {
+			raw = await c.req.json();
+		} catch {
+			return {
+				ok: false,
+				response: Response.json({ error: "Invalid JSON body" }, { status: 400 })
+			};
+		}
+		const result = await validateSlot(validators.body, raw);
+		if (result.ok) input.body = result.value;
+		else allIssues.push({
+			slot: "body",
+			issues: flattenIssues(result.issues)
+		});
+	}
+	if (allIssues.length > 0) return {
+		ok: false,
+		response: Response.json({
+			error: "Validation failed",
+			issues: allIssues
+		}, { status: 400 })
+	};
+	return {
+		ok: true,
+		input
+	};
+}
+//#endregion
+export { runValidation as t };