emdash 0.8.0 → 0.9.0

package/dist/{runner-tQ7BJ4T7.mjs → runner-C7ADox5q.mjs}

@@ -1,8 +1,25 @@
-import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
 import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
-import { a as isSqlite, n as currentTimestamp, r as currentTimestampValue, s as listTablesLike, t as binaryType } from "./dialect-helpers-DhTzaUxP.mjs";
+import { c as listTablesLike, i as currentTimestampValue, n as columnExists, o as isSqlite, r as currentTimestamp, t as binaryType } from "./dialect-helpers-BKCvISIQ.mjs";
+import { createRequire } from "node:module";
 import { Migrator, sql } from "kysely";
 
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
 //#region src/database/migrations/001_initial.ts
 var _001_initial_exports = /* @__PURE__ */ __exportAll({
 	down: () => down$33,
@@ -1404,7 +1421,7 @@ async function up$1(db) {
 	for (const tableName of tableNames) {
 		const table = { name: tableName };
 		await sql`
-			CREATE INDEX ${sql.ref(`idx_${table.name}_deleted_published_id`)}
+			CREATE INDEX IF NOT EXISTS ${sql.ref(`idx_${table.name}_deleted_published_id`)}
 			ON ${sql.ref(table.name)} (deleted_at, published_at DESC, id DESC)
 		`.execute(db);
 	}
@@ -1440,55 +1457,58 @@ var _035_bounded_404_log_exports = /* @__PURE__ */ __exportAll({
 *   - Adds a UNIQUE index on `path` so upsert semantics work
 */
 async function up(db) {
-	await db.schema.alterTable("_emdash_404_log").addColumn("hits", "integer", (col) => col.notNull().defaultTo(1)).execute();
-	await db.schema.alterTable("_emdash_404_log").addColumn("last_seen_at", "text").execute();
+	const hitsExists = await columnExists(db, "_emdash_404_log", "hits");
+	if (!hitsExists) await db.schema.alterTable("_emdash_404_log").addColumn("hits", "integer", (col) => col.notNull().defaultTo(1)).execute();
+	if (!await columnExists(db, "_emdash_404_log", "last_seen_at")) await db.schema.alterTable("_emdash_404_log").addColumn("last_seen_at", "text").execute();
 	await sql`
 		UPDATE _emdash_404_log
 		SET last_seen_at = created_at
 		WHERE last_seen_at IS NULL
 	`.execute(db);
-	await sql`
-		WITH ranked AS (
-			SELECT
-				id,
-				path,
-				ROW_NUMBER() OVER (
-					PARTITION BY path
-					ORDER BY created_at DESC, id DESC
-				) AS rn,
-				COUNT(*) OVER (PARTITION BY path) AS path_count,
-				MAX(created_at) OVER (PARTITION BY path) AS latest_created_at
-			FROM _emdash_404_log
-		)
-		UPDATE _emdash_404_log
-		SET
-			hits = (SELECT path_count FROM ranked WHERE ranked.id = _emdash_404_log.id),
-			last_seen_at = (SELECT latest_created_at FROM ranked WHERE ranked.id = _emdash_404_log.id)
-		WHERE id IN (SELECT id FROM ranked WHERE rn = 1)
-	`.execute(db);
-	await sql`
-		DELETE FROM _emdash_404_log
-		WHERE id IN (
-			SELECT id FROM (
+	if (!hitsExists) {
+		await sql`
+			WITH ranked AS (
 				SELECT
 					id,
+					path,
 					ROW_NUMBER() OVER (
 						PARTITION BY path
 						ORDER BY created_at DESC, id DESC
-					) AS rn
+					) AS rn,
+					COUNT(*) OVER (PARTITION BY path) AS path_count,
+					MAX(created_at) OVER (PARTITION BY path) AS latest_created_at
 				FROM _emdash_404_log
-			) AS ranked
-			WHERE rn > 1
-		)
-	`.execute(db);
-	await db.schema.createIndex("idx_404_log_path_unique").on("_emdash_404_log").column("path").unique().execute();
-	await db.schema.dropIndex("idx_404_log_path").execute();
-	await db.schema.createIndex("idx_404_log_last_seen").on("_emdash_404_log").column("last_seen_at").execute();
+			)
+			UPDATE _emdash_404_log
+			SET
+				hits = (SELECT path_count FROM ranked WHERE ranked.id = _emdash_404_log.id),
+				last_seen_at = (SELECT latest_created_at FROM ranked WHERE ranked.id = _emdash_404_log.id)
+			WHERE id IN (SELECT id FROM ranked WHERE rn = 1)
+		`.execute(db);
+		await sql`
+			DELETE FROM _emdash_404_log
+			WHERE id IN (
+				SELECT id FROM (
+					SELECT
+						id,
+						ROW_NUMBER() OVER (
+							PARTITION BY path
+							ORDER BY created_at DESC, id DESC
+						) AS rn
+					FROM _emdash_404_log
+				) AS ranked
+				WHERE rn > 1
+			)
+		`.execute(db);
+	}
+	await db.schema.createIndex("idx_404_log_path_unique").ifNotExists().on("_emdash_404_log").column("path").unique().execute();
+	await db.schema.dropIndex("idx_404_log_path").ifExists().execute();
+	await db.schema.createIndex("idx_404_log_last_seen").ifNotExists().on("_emdash_404_log").column("last_seen_at").execute();
 }
 async function down(db) {
-	await db.schema.dropIndex("idx_404_log_last_seen").execute();
-	await db.schema.dropIndex("idx_404_log_path_unique").execute();
-	await db.schema.createIndex("idx_404_log_path").on("_emdash_404_log").column("path").execute();
+	await db.schema.dropIndex("idx_404_log_last_seen").ifExists().execute();
+	await db.schema.dropIndex("idx_404_log_path_unique").ifExists().execute();
+	await db.schema.createIndex("idx_404_log_path").ifNotExists().on("_emdash_404_log").column("path").execute();
 	await db.schema.alterTable("_emdash_404_log").dropColumn("last_seen_at").execute();
 	await db.schema.alterTable("_emdash_404_log").dropColumn("hits").execute();
 }
@@ -1564,22 +1584,130 @@ async function getMigrationStatus(db) {
 		pending
 	};
 }
+/** Pattern for escaping special regex characters. Matches the shared helper in `database/repositories/content.ts`. */
+const REGEX_ESCAPE_PATTERN = /[.*+?^${}()|[\]\\]/g;
+/** Escape special regex characters so a string can be embedded literally in `new RegExp()`. */
+function escapeRegExp(value) {
+	return value.replace(REGEX_ESCAPE_PATTERN, "\\$&");
+}
+/**
+* Pattern used to detect the concurrent-migration race. The Kysely
+* `SqliteAdapter.acquireMigrationLock` is a no-op (inherited by `kysely-d1`
+* and our `EmDashD1Dialect`), so two isolates running migrations against the
+* same database can both attempt `INSERT INTO _emdash_migrations` for the
+* same migration name. The losing insert fails with a UNIQUE constraint
+* error, which is benign: the other isolate is applying the same schema.
+*
+* We match on the table name (not the full error text) because different
+* SQLite drivers phrase the message differently
+* (`UNIQUE constraint failed: _emdash_migrations.name` for better-sqlite3,
+* `D1_ERROR: UNIQUE constraint failed: _emdash_migrations.name: SQLITE_CONSTRAINT`
+* for D1, etc.). The pattern is built from `MIGRATION_TABLE` so a rename
+* cannot silently disable race detection.
+*/
+const MIGRATION_RACE_PATTERN = new RegExp(`UNIQUE constraint failed: ${escapeRegExp(MIGRATION_TABLE)}\\.name`, "i");
+/** How long to wait for a concurrent migrator to finish before giving up. */
+const MIGRATION_RACE_WAIT_MS = 1e4;
+/** Polling interval while waiting for a concurrent migrator. */
+const MIGRATION_RACE_POLL_MS = 100;
+/**
+* Pattern used to detect "table does not exist" errors across the dialects
+* EmDash supports. The phrasing differs by driver:
+*
+*   - better-sqlite3: `no such table: _emdash_migrations`
+*   - D1:             `D1_ERROR: no such table: _emdash_migrations: SQLITE_ERROR`
+*   - PostgreSQL:     `relation "_emdash_migrations" does not exist`
+*                     (also occasionally `table "_emdash_migrations" does not exist`)
+*
+* We deliberately match on the migration table name (rather than using the
+* generic `isMissingTableError` helper) so an unexpected missing-table error
+* naming a different table — implausible today since
+* `getAppliedMigrationCount` only references `MIGRATION_TABLE`, but cheap
+* insurance against future edits — is not silently swallowed. The pattern is
+* built from `MIGRATION_TABLE` so a rename cannot drift.
+*/
+const MIGRATION_TABLE_MISSING_PATTERN = new RegExp(`(?:no such table:\\s*${escapeRegExp(MIGRATION_TABLE)}\\b|(?:relation|table)\\s+"?${escapeRegExp(MIGRATION_TABLE)}"?\\s+does(?:n't| not) exist\\b)`, "i");
+/**
+* Read the count of applied migrations.
+*
+* Returns `null` only when the migration table does not exist yet (which is
+* the normal state on a fresh database before the first migration runs).
+* Any other error is rethrown so callers — particularly
+* `waitForConcurrentMigrator` — don't silently mask connection failures,
+* permission errors, or other unexpected driver problems behind a 10s wait
+* and a bogus "we're done" verdict.
+*/
+async function getAppliedMigrationCount(db) {
+	try {
+		const result = await sql`
+			SELECT COUNT(*) as count FROM ${sql.ref(MIGRATION_TABLE)}
+		`.execute(db);
+		return Number(result.rows[0]?.count ?? 0);
+	} catch (error) {
+		if (MIGRATION_TABLE_MISSING_PATTERN.test(deepErrorMessage(error))) return null;
+		throw error;
+	}
+}
+/**
+* Wait for a concurrent migrator to finish applying all migrations.
+*
+* Resolves to `true` once the migration table contains at least
+* `MIGRATION_COUNT` rows (i.e. every migration this build knows about has
+* been recorded), `false` if the deadline elapses first. We use `>=` rather
+* than `===` so that an old isolate observing a database that has already
+* been migrated by a newer build still treats the wait as settled instead
+* of timing out.
+*/
+async function waitForConcurrentMigrator(db) {
+	const deadline = Date.now() + MIGRATION_RACE_WAIT_MS;
+	while (Date.now() < deadline) {
+		const count = await getAppliedMigrationCount(db);
+		if (count !== null && count >= MIGRATION_COUNT) return true;
+		await new Promise((resolve) => setTimeout(resolve, MIGRATION_RACE_POLL_MS));
+	}
+	const finalCount = await getAppliedMigrationCount(db);
+	return finalCount !== null && finalCount >= MIGRATION_COUNT;
+}
+/** Extract the deepest error message available from a thrown value. */
+function deepErrorMessage(error) {
+	if (error instanceof Error) {
+		const own = error.message ?? "";
+		if (error.cause) {
+			const causeMsg = deepErrorMessage(error.cause);
+			return own ? `${own}: ${causeMsg}` : causeMsg;
+		}
+		return own;
+	}
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
 /**
 * Run all pending migrations.
 *
 * Includes a fast-path: if the migration table already exists and contains
-* exactly MIGRATION_COUNT rows, all migrations have been applied and we can
-* skip the Kysely Migrator entirely. This avoids the expensive
-* `pragma_table_info` introspection that Kysely runs for every table in the
-* database (twice!) just to check if the migration tables exist.
-* On D1 with ~57 tables, that's ~116 queries saved per init.
+* at least MIGRATION_COUNT rows, all migrations this build knows about have
+* been applied and we can skip the Kysely Migrator entirely. This avoids
+* the expensive `pragma_table_info` introspection that Kysely runs for
+* every table in the database (twice!) just to check if the migration
+* tables exist. On D1 with ~57 tables, that's ~116 queries saved per init.
+*
+* Concurrent-migration safety: the Kysely Migrator's `acquireMigrationLock`
+* is a no-op for SQLite (and therefore D1), so two callers running this
+* concurrently against the same database will both try to apply pending
+* migrations. SQLite serializes the writes, but the loser still surfaces a
+* `UNIQUE constraint failed: _emdash_migrations.name` error. We treat that
+* specific error as benign: another caller is already applying the same
+* schema. We wait for the concurrent migrator to finish, then return
+* success. This matches the user-observable expectation that running
+* migrations twice in a row is a no-op.
 */
 async function runMigrations(db) {
-	try {
-		if ((await sql`
-			SELECT COUNT(*) as count FROM ${sql.ref(MIGRATION_TABLE)}
-		`.execute(db)).rows[0]?.count === MIGRATION_COUNT) return { applied: [] };
-	} catch {}
+	const initialCount = await getAppliedMigrationCount(db);
+	if (initialCount !== null && initialCount >= MIGRATION_COUNT) return { applied: [] };
 	const { error, results } = await new Migrator({
 		db,
 		provider: new StaticMigrationProvider(),
@@ -1588,11 +1716,13 @@ async function runMigrations(db) {
 	}).migrateToLatest();
 	const applied = results?.filter((r) => r.status === "Success").map((r) => r.migrationName) ?? [];
 	if (error) {
-		let msg = error instanceof Error ? error.message : JSON.stringify(error);
-		if (!msg && error instanceof Error && error.cause) msg = error.cause instanceof Error ? error.cause.message : JSON.stringify(error.cause);
+		const msg = deepErrorMessage(error);
 		const failedMigration = results?.find((r) => r.status === "Error");
-		if (failedMigration) msg = `${msg || "unknown error"} (migration: ${failedMigration.migrationName})`;
-		throw new Error(`Migration failed: ${msg}`);
+		if (MIGRATION_RACE_PATTERN.test(msg)) {
+			if (await waitForConcurrentMigrator(db)) return { applied };
+		}
+		const failedSuffix = failedMigration ? ` (migration: ${failedMigration.migrationName})` : "";
+		throw new Error(`Migration failed: ${msg || "unknown error"}${failedSuffix}`);
 	}
 	return { applied };
 }
@@ -1615,5 +1745,5 @@ async function rollbackMigration(db) {
 }
 
 //#endregion
-export { rollbackMigration as n, runMigrations as r, getMigrationStatus as t };
-//# sourceMappingURL=runner-tQ7BJ4T7.mjs.map
+export { __exportAll as i, rollbackMigration as n, runMigrations as r, getMigrationStatus as t };
+//# sourceMappingURL=runner-C7ADox5q.mjs.map