Create polished demo videos without editing skills. Mac/Windows/Linux
fix(project): make project saves atomic
wiiiii1234ade9d8e16d2
diff --git a/electron/ipc/project/atomicSave.test.ts b/electron/ipc/project/atomicSave.test.tsnew file mode 100644index 00000000..07c9534f--- /dev/null+++ b/electron/ipc/project/atomicSave.test.ts@@ -0,0 +1,103 @@+import fs from "node:fs/promises";+import os from "node:os";+import path from "node:path";+import { afterEach, beforeEach, describe, expect, it } from "vitest";++import { getProjectBackupPath, writeProjectFileAtomically } from "./atomicSave";++describe("writeProjectFileAtomically", () => {+ let tempDir: string;+ let projectPath: string;++ beforeEach(async () => {+ tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "recordly-atomic-project-"));+ projectPath = path.join(tempDir, "demo.recordly");+ });++ afterEach(async () => {+ await fs.rm(tempDir, { recursive: true, force: true });+ });++ async function expectNoTemporaryArtifacts() {+ const entries = await fs.readdir(tempDir);+ expect(entries.filter((entry) => entry.endsWith(".tmp"))).toEqual([]);+ }++ it("commits a complete new project without creating a backup", async () => {+ await writeProjectFileAtomically(projectPath, '{"version":1}');++ await expect(fs.readFile(projectPath, "utf-8")).resolves.toBe('{"version":1}');+ await expect(fs.access(getProjectBackupPath(projectPath))).rejects.toMatchObject({+ code: "ENOENT",+ });+ await expectNoTemporaryArtifacts();+ });++ it("removes a stale backup when the target has no previous generation", async () => {+ await fs.writeFile(getProjectBackupPath(projectPath), "stale-project");++ await writeProjectFileAtomically(projectPath, '{"version":1}');++ await expect(fs.access(getProjectBackupPath(projectPath))).rejects.toMatchObject({+ code: "ENOENT",+ });+ });++ it("preserves the previous complete generation before replacement", async () => {+ await writeProjectFileAtomically(projectPath, '{"version":1,"name":"old"}');+ await writeProjectFileAtomically(projectPath, '{"version":1,"name":"new"}');++ await expect(fs.readFile(projectPath, "utf-8")).resolves.toBe('{"version":1,"name":"new"}');+ await expect(fs.readFile(getProjectBackupPath(projectPath), "utf-8")).resolves.toBe(+ '{"version":1,"name":"old"}',+ );+ await expectNoTemporaryArtifacts();+ });++ it("keeps the active generation unchanged when backup commit fails", async () => {+ await writeProjectFileAtomically(projectPath, '{"version":1,"name":"old"}');+ await fs.mkdir(getProjectBackupPath(projectPath));++ await expect(+ writeProjectFileAtomically(projectPath, '{"version":1,"name":"new"}'),+ ).rejects.toBeDefined();++ await expect(fs.readFile(projectPath, "utf-8")).resolves.toBe('{"version":1,"name":"old"}');++ await fs.rm(getProjectBackupPath(projectPath), { recursive: true });+ await writeProjectFileAtomically(projectPath, '{"version":1,"name":"retry"}');+ await expect(fs.readFile(projectPath, "utf-8")).resolves.toBe(+ '{"version":1,"name":"retry"}',+ );+ await expect(fs.readFile(getProjectBackupPath(projectPath), "utf-8")).resolves.toBe(+ '{"version":1,"name":"old"}',+ );+ await expectNoTemporaryArtifacts();+ });++ it("serializes overlapping writes to the same project", async () => {+ await writeProjectFileAtomically(projectPath, '{"revision":1}');++ await Promise.all([+ writeProjectFileAtomically(projectPath, '{"revision":2}'),+ writeProjectFileAtomically(projectPath, '{"revision":3}'),+ ]);++ await expect(fs.readFile(projectPath, "utf-8")).resolves.toBe('{"revision":3}');+ await expect(fs.readFile(getProjectBackupPath(projectPath), "utf-8")).resolves.toBe(+ '{"revision":2}',+ );+ await expectNoTemporaryArtifacts();+ });++ it.skipIf(process.platform === "win32")(+ "preserves existing project permission bits on replacement",+ async () => {+ await fs.writeFile(projectPath, '{"revision":1}', { mode: 0o600 });++ await writeProjectFileAtomically(projectPath, '{"revision":2}');++ expect((await fs.stat(projectPath)).mode & 0o777).toBe(0o600);+ },+ );+});diff --git a/electron/ipc/project/atomicSave.ts b/electron/ipc/project/atomicSave.tsnew file mode 100644index 00000000..d4942e10--- /dev/null+++ b/electron/ipc/project/atomicSave.ts@@ -0,0 +1,143 @@+import { randomUUID } from "node:crypto";+import { constants as fsConstants } from "node:fs";+import fs from "node:fs/promises";+import path from "node:path";++const pendingWrites = new Map<string, Promise<void>>();++const unsupportedDirectorySyncErrors = new Set([+ "EACCES",+ "EINVAL",+ "EISDIR",+ "ENOSYS",+ "ENOTSUP",+ "EOPNOTSUPP",+ "EPERM",+]);++export function getProjectBackupPath(projectPath: string): string {+ return `${projectPath}.bak`;+}++function getQueueKey(projectPath: string): string {+ const resolvedPath = path.resolve(projectPath);+ return process.platform === "win32" ? resolvedPath.toLowerCase() : resolvedPath;+}++function createTemporaryPath(parentDir: string, label: string): string {+ return path.join(parentDir, `.recordly-${label}-${process.pid}-${randomUUID()}.tmp`);+}++async function getExistingFileMode(filePath: string): Promise<number | undefined> {+ try {+ return (await fs.stat(filePath)).mode & 0o777;+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code === "ENOENT") {+ return undefined;+ }+ throw error;+ }+}++async function writeSyncedTemporaryFile(+ filePath: string,+ contents: string,+ mode?: number,+): Promise<void> {+ const handle = await fs.open(filePath, "wx", mode);+ try {+ await handle.writeFile(contents, "utf-8");+ await handle.sync();+ } finally {+ await handle.close();+ }+}++async function syncExistingFile(filePath: string): Promise<void> {+ const handle = await fs.open(filePath, "r+");+ try {+ await handle.sync();+ } finally {+ await handle.close();+ }+}++async function syncParentDirectory(parentDir: string): Promise<void> {+ if (process.platform === "win32") {+ return;+ }++ try {+ const handle = await fs.open(parentDir, "r");+ try {+ await handle.sync();+ } finally {+ await handle.close();+ }+ } catch (error) {+ const code = (error as NodeJS.ErrnoException).code;+ if (!code || !unsupportedDirectorySyncErrors.has(code)) {+ throw error;+ }+ }+}++async function preservePreviousGeneration(+ targetPath: string,+ backupPath: string,+ backupTemporaryPath: string,+): Promise<void> {+ try {+ await fs.copyFile(targetPath, backupTemporaryPath, fsConstants.COPYFILE_EXCL);+ } catch (error) {+ if ((error as NodeJS.ErrnoException).code === "ENOENT") {+ await fs.rm(backupPath, { force: true });+ return;+ }+ throw error;+ }++ await syncExistingFile(backupTemporaryPath);+ await fs.rename(backupTemporaryPath, backupPath);+}++async function commitProjectFile(projectPath: string, contents: string): Promise<void> {+ const targetPath = path.resolve(projectPath);+ const parentDir = path.dirname(targetPath);+ const backupPath = getProjectBackupPath(targetPath);+ const temporaryPath = createTemporaryPath(parentDir, "project");+ const backupTemporaryPath = createTemporaryPath(parentDir, "backup");+ const existingMode = await getExistingFileMode(targetPath);++ try {+ await writeSyncedTemporaryFile(temporaryPath, contents, existingMode);+ await preservePreviousGeneration(targetPath, backupPath, backupTemporaryPath);+ await fs.rename(temporaryPath, targetPath);+ await syncParentDirectory(parentDir);+ } finally {+ await Promise.all([+ fs.rm(temporaryPath, { force: true }).catch(() => undefined),+ fs.rm(backupTemporaryPath, { force: true }).catch(() => undefined),+ ]);+ }+}++export async function writeProjectFileAtomically(+ projectPath: string,+ contents: string,+): Promise<void> {+ const queueKey = getQueueKey(projectPath);+ const previousWrite = pendingWrites.get(queueKey) ?? Promise.resolve();+ const currentWrite = previousWrite+ .catch(() => undefined)+ .then(() => commitProjectFile(projectPath, contents));+ pendingWrites.set(queueKey, currentWrite);++ try {+ await currentWrite;+ } finally {+ if (pendingWrites.get(queueKey) === currentWrite) {+ pendingWrites.delete(queueKey);+ }+ }+}diff --git a/electron/ipc/register/project.ts b/electron/ipc/register/project.tsindex 61dbdbaa..59b992e8 100644--- a/electron/ipc/register/project.ts+++ b/electron/ipc/register/project.ts@@ -9,6 +9,7 @@ import {LEGACY_PROJECT_FILE_EXTENSIONS,PROJECT_FILE_EXTENSION,} from "../constants";+import { writeProjectFileAtomically } from "../project/atomicSave";import {getProjectsDir,getProjectThumbnailPath,@@ -305,7 +306,10 @@ export function registerProjectHandlers() {: nullif (trustedExistingProjectPath) {- await fs.writeFile(trustedExistingProjectPath, JSON.stringify(preparedProject.projectData, null, 2), 'utf-8')+ await writeProjectFileAtomically(+ trustedExistingProjectPath,+ JSON.stringify(preparedProject.projectData, null, 2),+ )setCurrentProjectPath(trustedExistingProjectPath)await saveProjectThumbnail(trustedExistingProjectPath, thumbnailDataUrl)await rememberRecentProject(trustedExistingProjectPath)@@ -345,7 +349,10 @@ export function registerProjectHandlers() {}}- await fs.writeFile(result.filePath, JSON.stringify(preparedProject.projectData, null, 2), 'utf-8')+ await writeProjectFileAtomically(+ result.filePath,+ JSON.stringify(preparedProject.projectData, null, 2),+ )setCurrentProjectPath(result.filePath)await saveProjectThumbnail(result.filePath, thumbnailDataUrl)await rememberRecentProject(result.filePath)@@ -411,7 +418,10 @@ export function registerProjectHandlers() {return overwriteCheck}- await fs.writeFile(targetProjectPath, JSON.stringify(preparedProject.projectData, null, 2), 'utf-8')+ await writeProjectFileAtomically(+ targetProjectPath,+ JSON.stringify(preparedProject.projectData, null, 2),+ )await saveProjectThumbnail(targetProjectPath, thumbnailDataUrl)await rememberRecentProject(targetProjectPath)