@jant/core 0.6.14 → 0.6.16

package/bin/commands/import-site.js

@@ -840,6 +840,20 @@ async function loadSiteConfig(rootDir) {
           params.show_header_avatar ?? jantData.show_header_avatar,
         ),
         noindex: coerceBoolean(params.noindex ?? jantData.noindex),
+        public_api_enabled:
+          params.public_api_enabled === undefined &&
+          jantData.public_api_enabled === undefined
+            ? true
+            : coerceBoolean(
+                params.public_api_enabled ?? jantData.public_api_enabled,
+              ),
+        rss_feeds_enabled:
+          params.rss_feeds_enabled === undefined &&
+          jantData.rss_feeds_enabled === undefined
+            ? true
+            : coerceBoolean(
+                params.rss_feeds_enabled ?? jantData.rss_feeds_enabled,
+              ),
         site_footer_markdown:
           typeof jantData.site_footer_markdown === "string"
             ? jantData.site_footer_markdown
@@ -896,6 +910,8 @@ function buildSettingsUpdatesFromConfig(siteConfig, customCss = "") {
     SITE_FOOTER: String(jant.site_footer_markdown || ""),
     SHOW_JANT_BRANDING_ON_HOME: jant.show_jant_branding_on_home ? "true" : "",
     NOINDEX: jant.noindex ? "true" : "",
+    PUBLIC_API_ENABLED: jant.public_api_enabled === false ? "false" : "true",
+    RSS_FEEDS_ENABLED: jant.rss_feeds_enabled === false ? "false" : "true",
     SHOW_HEADER_AVATAR: jant.show_header_avatar ? "true" : "",
     THEME: themeId && themeId !== defaultThemeId ? themeId : "",
     FONT_THEME: fontThemeId && fontThemeId !== "default" ? fontThemeId : "",
@@ -1615,7 +1631,7 @@ async function walkHugoContent(rootDir) {
 }
 
 /**
- * Resolve the collection memberships listed in a bundle's top-level
+ * Resolve the collection memberships listed in a post bundle's top-level
  * `collections:` front-matter array into `{collectionId, createdAt,
  * position, pinnedAt}` records the post-create APIs expect.
  *
@@ -1634,14 +1650,16 @@ function resolveCollectionMemberships(frontMatter, collectionSlugToId) {
     const id = collectionSlugToId.get(raw.slug);
     if (!id) continue;
     const entry = { collectionId: id };
-    if (typeof raw.collected_at === "string" && raw.collected_at) {
-      entry.createdAt = Math.floor(new Date(raw.collected_at).getTime() / 1000);
+    const createdAt = parseImportTimestamp(raw.collected_at);
+    if (createdAt !== null) {
+      entry.createdAt = createdAt;
     }
-    if (typeof raw.position === "number") {
+    if (typeof raw.position === "number" && Number.isFinite(raw.position)) {
       entry.position = raw.position;
     }
-    if (typeof raw.pinned_at === "string" && raw.pinned_at) {
-      entry.pinnedAt = Math.floor(new Date(raw.pinned_at).getTime() / 1000);
+    const pinnedAt = parseImportTimestamp(raw.pinned_at);
+    if (pinnedAt !== null) {
+      entry.pinnedAt = pinnedAt;
     }
     entries.push(entry);
     ids.push(id);
@@ -1649,6 +1667,59 @@ function resolveCollectionMemberships(frontMatter, collectionSlugToId) {
   return { entries, ids };
 }
 
+/**
+ * Resolve one Thread's collection memberships from its root and every reply.
+ *
+ * Current exports write `collections:` only on the root bundle. Older exports
+ * wrote it per post, so import must take the union before creating the root.
+ * Duplicate memberships retain all historical information by taking the
+ * greatest collected/pinned timestamps and the smallest position.
+ */
+function resolveThreadCollectionMemberships(rootBundle, collectionSlugToId) {
+  const byCollectionId = new Map();
+  const bundles = [rootBundle, ...(rootBundle.children ?? [])];
+
+  for (const bundle of bundles) {
+    const { entries } = resolveCollectionMemberships(
+      bundle.frontMatter,
+      collectionSlugToId,
+    );
+
+    for (const entry of entries) {
+      const current = byCollectionId.get(entry.collectionId);
+      if (!current) {
+        byCollectionId.set(entry.collectionId, { ...entry });
+        continue;
+      }
+
+      if (entry.createdAt !== undefined) {
+        current.createdAt =
+          current.createdAt === undefined
+            ? entry.createdAt
+            : Math.max(current.createdAt, entry.createdAt);
+      }
+      if (entry.position !== undefined) {
+        current.position =
+          current.position === undefined
+            ? entry.position
+            : Math.min(current.position, entry.position);
+      }
+      if (entry.pinnedAt !== undefined) {
+        current.pinnedAt =
+          current.pinnedAt === undefined
+            ? entry.pinnedAt
+            : Math.max(current.pinnedAt, entry.pinnedAt);
+      }
+    }
+  }
+
+  const entries = [...byCollectionId.values()];
+  return {
+    entries,
+    ids: entries.map((entry) => entry.collectionId),
+  };
+}
+
 function parseImportTimestamp(value) {
   if (typeof value !== "string" || value.trim() === "") return null;
   const timestamp = Date.parse(value);
@@ -1672,6 +1743,13 @@ function getImportedPostStatus(frontMatter) {
 function shouldImportReplyQuietly(rootFrontMatter, replyFrontMatter) {
   if (getImportedPostStatus(replyFrontMatter) !== "published") return false;
 
+  // Exports since quiet_reply became a stored column say so explicitly.
+  if (typeof replyFrontMatter.quiet_reply === "boolean") {
+    return replyFrontMatter.quiet_reply;
+  }
+
+  // Older bundles: a reply published after the root's recorded last activity
+  // can only have gotten there by skipping the bump, so it was quiet.
   const rootLastActivityAt = getImportedRootLastActivityAt(rootFrontMatter);
   const replyPublishedAt = parseImportTimestamp(replyFrontMatter.date);
   return (
@@ -1795,6 +1873,7 @@ export const __test__ = {
   walkHugoContent,
   mediaSpecFromJantMedia,
   resolveCollectionMemberships,
+  resolveThreadCollectionMemberships,
   buildPostPayloadFromBundle,
   shouldImportReplyQuietly,
 };
@@ -2220,8 +2299,8 @@ export async function run(argv) {
         }
       }
 
-      const memberships = resolveCollectionMemberships(
-        rootFm,
+      const memberships = resolveThreadCollectionMemberships(
+        rootBundle,
         collectionSlugToId,
       );
       const postData = buildPostPayloadFromBundle(rootBundle, {
@@ -2357,14 +2436,10 @@ export async function run(argv) {
           if (textAttachment) replyAttachments.push(textAttachment);
         }
 
-        const replyMemberships = resolveCollectionMemberships(
-          replyFm,
-          collectionSlugToId,
-        );
         const replyData = buildPostPayloadFromBundle(replyBundle, {
           bodyMarkdown: replyBody,
           attachments: replyAttachments,
-          memberships: replyMemberships,
+          memberships: { entries: [], ids: [] },
           replyToId: threadTailId,
           quietReply: shouldImportReplyQuietly(rootFm, replyFm),
         });

package/bin/commands/migrate.js

@@ -9,6 +9,7 @@ import {
   applyNodeBackfills,
   applyPgBackfills,
 } from "../lib/migration-runner.js";
+import { queryD1 } from "../lib/d1-query.js";
 import { loadNodeRuntime } from "../lib/load-node-runtime.js";
 import { loadNodeEnvFile } from "../lib/node-env.js";
 import { openNodeSqlite, resolveDatabaseDialect } from "../lib/node-sqlite.js";
@@ -16,6 +17,10 @@ import {
   bootstrapCliRuntime,
   getCliRuntimeLabel,
 } from "../lib/runtime-target.js";
+import {
+  preflightThreadCollectionMigration,
+  verifyThreadCollectionMigration,
+} from "../lib/thread-collection-migration.js";
 
 export { loadNodeEnvFile };
 
@@ -167,6 +172,27 @@ async function logCliPgMigrationDebug(databaseUrl, phase) {
   }
 }
 
+async function withNodeMigrationQuery(databaseDialect, databaseUrl, callback) {
+  if (databaseDialect === "pg") {
+    const pool = new Pool({ connectionString: databaseUrl });
+    try {
+      return await callback(async (sql) => (await pool.query(sql)).rows);
+    } finally {
+      await pool.end().catch(() => undefined);
+    }
+  }
+
+  const { sqlite } = openNodeSqlite(process.env, {
+    createParentDir: true,
+    requireInitialized: false,
+  });
+  try {
+    return await callback((sql) => sqlite.prepare(sql).all());
+  } finally {
+    sqlite.close();
+  }
+}
+
 export async function run(argv) {
   const { values } = parseArgs({
     args: argv,
@@ -256,6 +282,16 @@ export async function run(argv) {
   }
 
   if (runtime === "node") {
+    const threadCollectionPreflight = await withNodeMigrationQuery(
+      databaseDialect,
+      databaseUrl,
+      (query) =>
+        preflightThreadCollectionMigration({
+          dialect: databaseDialect === "pg" ? "pg" : "sqlite",
+          query,
+        }),
+    );
+
     if (debugMigrate && databaseDialect === "pg") {
       await logCliPgMigrationDebug(databaseUrl, "before");
     }
@@ -270,6 +306,16 @@ export async function run(argv) {
       throw error;
     }
 
+    await withNodeMigrationQuery(databaseDialect, databaseUrl, (query) =>
+      verifyThreadCollectionMigration(
+        {
+          dialect: databaseDialect === "pg" ? "pg" : "sqlite",
+          query,
+        },
+        threadCollectionPreflight,
+      ),
+    );
+
     if (debugMigrate && databaseDialect === "pg") {
       await logCliPgMigrationDebug(databaseUrl, "after");
     }
@@ -299,7 +345,16 @@ export async function run(argv) {
       env: values.env,
       persistTo: values["persist-to"],
     };
+    const query = (sql) => queryD1(sql, runtime, options);
+    const threadCollectionPreflight = await preflightThreadCollectionMigration({
+      dialect: "sqlite",
+      query,
+    });
     applyD1SchemaMigrations(runtime, options);
+    await verifyThreadCollectionMigration(
+      { dialect: "sqlite", query },
+      threadCollectionPreflight,
+    );
     applyD1Backfills(runtime, options);
   }
 

package/bin/commands/posts/rebuild-html.js

@@ -0,0 +1,184 @@
+import { parseArgs } from "node:util";
+import { resolveSiteUrl } from "../../lib/site-url.js";
+
+const INTERNAL_ADMIN_TOKEN_ENV_VAR = "INTERNAL_ADMIN_TOKEN";
+const DEFAULT_BATCH_SIZE = 50;
+const MAX_BATCH_SIZE = 100;
+
+function normalizeBaseUrl(value) {
+  const trimmed = value.trim();
+  return trimmed.endsWith("/") ? trimmed : `${trimmed}/`;
+}
+
+function buildRebuildUrl(siteUrl, siteId) {
+  const path = siteId
+    ? `api/internal/sites/${encodeURIComponent(siteId)}/posts/body-html/rebuild`
+    : "api/internal/posts/body-html/rebuild";
+  return new URL(path, normalizeBaseUrl(siteUrl)).toString();
+}
+
+function parseBatchSize(rawLimit) {
+  if (rawLimit === undefined) return DEFAULT_BATCH_SIZE;
+
+  const limit = Number.parseInt(rawLimit, 10);
+  if (!Number.isInteger(limit) || limit < 1 || limit > MAX_BATCH_SIZE) {
+    throw new Error(
+      `Batch size must be an integer between 1 and ${MAX_BATCH_SIZE}.`,
+    );
+  }
+  return limit;
+}
+
+async function requestBatch(url, token, { limit, cursor, dryRun }) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify({
+      limit,
+      ...(cursor ? { cursor } : {}),
+      ...(dryRun ? { dryRun: true } : {}),
+    }),
+  });
+
+  if (!response.ok) {
+    const responseText = await response.text();
+    throw new Error(
+      `HTTP ${response.status}: ${responseText || response.statusText}`,
+    );
+  }
+
+  return response.json();
+}
+
+function logBatchResult(batchIndex, result) {
+  console.log(
+    `  batch ${batchIndex}: processed=${result.processed} wouldRebuild=${result.wouldRebuild} rebuilt=${result.rebuilt} wouldUpgradeFootnotes=${result.wouldUpgradeFootnotes ?? 0} upgradedFootnotes=${result.upgradedFootnotes ?? 0} skipped=${result.skipped} conflicted=${result.conflicted} failed=${result.failed}`,
+  );
+  for (const failure of result.failures ?? []) {
+    console.error(`    ${failure.postId}: ${failure.error}`);
+  }
+}
+
+export async function run(argv) {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      config: { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      env: { type: "string" },
+      help: { type: "boolean", short: "h" },
+      limit: { type: "string" },
+      once: { type: "boolean", default: false },
+      site: { type: "string" },
+      token: { type: "string" },
+      url: { type: "string" },
+    },
+  });
+
+  if (values.help) {
+    console.log("Usage: jant posts rebuild-html [--url <url>] [options]");
+    console.log("");
+    console.log(
+      "Upgrade recognized legacy footnotes and rebuild stored post body HTML.",
+    );
+    console.log(
+      "The operation is site-scoped, cursor-paginated, and idempotent.",
+    );
+    console.log("");
+    console.log("Options:");
+    console.log("  --url           Target site or internal core URL");
+    console.log(
+      "  --site          Explicit managed site TypeID (host-based mode)",
+    );
+    console.log(
+      `  --limit         Batch size (default: ${DEFAULT_BATCH_SIZE}, max: ${MAX_BATCH_SIZE})`,
+    );
+    console.log("  --dry-run       Report changes without writing them");
+    console.log("  --once          Run one batch and exit");
+    console.log("  --token         Internal admin token");
+    console.log("  --config        Wrangler config file");
+    console.log("  --env           Wrangler environment name");
+    process.exit(0);
+  }
+
+  const siteUrl = resolveSiteUrl({
+    url: values.url,
+    config: values.config,
+    env: values.env,
+  });
+  if (!siteUrl) {
+    throw new Error(
+      "posts rebuild-html requires --url or SITE_ORIGIN in the environment or wrangler.toml.",
+    );
+  }
+
+  const token =
+    values.token?.trim() || process.env[INTERNAL_ADMIN_TOKEN_ENV_VAR]?.trim();
+  if (!token) {
+    throw new Error(
+      `posts rebuild-html requires --token or ${INTERNAL_ADMIN_TOKEN_ENV_VAR}.`,
+    );
+  }
+
+  const siteId = values.site?.trim();
+  const limit = parseBatchSize(values.limit);
+  const dryRun = values["dry-run"];
+  const rebuildUrl = buildRebuildUrl(siteUrl, siteId);
+  const scope = siteId ? `managed site ${siteId}` : siteUrl;
+
+  console.log(`${dryRun ? "Checking" : "Rebuilding"} post HTML for ${scope}`);
+  console.log(
+    `  batch size: ${limit}${values.once ? " (single batch)" : ""}${dryRun ? " (dry run)" : ""}`,
+  );
+
+  const totals = {
+    processed: 0,
+    wouldRebuild: 0,
+    rebuilt: 0,
+    wouldUpgradeFootnotes: 0,
+    upgradedFootnotes: 0,
+    skipped: 0,
+    conflicted: 0,
+    failed: 0,
+  };
+  let cursor;
+  let batchIndex = 0;
+  let targetVersion;
+
+  for (;;) {
+    batchIndex += 1;
+    const result = await requestBatch(rebuildUrl, token, {
+      limit,
+      cursor,
+      dryRun,
+    });
+    logBatchResult(batchIndex, result);
+
+    for (const key of Object.keys(totals)) {
+      totals[key] += result[key] ?? 0;
+    }
+    targetVersion = result.targetVersion;
+
+    if (values.once || result.done) break;
+    if (!result.nextCursor || result.nextCursor === cursor) {
+      throw new Error(
+        "Server reported more work without advancing the cursor; aborting.",
+      );
+    }
+    cursor = result.nextCursor;
+  }
+
+  console.log("");
+  console.log(
+    `Done. targetVersion=${targetVersion ?? "unknown"} processed=${totals.processed} wouldRebuild=${totals.wouldRebuild} rebuilt=${totals.rebuilt} wouldUpgradeFootnotes=${totals.wouldUpgradeFootnotes} upgradedFootnotes=${totals.upgradedFootnotes} skipped=${totals.skipped} conflicted=${totals.conflicted} failed=${totals.failed} batches=${batchIndex}`,
+  );
+
+  if (totals.failed > 0 || totals.conflicted > 0) {
+    throw new Error(
+      "Some rows were not rebuilt. Fix invalid bodies or rerun after concurrent edits settle.",
+    );
+  }
+}

package/bin/commands/site/snapshot/import.js

@@ -28,6 +28,7 @@ import {
   remapSnapshotObjectKey,
   rewriteLegacySnapshotSql,
   rewriteSnapshotSiteIdentifiers,
+  upgradeSnapshotSql,
   validateSnapshotTargetSite,
 } from "../../../lib/site-snapshot.js";
 import {
@@ -69,7 +70,7 @@ async function createNodeImportContext() {
       return nodeDatabase.query(sql);
     },
     async execute(sql) {
-      await nodeDatabase.execute(sql);
+      await nodeDatabase.executeAtomically(sql);
     },
     async uploadObject(key, filePath, contentType) {
       if (!storage) {
@@ -334,6 +335,18 @@ export async function run(argv) {
       join(materialized.rootDir, "db.sql"),
       "utf-8",
     );
+    const siteScopedDbSql = snapshotSite
+      ? shouldRemapSite
+        ? rewriteSnapshotSiteIdentifiers(
+            rawDbSql,
+            snapshotSite.id,
+            targetSite.id,
+          )
+        : rawDbSql
+      : rewriteLegacySnapshotSql(rawDbSql, targetSite.id);
+    // Upgrade compatibility SQL before touching target rows or storage.
+    // A malformed v1 post_collection reference therefore fails safely.
+    const dbSql = upgradeSnapshotSql(siteScopedDbSql, meta.version);
 
     // Preflight: every storage_key/poster_key referenced by db.sql must have
     // a corresponding file in objects/, or we'll end up with broken media
@@ -389,15 +402,6 @@ export async function run(argv) {
       );
     }
 
-    const dbSql = snapshotSite
-      ? shouldRemapSite
-        ? rewriteSnapshotSiteIdentifiers(
-            rawDbSql,
-            snapshotSite.id,
-            targetSite.id,
-          )
-        : rawDbSql
-      : rewriteLegacySnapshotSql(rawDbSql, targetSite.id);
     await context.execute(`${buildReplaceSql(targetSite.id)}\n${dbSql}`);
 
     const keysToDelete = [...currentKeys].filter(

package/bin/lib/d1-query.js

@@ -87,6 +87,23 @@ function extractJson(raw) {
   return raw.slice(start);
 }
 
+function getWranglerExecutionOptions(options) {
+  const executionOptions = { ...options };
+  for (const key of [
+    "configPath",
+    "database",
+    "env",
+    "persistTo",
+    "quiet",
+    "retryAttempts",
+    "retryDelayMs",
+    "trackedExecution",
+  ]) {
+    delete executionOptions[key];
+  }
+  return executionOptions;
+}
+
 function runWrangler(args, options = {}) {
   const retryAttempts = Math.max(
     1,
@@ -99,7 +116,7 @@ function runWrangler(args, options = {}) {
 
   for (let attempt = 1; attempt <= retryAttempts; attempt += 1) {
     try {
-      return runLocalWrangler(args, options);
+      return runLocalWrangler(args, getWranglerExecutionOptions(options));
     } catch (error) {
       const output = `${error.stdout ?? ""}${error.stderr ?? ""}`.trim();
       const wranglerError = parseWranglerError(output);
@@ -135,7 +152,7 @@ export function executeD1(sql, runtime, options = {}) {
   );
 
   if (options.quiet) {
-    const output = runWrangler([...args, "--json"]);
+    const output = runWrangler([...args, "--json"], options);
     const parsed = JSON.parse(extractJson(output));
     const statements = Array.isArray(parsed) ? parsed : [parsed];
 
@@ -148,7 +165,7 @@ export function executeD1(sql, runtime, options = {}) {
     return statements;
   }
 
-  runWrangler(args, { stdio: "inherit" });
+  runWrangler(args, { ...options, stdio: "inherit" });
 }
 
 export function queryD1(sql, runtime, options = {}) {
@@ -164,6 +181,7 @@ export function queryD1(sql, runtime, options = {}) {
       ],
       options,
     ),
+    options,
   );
   const parsed = JSON.parse(extractJson(output));
   const statement = Array.isArray(parsed) ? parsed[0] : parsed;
@@ -189,7 +207,7 @@ export function executeD1File(filePath, runtime, options = {}) {
   );
 
   if (options.quiet) {
-    const output = runWrangler([...args, "--json"]);
+    const output = runWrangler([...args, "--json"], options);
     const parsed = JSON.parse(extractJson(output));
     const statements = Array.isArray(parsed) ? parsed : [parsed];
 
@@ -202,5 +220,5 @@ export function executeD1File(filePath, runtime, options = {}) {
     return statements;
   }
 
-  runWrangler(args, { stdio: "inherit" });
+  runWrangler(args, { ...options, stdio: "inherit" });
 }

package/bin/lib/migration-runner.js

@@ -183,11 +183,21 @@ export function createD1SqlRunner(runtime, options) {
       executeD1(sql, runtime, { ...options, quiet: true });
     },
     executeTrackedFile(filePath, trackingSql) {
+      // A tracked schema/data migration is already atomic with its tracking
+      // insert. Do not let the lower-level Wrangler helper blindly replay a
+      // destructive batch after an ambiguous network response. The outer
+      // runner reconciles the tracking row instead.
+      const trackedOptions = {
+        ...options,
+        quiet: true,
+        retryAttempts: 1,
+      };
+
       if (trackedExecution === "segmented") {
         for (const statement of readSqlStatements(filePath)) {
-          executeD1(statement, runtime, { ...options, quiet: true });
+          executeD1(statement, runtime, trackedOptions);
         }
-        executeD1(trackingSql, runtime, { ...options, quiet: true });
+        executeD1(trackingSql, runtime, trackedOptions);
         return;
       }
 
@@ -200,7 +210,7 @@ export function createD1SqlRunner(runtime, options) {
             tempPath,
             `\n${readNormalizedSqlFile(filePath)}\n${trackingSql}\n`,
           );
-          executeD1File(tempPath, runtime, { ...options, quiet: true });
+          executeD1File(tempPath, runtime, trackedOptions);
         } finally {
           rmSync(tempDir, { recursive: true, force: true });
         }
@@ -210,10 +220,7 @@ export function createD1SqlRunner(runtime, options) {
       executeD1(
         `\n${readNormalizedSqlFile(filePath)}\n${trackingSql}`,
         runtime,
-        {
-          ...options,
-          quiet: true,
-        },
+        trackedOptions,
       );
     },
     query(sql) {
@@ -261,6 +268,21 @@ export function applyTrackedSqlFiles(runner, options) {
       }
       console.log(`[${index + 1}/${pendingFiles.length}] ${file.name} ✅`);
     } catch (error) {
+      // The database may have committed the atomic batch even if the client
+      // lost its response. Re-read the tracking table before reporting a
+      // failure; a committed marker means replay would be both unnecessary and
+      // unsafe for CREATE/COPY/DROP migrations.
+      try {
+        if (new Set(listAppliedNames(runner, tableName)).has(file.name)) {
+          console.log(
+            `[${index + 1}/${pendingFiles.length}] ${file.name} ✅ (confirmed after interrupted response)`,
+          );
+          continue;
+        }
+      } catch {
+        // Preserve the original execution failure when reconciliation itself
+        // cannot reach the database.
+      }
       console.log(`[${index + 1}/${pendingFiles.length}] ${file.name} ❌`);
       throw new Error(`Failed to apply ${file.name}: ${error.message}`, {
         cause: error,

package/bin/lib/node-database.js

@@ -5,6 +5,15 @@ function hasExecute(db) {
   return typeof db === "object" && db !== null && "execute" in db;
 }
 
+function hasTransaction(db) {
+  return (
+    typeof db === "object" &&
+    db !== null &&
+    "transaction" in db &&
+    typeof db.transaction === "function"
+  );
+}
+
 export async function openNodeDatabase(env = process.env) {
   const { createNodeBindings } = await loadNodeRuntime();
   const { bindings, close } = await createNodeBindings({
@@ -44,5 +53,28 @@ export async function openNodeDatabase(env = process.env) {
 
       await database.db.run(sql);
     },
+    async executeAtomically(sql) {
+      if (bindings.NODE_SQLITE) {
+        bindings.NODE_SQLITE.transaction(() => {
+          bindings.NODE_SQLITE.exec(sql);
+        })();
+        return;
+      }
+
+      if (!hasTransaction(database.db)) {
+        throw new Error(
+          `Atomic SQL execution is unavailable for the ${database.dialect} Node database driver.`,
+        );
+      }
+
+      await database.db.transaction(async (transaction) => {
+        if (!hasExecute(transaction)) {
+          throw new Error(
+            `Atomic SQL execution is unavailable for the ${database.dialect} transaction driver.`,
+          );
+        }
+        await transaction.execute(sql);
+      });
+    },
   };
 }