@nyc-transit-kit/cli 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nyc-transit-kit/cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "sideEffects": false,
   "bin": {
@@ -23,13 +23,13 @@
     "test": "bun test ./test"
   },
   "dependencies": {
-    "@effect/platform-bun": "4.0.0-beta.83",
-    "@nyc-transit-kit/contracts": "0.1.0",
-    "@nyc-transit-kit/mta": "0.1.0",
-    "@nyc-transit-kit/nyc-dot": "0.1.0",
-    "@nyc-transit-kit/nyc-open-data": "0.1.0",
-    "@nyc-transit-kit/soda3": "0.1.0",
-    "effect": "4.0.0-beta.83"
+    "@effect/platform-bun": "4.0.0-beta.92",
+    "@nyc-transit-kit/contracts": "0.1.2",
+    "@nyc-transit-kit/mta": "0.1.2",
+    "@nyc-transit-kit/nyc-dot": "0.1.2",
+    "@nyc-transit-kit/nyc-open-data": "0.1.2",
+    "@nyc-transit-kit/soda3": "0.1.2",
+    "effect": "4.0.0-beta.92"
   },
   "publishConfig": {
     "access": "public"

package/src/commands/mta.ts

@@ -19,7 +19,7 @@ import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as Command from "effect/unstable/cli/Command"
 import * as Flag from "effect/unstable/cli/Flag"
-import { atomicWrite } from "../files"
+import { atomicWriteGroup } from "../files"
 import { failCommand, missingOption, runEffect, soqlFromSelect, writeSuccess } from "./shared"
 import { fileWriteError, writeResponseToFile, writeSoda3QueryDryRun } from "./soda3-shared"
 import { CliCommandContext, type CommandContext } from "./types"
@@ -436,11 +436,17 @@ export const handleMtaGtfsRealtimeCapture = (config: {
         })
 
         yield* Effect.tryPromise({
-          try: () => atomicWrite(config.output, result.bytes),
-          catch: fileWriteError
-        })
-        yield* Effect.tryPromise({
-          try: () => atomicWrite(config.manifestOutput, `${JSON.stringify(manifest, null, 2)}\n`),
+          try: () =>
+            atomicWriteGroup([
+              {
+                path: config.output,
+                body: result.bytes
+              },
+              {
+                path: config.manifestOutput,
+                body: `${JSON.stringify(manifest, null, 2)}\n`
+              }
+            ]),
           catch: fileWriteError
         })
 

package/src/files.ts

@@ -1,4 +1,4 @@
-import { rename } from "node:fs/promises"
+import { lstat, rename, rm } from "node:fs/promises"
 
 export type AtomicWriteBody =
   | Blob
@@ -8,20 +8,94 @@ export type AtomicWriteBody =
   | Bun.Archive
   | Response
 
-export const atomicWrite = async (path: string, body: AtomicWriteBody) => {
-  const tempPath = `${path}.tmp-${process.pid}`
+export type AtomicWriteEntry = {
+  readonly path: string
+  readonly body: AtomicWriteBody
+}
+
+type StagedWrite = AtomicWriteEntry & {
+  readonly tempPath: string
+  readonly backupPath: string
+  backedUp: boolean
+  committed: boolean
+}
+
+const writeBody = async (path: string, body: AtomicWriteBody) => {
+  if (body instanceof Response) {
+    await Bun.file(path).write(body)
+  } else {
+    await Bun.write(path, body)
+  }
+}
+
+const removeFile = (path: string) => rm(path, { force: true }).catch(() => undefined)
+
+const assertUniqueTargets = (entries: ReadonlyArray<AtomicWriteEntry>) => {
+  const seen = new Set<string>()
+  for (const entry of entries) {
+    if (seen.has(entry.path)) {
+      throw new Error(`Duplicate atomic write target: ${entry.path}`)
+    }
+    seen.add(entry.path)
+  }
+}
+
+const backupExistingTarget = async (write: StagedWrite) => {
+  try {
+    const stat = await lstat(write.path)
+    if (stat.isDirectory()) {
+      throw new Error(`Atomic write target is a directory: ${write.path}`)
+    }
+    await rename(write.path, write.backupPath)
+    write.backedUp = true
+  } catch (cause) {
+    if (typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ENOENT") {
+      return
+    }
+    throw cause
+  }
+}
+
+export const atomicWriteGroup = async (entries: ReadonlyArray<AtomicWriteEntry>) => {
+  assertUniqueTargets(entries)
+  const batchId = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  const writes = entries.map((entry, index) => ({
+    ...entry,
+    tempPath: `${entry.path}.tmp-${batchId}-${index}`,
+    backupPath: `${entry.path}.bak-${batchId}-${index}`,
+    backedUp: false,
+    committed: false
+  }))
 
   try {
-    if (body instanceof Response) {
-      await Bun.file(tempPath).write(body)
-    } else {
-      await Bun.write(tempPath, body)
+    for (const write of writes) {
+      await writeBody(write.tempPath, write.body)
+    }
+
+    for (const write of writes) {
+      await backupExistingTarget(write)
+      await rename(write.tempPath, write.path)
+      write.committed = true
+    }
+
+    for (const write of writes) {
+      if (write.backedUp) {
+        await removeFile(write.backupPath)
+      }
     }
-    await rename(tempPath, path)
   } catch (cause) {
-    await Bun.file(tempPath)
-      .delete()
-      .catch(() => undefined)
+    for (const write of writes.toReversed()) {
+      if (write.committed) {
+        await removeFile(write.path)
+      }
+      if (write.backedUp) {
+        await rename(write.backupPath, write.path).catch(() => undefined)
+      }
+      await removeFile(write.tempPath)
+    }
     throw cause
   }
 }
+
+export const atomicWrite = async (path: string, body: AtomicWriteBody) =>
+  atomicWriteGroup([{ path, body }])