@devdogsuga/devtools 0.1.51-next.547 → 0.1.51-next.548

package/dist/{cli-CJtevyVy.js → cli-DV6tvG1E.js}

@@ -7236,9 +7236,18 @@ var DevDataError = class extends Error {
 		this.name = "DevDataError";
 	}
 };
-/** A Postgres SQLSTATE: five characters, digits and capitals. Connection errors (`ECONNREFUSED`) are not. */
-function isSqlState(code) {
-	return typeof code === "string" && /^[0-9A-Z]{5}$/.test(code);
+/**
+* Whether `err` is the product's own SQL being wrong: a Postgres error whose
+* SQLSTATE class is a cardinality violation (21), data exception (22),
+* integrity constraint violation (23) or syntax error or access rule
+* violation (42). Everything else is not the file's fault and reports as a
+* normal failure: a refused or dropped connection (class 08 and
+* `ECONNREFUSED`), an operator shutdown (57, `admin_shutdown`), a server out
+* of resources (53), a transaction that was rolled back (40), and so on.
+*/
+function isSqlFileError(err) {
+	const code = err?.code;
+	return typeof code === "string" && /^(21|22|23|42)[0-9A-Z]{3}$/.test(code);
 }
 /**
 * The line of `text` a Postgres error points at, from the error's 1-based
@@ -7294,6 +7303,11 @@ function postgresSession(dbUrl) {
 			const present = new Set(rows.map((r) => r.nspname));
 			return schemas.filter((name) => !present.has(name));
 		},
+		async exec(text) {
+			await sql.begin(async (tx) => {
+				await tx.unsafe(text);
+			});
+		},
 		async runAs(memberId, text) {
 			await sql.begin(async (tx) => {
 				await tx`select set_config('devtools.member_id', ${memberId}, true)`;
@@ -7335,7 +7349,7 @@ async function seed(session, file, text, options, log) {
 	try {
 		await session.runAs(member.id, text);
 	} catch (err) {
-		if (!isSqlState(err?.code)) throw err;
+		if (!isSqlFileError(err)) throw err;
 		const line = errorLine(err, text);
 		throw new DevDataError(`${file}${line === null ? "" : `:${line}`}: ${err.message}. This is a problem in the product's dev-data SQL, not in devtools; nothing was seeded (the file runs in one transaction).`);
 	}
@@ -7572,6 +7586,15 @@ function typesAssetName(product, hash) {
 * Without that, the diff would start from an empty database and write the whole
 * schema as one migration, which `db push` rejects as already applied.
 *
+* The record only says what *should* be in the database. Before the diff,
+* sync therefore compares the database itself with the record (`supabase db
+* diff --from <database> --to migrations`, restricted to the product's
+* schemas) and re-applies whatever is missing: a dropped table, a dropped
+* schema, a database reset behind the record's back. The migration ledger is
+* never trusted to decide anything; it is rewritten to list the record when it
+* is missing or short. "The database already matches" is therefore a
+* statement about the live database.
+*
 * It never resets the database. A reset wipes `auth.custom_oauth_providers`,
 * which is where "Sign in with DevDogs" is registered (Q83); `--rebuild` is
 * the explicit escape hatch for a database that has drifted from its record,
@@ -7623,6 +7646,7 @@ async function dbSync(product, cli, target, run, options) {
 			"--db-url",
 			"<DB_URL>"
 		])} (this machine has no record of what the project has had applied)`);
+		if (options.open) log(`Would run: ${cliLine(cli, liveDiffArgs(product, target).slice(cli.prefix.length))} (and restore anything the database lost)`);
 		log(`Would run: ${cliLine(cli, generateArgs.slice(cli.prefix.length))}`);
 		log(target.kind === "local" ? `Would run: ${cliLine(cli, [
 			"migration",
@@ -7646,7 +7670,7 @@ async function dbSync(product, cli, target, run, options) {
 		const restored = migrationFiles(migrationsDir).length;
 		if (fetched.code === 0 && restored > 0) log(`Restored ${restored} applied migration${restored === 1 ? "" : "s"} from the project's history.`);
 	}
-	await reconcileRecord(product, cli, target, run, options, log);
+	const restored = await restoreDatabase(product, cli, target, run, options, log);
 	const before = new Set(migrationFiles(migrationsDir));
 	let generated = await run(cli.command, generateArgs, { cwd: product.root });
 	if (generated.code !== 0 && isContainerFailure(generated)) {
@@ -7656,11 +7680,11 @@ async function dbSync(product, cli, target, run, options) {
 	if (generated.code !== 0) throw new SyncError(isContainerFailure(generated) ? "Could not diff the schema: Docker is needed for the shadow database. Start Docker and try again." : "Could not diff the schema against what this database has had applied.", generated.stderr || generated.stdout);
 	const created = migrationFiles(migrationsDir).filter((f) => !before.has(f));
 	if (created.length === 0) {
-		log("The database already matches supabase/schemas.");
+		if (!restored.applied) log("The database already matches supabase/schemas.");
 		return {
 			migration: null,
-			applied: false,
-			destructive: []
+			applied: restored.applied,
+			destructive: restored.destructive
 		};
 	}
 	const migration = created[created.length - 1];
@@ -7694,71 +7718,136 @@ async function dbSync(product, cli, target, run, options) {
 	return {
 		migration,
 		applied: true,
-		destructive
+		destructive: [...restored.destructive, ...destructive]
 	};
 }
 /** `20261011120000` from `20261011120000_devtools_sync.sql`. */
 function versionOf(file) {
 	return file.split("_")[0] ?? file;
 }
+function liveDiffArgs(product, target) {
+	return [
+		"db",
+		"diff",
+		"--from",
+		target.kind === "local" ? "local" : target.dbUrl,
+		"--to",
+		"migrations",
+		"--use-pg-delta",
+		"--schema",
+		product.config.supabase.schemas.join(","),
+		"--output-format",
+		"json"
+	];
+}
 /**
-* Makes the local record agree with the database. The declarative diff only
-* compares `supabase/schemas` with `supabase/migrations`, so a database that
-* lost its contents behind the record's back (a hosted project reset from the
-* dashboard, a checkout switched from the local stack to a hosted project)
-* would read as "already matches". This asks the target:
+* The SQL that turns the database into what the record describes, from the
+* CLI's pg-delta diff (database to migrations baseline). Empty when they
+* agree. Only the product's own schemas are compared, so the platform's
+* (auth, storage, ...) never show up as drift.
+*/
+async function liveDiff(product, cli, target, run, log) {
+	const args = [...cli.prefix, ...liveDiffArgs(product, target)];
+	let result = await run(cli.command, args, { cwd: product.root });
+	if (result.code !== 0 && isContainerFailure(result)) {
+		log("The shadow database did not start; trying once more.");
+		result = await run(cli.command, args, { cwd: product.root });
+	}
+	if (result.code !== 0) throw new SyncError(isContainerFailure(result) ? "Could not compare the database with its record: Docker is needed for the shadow database. Start Docker and try again." : "Could not compare the database with what devtools recorded as applied.", result.stderr || result.stdout);
+	for (const line of result.stdout.split("\n").reverse()) {
+		const text = line.trim();
+		if (!text.startsWith("{")) continue;
+		try {
+			const parsed = JSON.parse(text);
+			if (typeof parsed.diff === "string") return parsed.diff;
+		} catch {}
+	}
+	throw new SyncError("Could not read the result of comparing the database with its record.", result.stdout || result.stderr);
+}
+/**
+* Makes the database agree with the local record, from the database itself.
+* The declarative diff only compares `supabase/schemas` with
+* `supabase/migrations`, so a database that lost objects behind the record's
+* back (a table dropped by hand, a hosted project reset from the dashboard, a
+* checkout switched from the local stack to a hosted project) would read as
+* "already matches". So, with a record to compare against:
 *
-*   - a migration in the record that is not in the database's ledger was never
-*     applied there: it is dropped from the record, so the diff re-creates it;
-*   - a configured schema that does not exist means the ledger is stale too:
-*     its entries are reverted and the whole record dropped, so the diff
-*     writes the full schema again.
+*   1. the database is diffed against the record, per configured schema, and
+*      whatever it lacks is created again (data in what remains is untouched);
+*      statements that drop something need the same approval as any change;
+*   2. the migration ledger is made to list every migration in the record
+*      (marking them applied, which they now are), so the next
+*      `migration up` applies only what is new.
 *
-* Nothing is reset or dropped in the database; only ledger rows of schemas
-* that are already gone are removed. A database that cannot be reached is
-* left to the apply step to report.
+* A missing or unreadable ledger decides nothing by itself: it is rewritten,
+* never read as "start over". A database that cannot be reached is left to
+* the apply step to report.
 */
-async function reconcileRecord(product, cli, target, run, options, log) {
-	if (!options.open) return;
-	const { migrationsDir } = product.paths;
-	const files = migrationFiles(migrationsDir);
-	let ledger;
-	let missing;
+async function restoreDatabase(product, cli, target, run, options, log) {
+	const nothing = {
+		applied: false,
+		destructive: []
+	};
+	const files = migrationFiles(product.paths.migrationsDir);
+	if (!options.open || files.length === 0) return nothing;
 	let session;
+	let missing;
+	let ledger;
 	try {
 		session = options.open(target.dbUrl);
-		ledger = await session.appliedMigrations();
 		missing = await session.missingSchemas(product.config.supabase.schemas);
 	} catch (err) {
-		log(`Could not check what the database has applied (${err.message}); trusting the local record.`);
-		return;
-	} finally {
+		log(`Could not check what the database has (${err.message}); trusting the local record.`);
 		await session?.close().catch(() => void 0);
+		return nothing;
 	}
-	if (missing.length > 0) {
-		const stale = ledger ?? [];
-		log(`The database is missing ${missing.length === 1 ? "schema" : "schemas"} ${missing.join(", ")}, so the record of applied migrations is out of date; rebuilding it from supabase/schemas.`);
-		if (stale.length > 0) {
-			const reverted = await run(cli.command, [
-				...cli.prefix,
-				"migration",
-				"repair",
-				"--status",
-				"reverted",
-				"--db-url",
-				target.dbUrl,
-				...stale
-			], { cwd: product.root });
-			if (reverted.code !== 0) throw new SyncError("The database lost its schema but its migration history still lists migrations as applied, and clearing that history failed.", reverted.stderr || reverted.stdout);
+	try {
+		try {
+			ledger = await session.appliedMigrations();
+		} catch (err) {
+			ledger = void 0;
+			log(`Could not read the migration history (${err.message}); deciding from the schemas alone.`);
 		}
-		for (const file of files) rmSync(join(migrationsDir, file));
-		return;
-	}
-	const applied = new Set(ledger ?? []);
-	const unapplied = files.filter((file) => !applied.has(versionOf(file)));
-	if (unapplied.length > 0) {
-		log(`${unapplied.length} migration${unapplied.length === 1 ? "" : "s"} in the local record ${unapplied.length === 1 ? "is" : "are"} not in this database's history (it was reset, or this checkout switched databases); re-applying ${unapplied.length === 1 ? "it" : "them"}.`);
-		for (const file of unapplied) rmSync(join(migrationsDir, file));
+		const sql = (await liveDiff(product, cli, target, run, log)).trim();
+		let applied = false;
+		let destructive = [];
+		if (sql) {
+			destructive = destructiveStatements(sql);
+			if (destructive.length > 0 && !options.yes) {
+				if (!(options.confirmDestructive ? await options.confirmDestructive(sql, destructive) : false)) throw new SyncError(`The database differs from supabase/schemas and putting it right drops data in your development database (${destructive.length} statement${destructive.length === 1 ? "" : "s"}). Re-run with --yes to allow it.`, destructive.join(";\n"));
+			}
+			log(missing.length > 0 ? `The database is missing ${missing.length === 1 ? "schema" : "schemas"} ${missing.join(", ")}; creating ${missing.length === 1 ? "it" : "them"} again from supabase/schemas.` : "The database has lost part of supabase/schemas (a dropped table, view or function, perhaps); restoring it. Existing data is kept.");
+			try {
+				await session.exec(sql);
+			} catch (err) {
+				throw new SyncError("Could not restore what the database lost. `devtools db sync --rebuild` starts over (it wipes local data).", err.message);
+			}
+			applied = true;
+		}
+		if (ledger !== void 0) {
+			const known = new Set(ledger ?? []);
+			const unlisted = files.map(versionOf).filter((version) => !known.has(version));
+			if (unlisted.length > 0) {
+				if (ledger === null) log("The database has no migration history table; recreating it from the local record.");
+				const repaired = await run(cli.command, [
+					...cli.prefix,
+					"migration",
+					"repair",
+					"--status",
+					"applied",
+					"--db-url",
+					target.dbUrl,
+					...unlisted
+				], { cwd: product.root });
+				if (repaired.code !== 0) throw new SyncError("Could not record the applied migrations in the database's history.", repaired.stderr || repaired.stdout);
+			}
+		}
+		return {
+			applied,
+			destructive
+		};
+	} finally {
+		await session.close().catch(() => void 0);
 	}
 }
 function isContainerFailure(result) {
@@ -8049,7 +8138,7 @@ async function regenerateAfterSync(product, cli, target, result, deps) {
 		log.info(`Would regenerate ${product.config.types.out}.`);
 		return;
 	}
-	if (!result.migration && typesAreCurrent(product)) return;
+	if (!result.applied && typesAreCurrent(product)) return;
 	try {
 		await generateTypes(product, cli, target, deps.run, (line) => log.info(line));
 		log.success(`Regenerated ${product.config.types.out}.`);
@@ -8095,7 +8184,7 @@ function createProductHandlers(deps = defaultDeps) {
 		switch (sub) {
 			case "sync": {
 				const { result, cli, target } = await runSync(product, deps, flags);
-				if (result.migration) log.success("Your database now matches supabase/schemas.");
+				if (result.applied) log.success("Your database now matches supabase/schemas.");
 				await regenerateAfterSync(product, cli, target, result, deps);
 				return DONE;
 			}
@@ -8328,7 +8417,7 @@ async function runSetup(product, deps, rest) {
 		log: (line) => log.info(line),
 		open: deps.openSql
 	});
-	log.success(result.migration ? "Applied supabase/schemas to your database." : "Your database already matched supabase/schemas.");
+	log.success(result.applied ? "Applied supabase/schemas to your database." : "Your database already matched supabase/schemas.");
 	if (target.kind === "local") await waitForRest(target, deps, product);
 	if (rest.includes("--download-types")) try {
 		await downloadTypes(product, {

package/dist/launch.js

@@ -183,7 +183,7 @@ async function startStack() {
 * post-tier-resolution path.
 */
 async function dispatch(argv) {
-	const { main } = await import("./cli-CJtevyVy.js");
+	const { main } = await import("./cli-DV6tvG1E.js");
 	try {
 		await main(argv);
 	} catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devdogsuga/devtools",
-  "version": "0.1.51-next.547",
+  "version": "0.1.51-next.548",
   "private": false,
   "type": "module",
   "description": "Contributor CLI for DevDogs repositories (the platform monorepo, DogDays, DogPack): the real tools with the session's tier filled in, `setup`, `db sync`, `db types`, `dev-data`, a menu over them, the checks CI runs, and the `with-env` launcher. Ships built JS; run via `pnpm devtools` in a product repo, `pnpm dlx @devdogsuga/devtools` (or the `devtools` bin once installed) from inside a clone.",
@@ -47,8 +47,8 @@
     "tsdown": "^0.23.0",
     "vitest": "^4.1.11",
     "@devdogsuga/cli-core": "0.0.0",
-    "@devdogsuga/sdk": "0.1.0",
-    "@devdogsuga/config": "0.1.4-next.526"
+    "@devdogsuga/config": "0.1.4-next.526",
+    "@devdogsuga/sdk": "0.1.0"
   },
   "scripts": {
     "build": "tsdown && node scripts/write-build-info.mjs && node ../../scripts/check-bundle-imports.mjs",