Use atomicFS for every fs call in theme

atomicFS is moved into fileSystemHelpers, next to the atomicReplace.

Author: scriptype

src/e2e-tests/helpers.js

@@ -2,7 +2,7 @@ const { tmpdir } = require('os')
 const { join } = require('path')
 const test = require('tape')
 const writ = require('..')
-const { atomicFS } = require('./helpers')
+const { atomicFS } = require('../lib/fileSystemHelpers')
 
 test('Theme', t => {
 
@@ -483,4 +483,4 @@ test('Theme', t => {
     }
   })
 
-})
+})

src/e2e-tests/theme.test.js

@@ -1,6 +1,6 @@
 const fs = require('fs/promises')
 const { join } = require('path')
-const { tmpdir } = require('os')
+const { tmpdir, platform } = require('os')
 
 const readFileContent = path => {
   return fs.readFile(path, { encoding: 'utf-8' })
@@ -52,10 +52,81 @@ const atomicReplace = async (targetPath, buildFn) => {
   }
 }
 
+/*
+ * Retry an operation when Windows file handles prevent immediate access.
+ * On Windows, fs operations may fail with EBUSY if file handles aren't
+ * released yet. This retries the operation with backoff until it succeeds,
+ * mimicking the atomic pattern of building in isolation before swap.
+ */
+const atomicFS = (() => {
+  const sleep = (duration) => new Promise(resolve => setTimeout(resolve, duration))
+
+  const retryUntilSuccess = async (fn, maxRetries = 10, delayMS = 50) => {
+    if (platform() !== 'win32') {
+      return await fn()
+    }
+
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        return await fn()
+      } catch (error) {
+        if (error.code === 'EBUSY' && i < maxRetries - 1) {
+          console.log(`
+          * * * *
+          Caught EBUSY and retrying (${i}/${maxRetries})
+
+          function:
+          `)
+          console.log(fn.toString())
+          console.log(`
+          * * * *
+          `)
+          await sleep(delayMS)
+          continue
+        }
+        throw error
+      }
+    }
+  }
+
+  return {
+    readdir: (path) => retryUntilSuccess(() => fs.readdir(path)),
+
+    readdirRecursive: (path) => retryUntilSuccess(
+      () => fs.readdir(path, { recursive: true, withFileTypes: true })
+    ),
+
+    readFile: (path, encoding = 'utf-8') => retryUntilSuccess(
+      () => fs.readFile(path, encoding)
+    ),
+
+    rm: (path, options = { recursive: true, force: true }) => retryUntilSuccess(
+      () => fs.rm(path, options)
+    ),
+
+    mkdir: (path, options = { recursive: true }) => retryUntilSuccess(
+      () => fs.mkdir(path, options)
+    ),
+
+    writeFile: (path, data, options = 'utf-8') => retryUntilSuccess(
+      () => fs.writeFile(path, data, options)
+    ),
+
+    stat: (path) => retryUntilSuccess(() => fs.stat(path)),
+
+    cp: (src, dest, options = { recursive: true }) => retryUntilSuccess(
+      () => fs.cp(src, dest, options)
+    ),
+
+    mkdtemp: (prefix) => retryUntilSuccess(() => fs.mkdtemp(prefix))
+  }
+})()
+
 module.exports = {
   readFileContent,
   loadJSON,
   isDirectory,
   ensureDirectory,
-  atomicReplace
+  atomicReplace,
+  atomicFS
 }

src/lib/fileSystemHelpers.js

@@ -1,10 +1,9 @@
 const { tmpdir } = require('os')
-const { stat, rm, mkdir, mkdtemp, cp, readdir } = require('fs/promises')
 const { join } = require('path')
 const Debug = require('../debug')
 const Settings = require('../settings')
 const createDecorator = require('./decorator')
-const { atomicReplace } = require('../lib/fileSystemHelpers')
+const { atomicReplace, atomicFS } = require('../lib/fileSystemHelpers')
 const {
   ASSETS,
   PARTIALS,
@@ -40,7 +39,7 @@ const Methods = (() => {
 
   const customThemeExists = async (customThemePath) => {
     try {
-      return await stat(customThemePath)
+      return await atomicFS.stat(customThemePath)
     } catch {
       return false
     }
@@ -49,10 +48,12 @@ const Methods = (() => {
   const refreshCustomTheme = async (customThemePath) => {
     const backupKeepDir = async (keepPath) => {
       try {
-        if (await stat(keepPath)) {
-          const tempPath = await mkdtemp(join(tmpdir(), 'writ-theme-keep'))
+        if (await atomicFS.stat(keepPath)) {
+          const tempPath = await atomicFS.mkdtemp(
+            join(tmpdir(), 'writ-theme-keep')
+          )
           Debug.debugLog('refresh theme temp dir', tempPath)
-          await cp(keepPath, tempPath, { recursive: true })
+          await atomicFS.cp(keepPath, tempPath)
           return tempPath
         }
       } catch {
@@ -62,10 +63,7 @@ const Methods = (() => {
     }
 
     const applyKeepOverrides = async (keepBackupPath, themePath) => {
-      const entries = await readdir(keepBackupPath, {
-        recursive: true,
-        withFileTypes: true
-      })
+      const entries = await atomicFS.readdirRecursive(keepBackupPath)
 
       await Promise.all(
         entries
@@ -75,7 +73,7 @@ const Methods = (() => {
               entry.parentPath.replace(keepBackupPath, ''),
               entry.name
             )
-            return cp(
+            return atomicFS.cp(
               join(keepBackupPath, relativePath),
               join(themePath, relativePath)
             )
@@ -96,10 +94,8 @@ const Methods = (() => {
         })
 
         if (keepBackupPath) {
-          await mkdir(join(tempPath, KEEP_PATH), { recursive: true })
-          await cp(keepBackupPath, join(tempPath, KEEP_PATH), {
-            recursive: true
-          })
+          await atomicFS.mkdir(join(tempPath, KEEP_PATH))
+          await atomicFS.cp(keepBackupPath, join(tempPath, KEEP_PATH))
           await applyKeepOverrides(keepBackupPath, tempPath)
         }
       })
@@ -108,13 +104,13 @@ const Methods = (() => {
       throw e
     } finally {
       if (keepBackupPath) {
-        await rm(keepBackupPath, { recursive: true, force: true })
+        await atomicFS.rm(keepBackupPath)
       }
     }
   }
 
   const collectCustomizerPaths = async (customThemePath) => {
-    const paths = await readdir(customThemePath)
+    const paths = await atomicFS.readdir(customThemePath)
     const customizerPaths = paths.filter(p => {
       return p.endsWith('.css') || p.endsWith('.js')
     })
@@ -123,12 +119,11 @@ const Methods = (() => {
 
   const copyCommonResources = (targetPath) => {
     return Promise.all([
-      cp(
+      atomicFS.cp(
         join(__dirname, 'common', PARTIALS.from),
-        join(targetPath, PARTIALS.to),
-        { recursive: true }
+        join(targetPath, PARTIALS.to)
       ),
-      cp(
+      atomicFS.cp(
         join(__dirname, 'common', TEMPLATE_HELPERS.from),
         join(targetPath, PARTIALS.to, TEMPLATE_HELPERS.to)
       )
@@ -139,17 +134,15 @@ const Methods = (() => {
     const { theme } = Settings.getSettings()
     const themeSrcPath = join(__dirname, '..', '..', 'packages', `theme-${theme}`)
     return Promise.all([
-      cp(
+      atomicFS.cp(
         join(themeSrcPath, ASSETS),
-        join(customThemePath, ASSETS, theme),
-        { recursive: true }
+        join(customThemePath, ASSETS, theme)
       ),
-      cp(
+      atomicFS.cp(
         join(themeSrcPath, PARTIALS.from),
-        join(customThemePath, PARTIALS.to),
-        { recursive: true }
+        join(customThemePath, PARTIALS.to)
       ),
-      cp(
+      atomicFS.cp(
         join(themeSrcPath, THEME_SETTINGS),
         join(customThemePath, THEME_SETTINGS)
       )
@@ -161,14 +154,14 @@ const Methods = (() => {
   }
 
   const copyCustomizers = async (customThemePath) => {
-    const paths = await readdir(join(__dirname, 'customizers'))
+    const paths = await atomicFS.readdir(join(__dirname, 'customizers'))
     const customizers = paths.filter(p => {
       return p.endsWith('.css') || p.endsWith('.js')
     })
     State.customizers.push(...customizers)
     return Promise.all(
       paths.map(path => {
-        return cp(
+        return atomicFS.cp(
           join(__dirname, 'customizers', path),
           join(customThemePath, path)
         )
@@ -178,12 +171,12 @@ const Methods = (() => {
 
   const makeCustomThemeDirectory = async (customThemePath, options = {}) => {
     if (!options.skipContainer) {
-      await mkdir(customThemePath)
+      await atomicFS.mkdir(customThemePath)
     }
 
     await Promise.all([
-      mkdir(join(customThemePath, ASSETS)),
-      mkdir(join(customThemePath, PARTIALS.to))
+      atomicFS.mkdir(join(customThemePath, ASSETS)),
+      atomicFS.mkdir(join(customThemePath, PARTIALS.to))
     ])
 
     await copyCommonResources(customThemePath)