void 0.26.1 → 0.28.0

package/dist/{gen-DtkQhvQg.mjs → gen-CnN1Xidx.mjs}

@@ -1,18 +1,17 @@
-import { a as join, l as relative, n as dirname } from "./dist-BVqXeR_h.mjs";
-import { n as readProjectPaths } from "./project-paths-GgcMozYz.mjs";
-import { m as readConfig, u as getDatabaseDialect } from "./config-DiowPT80.mjs";
-import { n as readJournal, t as collectMigrations } from "./collect-DiTn9yr6.mjs";
+import { a as join, n as dirname, s as relative } from "./dist-ipQi0Q8y.mjs";
+import { n as readProjectPaths } from "./project-paths-DMvEeSau.mjs";
+import { d as readConfig, s as getDatabaseDialect } from "./config-Bx_1SpnO.mjs";
+import { n as readJournal, t as collectMigrations } from "./collect-xjffdCdk.mjs";
 import { K as select, L as log, O as cancel, tt as isCancel } from "./dist-D3m88sjf.mjs";
-import { d as printSuccess } from "./output-C50ag2r3.mjs";
-import { n as ensureProjectTsconfig } from "./project-tsconfig-CVJhNMxs.mjs";
-import { r as listDrizzleArtifacts, t as assertJournalCoherence } from "./validate-C9qJArv7.mjs";
-import { n as writeDrizzleConfig } from "./config-CLYAosnQ.mjs";
-import { t as buildDrizzleKitSpawnEnv } from "./yarn-pnp-CUX_iTPA.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
+import { m as printSuccess } from "./output-FNHKw5Ac.mjs";
+import { n as ensureProjectTsconfig } from "./project-tsconfig-bveqhlYA.mjs";
+import { r as writeDrizzleConfig, t as PLACEHOLDER_DB_URL } from "./config-BEm9vRvS.mjs";
+import { t as assertJournalCoherence } from "./validate-CheZGRE7.mjs";
+import { n as drizzleKitBin, t as buildDrizzleKitSpawnEnv } from "./yarn-pnp-DLbEFMT0.mjs";
+import { n as snapshotDrizzleOutputs } from "./generate-Dat0UTry.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
 //#region src/cli/gen.ts
-const drizzleKitBin = join(fileURLToPath(import.meta.resolve("drizzle-kit")), "..", "bin.cjs");
 async function runGenCommand(root, args) {
 	console.log();
 	if (args.subcommand === "model") await runModel(root, args.name, args.columns);
@@ -56,105 +55,59 @@ function getNextMiddlewareNumber(middlewareDir) {
 	}
 	return String(max + 1).padStart(2, "0");
 }
-function drizzleColumnDef(col) {
-	const { name, type } = col;
-	const notNull = col.nullable ? "" : ".notNull()";
-	switch (type) {
-		case "string":
-		case "text": return `  ${name}: text("${name}")${notNull},`;
-		case "integer": return `  ${name}: integer("${name}")${notNull},`;
-		case "boolean": return `  ${name}: integer("${name}", { mode: "boolean" })${notNull}.default(false),`;
-		case "real": return `  ${name}: real("${name}")${notNull},`;
-		default: return `  ${name}: text("${name}"),`;
-	}
-}
-function drizzleImportsForColumns(columns) {
-	const types = /* @__PURE__ */ new Set(["text", "integer"]);
-	for (const col of columns) switch (col.type) {
-		case "string":
-		case "text":
-			types.add("text");
-			break;
-		case "integer":
-			types.add("integer");
-			break;
-		case "boolean":
-			types.add("integer");
-			break;
-		case "real":
-			types.add("real");
-			break;
-		default: types.add("text");
+const TEXT_COLUMN = { fn: "text" };
+const COLUMN_BUILDERS = {
+	sqlite: {
+		string: TEXT_COLUMN,
+		text: TEXT_COLUMN,
+		integer: { fn: "integer" },
+		boolean: {
+			fn: "integer",
+			options: "{ mode: \"boolean\" }"
+		},
+		real: { fn: "real" }
+	},
+	postgresql: {
+		string: TEXT_COLUMN,
+		text: TEXT_COLUMN,
+		integer: { fn: "integer" },
+		boolean: { fn: "boolean" },
+		real: { fn: "doublePrecision" }
+	},
+	mysql: {
+		string: TEXT_COLUMN,
+		text: TEXT_COLUMN,
+		integer: { fn: "int" },
+		boolean: { fn: "boolean" },
+		real: { fn: "double" }
 	}
-	return [...types].sort();
-}
-function drizzleColumnDefPg(col) {
-	const { name, type } = col;
-	const notNull = col.nullable ? "" : ".notNull()";
-	switch (type) {
-		case "string":
-		case "text": return `  ${name}: text("${name}")${notNull},`;
-		case "integer": return `  ${name}: integer("${name}")${notNull},`;
-		case "boolean": return `  ${name}: boolean("${name}")${notNull}.default(false),`;
-		case "real": return `  ${name}: doublePrecision("${name}")${notNull},`;
-		default: return `  ${name}: text("${name}"),`;
-	}
-}
-function drizzleImportsForColumnsPg(columns) {
-	const types = /* @__PURE__ */ new Set([
+};
+const BASE_IMPORTS = {
+	sqlite: ["text", "integer"],
+	postgresql: [
 		"text",
 		"serial",
 		"timestamp"
-	]);
-	for (const col of columns) switch (col.type) {
-		case "string":
-		case "text":
-			types.add("text");
-			break;
-		case "integer":
-			types.add("integer");
-			break;
-		case "boolean":
-			types.add("boolean");
-			break;
-		case "real":
-			types.add("doublePrecision");
-			break;
-		default: types.add("text");
-	}
-	return [...types].sort();
-}
-function drizzleColumnDefMySql(col) {
-	const { name, type } = col;
-	const notNull = col.nullable ? "" : ".notNull()";
-	switch (type) {
-		case "string":
-		case "text": return `  ${name}: text("${name}")${notNull},`;
-		case "integer": return `  ${name}: int("${name}")${notNull},`;
-		case "boolean": return `  ${name}: boolean("${name}")${notNull}.default(false),`;
-		case "real": return `  ${name}: double("${name}")${notNull},`;
-		default: return `  ${name}: text("${name}"),`;
-	}
-}
-function drizzleImportsForColumnsMySql(columns) {
-	const types = /* @__PURE__ */ new Set([
+	],
+	mysql: [
 		"int",
 		"text",
 		"timestamp"
-	]);
-	for (const col of columns) switch (col.type) {
-		case "integer":
-			types.add("int");
-			break;
-		case "boolean":
-			types.add("boolean");
-			break;
-		case "real":
-			types.add("double");
-			break;
-		default: types.add("text");
-	}
-	return [...types].sort();
+	]
+};
+function drizzleColumnDef(dialect, col) {
+	const { name } = col;
+	const builder = COLUMN_BUILDERS[dialect][col.type];
+	if (!builder) return `  ${name}: text("${name}"),`;
+	const args = builder.options ? `"${name}", ${builder.options}` : `"${name}"`;
+	const notNull = col.nullable ? "" : ".notNull()";
+	const defaultValue = col.type === "boolean" ? ".default(false)" : "";
+	return `  ${name}: ${builder.fn}(${args})${notNull}${defaultValue},`;
+}
+function drizzleImportsForColumns(dialect, columns) {
+	const imports = new Set(BASE_IMPORTS[dialect]);
+	for (const col of columns) imports.add(COLUMN_BUILDERS[dialect][col.type]?.fn ?? "text");
+	return [...imports].sort();
 }
 function detectValidator(root) {
 	const pkgPath = join(root, "package.json");
@@ -203,76 +156,39 @@ async function resolveValidator(root) {
 	if (choice !== "none") log.warn(`Remember to install ${choice}: npm install ${choice}`);
 	return choice;
 }
-function validatorTypeFor(validator, col) {
-	if (validator === "valibot") return valibotType(col);
-	if (validator === "zod") return zodType(col);
-	return arktypeType(col);
-}
-function valibotType(col) {
-	let base;
-	switch (col.type) {
-		case "string":
-		case "text":
-		case "datetime":
-			base = "v.string()";
-			break;
-		case "integer":
-		case "real":
-			base = "v.number()";
-			break;
-		case "boolean":
-			base = "v.boolean()";
-			break;
-		case "blob":
-			base = "v.instance(Blob)";
-			break;
-		default: base = "v.string()";
-	}
-	return col.nullable ? `v.optional(${base})` : base;
-}
-function zodType(col) {
-	let base;
-	switch (col.type) {
-		case "string":
-		case "text":
-		case "datetime":
-			base = "z.string()";
-			break;
-		case "integer":
-		case "real":
-			base = "z.number()";
-			break;
-		case "boolean":
-			base = "z.boolean()";
-			break;
-		case "blob":
-			base = "z.instanceof(Blob)";
-			break;
-		default: base = "z.string()";
-	}
-	return col.nullable ? `${base}.optional()` : base;
-}
-function arktypeType(col) {
-	let base;
-	switch (col.type) {
-		case "string":
-		case "text":
-		case "datetime":
-			base = "string";
-			break;
-		case "integer":
-		case "real":
-			base = "number";
-			break;
-		case "boolean":
-			base = "boolean";
-			break;
-		case "blob":
-			base = "instanceof Blob";
-			break;
-		default: base = "string";
+const VALIDATOR_TYPES = {
+	valibot: {
+		string: "v.string()",
+		number: "v.number()",
+		boolean: "v.boolean()",
+		blob: "v.instance(Blob)",
+		optional: (base) => `v.optional(${base})`
+	},
+	zod: {
+		string: "z.string()",
+		number: "z.number()",
+		boolean: "z.boolean()",
+		blob: "z.instanceof(Blob)",
+		optional: (base) => `${base}.optional()`
+	},
+	arktype: {
+		string: "string",
+		number: "number",
+		boolean: "boolean",
+		blob: "instanceof Blob",
+		optional: (base) => `${base} | undefined`
 	}
-	return col.nullable ? `${base} | undefined` : base;
+};
+const VALUE_KINDS = {
+	integer: "number",
+	real: "number",
+	boolean: "boolean",
+	blob: "blob"
+};
+function validatorType(validator, col) {
+	const types = VALIDATOR_TYPES[validator];
+	const base = types[VALUE_KINDS[col.type] ?? "string"];
+	return col.nullable ? types.optional(base) : base;
 }
 function getImportLine(validator) {
 	switch (validator) {
@@ -283,8 +199,8 @@ function getImportLine(validator) {
 	}
 }
 function getBodySchema(validator, columns) {
-	if (validator === "arktype") return `type({\n${columns.map((c) => `    ${c.name}: "${arktypeType(c)}",`).join("\n")}\n  })`;
-	const fields = columns.map((c) => `    ${c.name}: ${validatorTypeFor(validator, c)},`).join("\n");
+	if (validator === "arktype") return `type({\n${columns.map((c) => `    ${c.name}: "${validatorType(validator, c)}",`).join("\n")}\n  })`;
+	const fields = columns.map((c) => `    ${c.name}: ${validatorType(validator, c)},`).join("\n");
 	return `${validator === "valibot" ? "v" : "z"}.object({\n${fields}\n  })`;
 }
 function getParamsSchema(validator) {
@@ -370,60 +286,43 @@ async function runModel(root, name, columns) {
 	const schemaDir = paths.schemaDir;
 	const barrelPath = paths.schemaFile;
 	const modelPath = join(schemaDir, `${name}.ts`);
+	const colDefs = columns.map((col) => drizzleColumnDef(dialect, col));
+	const columnImports = drizzleImportsForColumns(dialect, columns).join(", ");
 	let content;
-	if (dialect === "postgresql") {
-		const colDefs = columns.map((col) => drizzleColumnDefPg(col));
-		const columnImports = drizzleImportsForColumnsPg(columns);
-		const allCols = [
-			`  id: serial("id").primaryKey(),`,
-			...colDefs,
-			`  createdAt: timestamp("created_at").notNull().defaultNow(),`,
-			`  updatedAt: timestamp("updated_at").notNull().defaultNow(),`
-		];
-		content = [
-			`import { pgTable, ${columnImports.join(", ")} } from "void/schema-pg";`,
-			"",
-			`export const ${name} = pgTable("${name}", {`,
-			...allCols,
-			"});",
-			""
-		].join("\n");
-	} else if (dialect === "mysql") {
-		const colDefs = columns.map((col) => drizzleColumnDefMySql(col));
-		const columnImports = drizzleImportsForColumnsMySql(columns);
-		const allCols = [
-			`  id: int("id").autoincrement().primaryKey(),`,
-			...colDefs,
-			`  createdAt: timestamp("created_at").notNull().defaultNow(),`,
-			`  updatedAt: timestamp("updated_at").notNull().defaultNow(),`
-		];
-		content = [
-			`import { mysqlTable, ${columnImports.join(", ")} } from "void/schema-mysql";`,
-			"",
-			`export const ${name} = mysqlTable("${name}", {`,
-			...allCols,
-			"});",
-			""
-		].join("\n");
-	} else {
-		const colDefs = columns.map((col) => drizzleColumnDef(col));
-		const columnImports = drizzleImportsForColumns(columns);
-		const allCols = [
-			`  id: integer("id").primaryKey({ autoIncrement: true }),`,
-			...colDefs,
-			"  createdAt: text(\"created_at\").notNull().default(sql`(datetime('now'))`),",
-			"  updatedAt: text(\"updated_at\").notNull().default(sql`(datetime('now'))`),"
-		];
-		content = [
-			`import { sqliteTable, ${columnImports.join(", ")} } from "void/schema-d1";`,
-			`import { sql } from "void/db";`,
-			"",
-			`export const ${name} = sqliteTable("${name}", {`,
-			...allCols,
-			"});",
-			""
-		].join("\n");
-	}
+	if (dialect === "postgresql") content = [
+		`import { pgTable, ${columnImports} } from "void/schema-pg";`,
+		"",
+		`export const ${name} = pgTable("${name}", {`,
+		`  id: serial("id").primaryKey(),`,
+		...colDefs,
+		`  createdAt: timestamp("created_at").notNull().defaultNow(),`,
+		`  updatedAt: timestamp("updated_at").notNull().defaultNow(),`,
+		"});",
+		""
+	].join("\n");
+	else if (dialect === "mysql") content = [
+		`import { mysqlTable, ${columnImports} } from "void/schema-mysql";`,
+		"",
+		`export const ${name} = mysqlTable("${name}", {`,
+		`  id: int("id").autoincrement().primaryKey(),`,
+		...colDefs,
+		`  createdAt: timestamp("created_at").notNull().defaultNow(),`,
+		`  updatedAt: timestamp("updated_at").notNull().defaultNow(),`,
+		"});",
+		""
+	].join("\n");
+	else content = [
+		`import { sqliteTable, ${columnImports} } from "void/schema-d1";`,
+		`import { sql } from "void/db";`,
+		"",
+		`export const ${name} = sqliteTable("${name}", {`,
+		`  id: integer("id").primaryKey({ autoIncrement: true }),`,
+		...colDefs,
+		"  createdAt: text(\"created_at\").notNull().default(sql`(datetime('now'))`),",
+		"  updatedAt: text(\"updated_at\").notNull().default(sql`(datetime('now'))`),",
+		"});",
+		""
+	].join("\n");
 	mkdirSync(schemaDir, { recursive: true });
 	writeIfNotExists(modelPath, content);
 	const exportLine = `export * from "./schema/${name}";`;
@@ -464,9 +363,7 @@ function runMigration(root, name) {
 			log.error("Restore the snapshot from version control, or regenerate migrations with `void db generate` before running `void gen migration`.");
 			process.exit(1);
 		}
-		const journalPath = join(metaDir, "_journal.json");
-		const originalJournalBytes = existsSync(journalPath) ? readFileSync(journalPath) : null;
-		const snapshotsBefore = new Set(readdirSync(metaDir).filter((f) => f.endsWith("_snapshot.json")));
+		const rollBack = snapshotDrizzleOutputs(migrationsDir);
 		const sqlFilesBefore = new Set(readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")));
 		let journalDialect;
 		if (existingJournal.dialect === "sqlite") journalDialect = "sqlite";
@@ -485,8 +382,7 @@ function runMigration(root, name) {
 		}
 		const authSchemaPath = join(root, ".void", "better-auth-schema.ts");
 		const additionalSchemas = existsSync(authSchemaPath) ? [authSchemaPath] : void 0;
-		const configPath = writeDrizzleConfig(root, journalDialect === "postgresql" ? "postgresql://dummy" : journalDialect === "mysql" ? "mysql://dummy" : ":memory:", journalDialect, { additionalSchemas });
-		const childEnv = buildDrizzleKitSpawnEnv(root);
+		const configPath = writeDrizzleConfig(root, PLACEHOLDER_DB_URL[journalDialect], journalDialect, { additionalSchemas });
 		const result = spawnSync(process.execPath, [
 			drizzleKitBin,
 			"generate",
@@ -499,21 +395,10 @@ function runMigration(root, name) {
 			cwd: root,
 			stdio: "pipe",
 			encoding: "utf-8",
-			shell: process.platform === "win32",
-			env: childEnv
+			env: buildDrizzleKitSpawnEnv(root)
 		});
 		if (result.error || result.status !== 0) {
-			if (originalJournalBytes !== null) try {
-				writeFileSync(journalPath, originalJournalBytes);
-			} catch {}
-			if (existsSync(metaDir)) {
-				for (const f of readdirSync(metaDir)) if (f.endsWith("_snapshot.json") && !snapshotsBefore.has(f)) try {
-					unlinkSync(join(metaDir, f));
-				} catch {}
-			}
-			for (const f of readdirSync(migrationsDir)) if (f.endsWith(".sql") && !sqlFilesBefore.has(f)) try {
-				unlinkSync(join(migrationsDir, f));
-			} catch {}
+			rollBack();
 			const detail = [result.stderr, result.stdout].filter(Boolean).join("\n").trim();
 			log.error([
 				`Failed to run \`drizzle-kit generate --custom --name ${name}\`.`,
@@ -528,13 +413,6 @@ function runMigration(root, name) {
 		printSuccess("Migration created and journal updated.");
 		return;
 	}
-	if (existingJournal !== void 0 && existingJournal.entries.length === 0) {
-		if (listDrizzleArtifacts(migrationsDir).length > 0) {
-			log.error("db/migrations/meta/_journal.json has empty entries but stale drizzle-kit snapshots are on disk.");
-			log.error("Restore the journal entries from version control (or run `void db generate`), or delete the stale drizzle artifacts and rerun.");
-			process.exit(1);
-		}
-	}
 	const tag = `${getMigrationTimestamp(migrationsDir)}_${name}`;
 	if (writeIfNotExists(join(migrationsDir, `${tag}.sql`), `-- ${name}\n`)) printSuccess("Migration created.");
 }

package/dist/gen-F8pSZnhc.mjs

@@ -0,0 +1,2 @@
+import { r as runGenCommand } from "./gen-CnN1Xidx.mjs";
+export { runGenCommand };

package/dist/{generate-GDbL7sUr.mjs → generate-Dat0UTry.mjs}

@@ -1,7 +1,7 @@
-import { a as join, n as dirname } from "./dist-BVqXeR_h.mjs";
-import { t as collectMigrations } from "./collect-DiTn9yr6.mjs";
+import { a as join, n as dirname } from "./dist-ipQi0Q8y.mjs";
+import { t as collectMigrations } from "./collect-xjffdCdk.mjs";
 import { n as openMigrationValidationDatabase } from "./sqlite-validation-BzKMWnO4.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 //#region src/drizzle/generate.ts
 function snapshotFiles(root) {
 	const files = /* @__PURE__ */ new Map();
@@ -16,6 +16,40 @@ function snapshotFiles(root) {
 	}
 	return files;
 }
+function listFiles(dir, suffix) {
+	return new Set(existsSync(dir) ? readdirSync(dir).filter((file) => file.endsWith(suffix)) : []);
+}
+/**
+* Record the Drizzle outputs under `migrationsDir` and return a rollback for a
+* failed `drizzle-kit generate`, so partial files cannot fail the journal check
+* of later `void db` commands.
+*/
+function snapshotDrizzleOutputs(migrationsDir) {
+	const metaDir = join(migrationsDir, "meta");
+	const journalPath = join(metaDir, "_journal.json");
+	const metaDirExisted = existsSync(metaDir);
+	const journal = existsSync(journalPath) ? readFileSync(journalPath) : null;
+	const snapshots = listFiles(metaDir, "_snapshot.json");
+	const sqlFiles = listFiles(migrationsDir, ".sql");
+	const bestEffort = (step) => {
+		try {
+			step();
+		} catch {}
+	};
+	const removeNewFiles = (dir, suffix, before) => {
+		for (const file of listFiles(dir, suffix)) if (!before.has(file)) bestEffort(() => unlinkSync(join(dir, file)));
+	};
+	return () => {
+		if (metaDirExisted) {
+			if (journal !== null) bestEffort(() => writeFileSync(journalPath, journal));
+			bestEffort(() => removeNewFiles(metaDir, "_snapshot.json", snapshots));
+		} else bestEffort(() => rmSync(metaDir, {
+			recursive: true,
+			force: true
+		}));
+		bestEffort(() => removeNewFiles(migrationsDir, ".sql", sqlFiles));
+	};
+}
 /** Keep SQL and Drizzle's snapshot/journal together when generation fails validation. */
 async function generateValidatedSqliteMigrations(migrationsDir, generate) {
 	try {
@@ -44,4 +78,4 @@ async function generateValidatedSqliteMigrations(migrationsDir, generate) {
 	}
 }
 //#endregion
-export { generateValidatedSqliteMigrations };
+export { snapshotDrizzleOutputs as n, generateValidatedSqliteMigrations as t };

package/dist/generate-Rii9klHB.mjs

@@ -0,0 +1,2 @@
+import { t as generateValidatedSqliteMigrations } from "./generate-Dat0UTry.mjs";
+export { generateValidatedSqliteMigrations };

package/dist/generated-wrangler-config-DeWj5F9Y.mjs

@@ -0,0 +1,18 @@
+import { readFileSync } from "node:fs";
+import { parse } from "jsonc-parser";
+//#region src/cli/generated-wrangler-config.ts
+/** Parse JSON/JSONC text with an optional BOM; undefined unless it is one valid object. */
+function parseJsoncObject(text) {
+	const errors = [];
+	const parsed = parse(text.replace(/^\uFEFF/, ""), errors, { allowTrailingComma: true });
+	if (errors.length > 0 || parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return;
+	return parsed;
+}
+/** Parse a generated Wrangler JSON/JSONC config without accepting a partial parse. */
+function readGeneratedWranglerConfigFile(path) {
+	const parsed = parseJsoncObject(readFileSync(path, "utf8"));
+	if (!parsed) throw new Error("Invalid Wrangler JSON/JSONC config.");
+	return parsed;
+}
+//#endregion
+export { readGeneratedWranglerConfigFile as n, parseJsoncObject as t };