fix(FileStore): add case sensitivity detection for file operations

Author: hexqi

mockServer/src/store/FileStore.js

@@ -34,6 +34,13 @@ class FileStore extends StoreAdapter {
 
     // Ensure collection directory exists
     this.ensureDirectory()
+
+    // Detect whether the collection directory lives on a case-sensitive
+    // filesystem, so a file rename that only changes letter case (e.g.
+    // Login -> login) is handled correctly. On a case-insensitive FS (macOS
+    // APFS and Windows NTFS defaults) such a rename points at the same physical
+    // file, so writeAtomic + unlink would otherwise delete the just-written file.
+    this.caseSensitive = this.detectCaseSensitive()
   }
 
   ensureDirectory() {
@@ -45,6 +52,33 @@ class FileStore extends StoreAdapter {
     }
   }
 
+  /**
+   * Probe whether the collection directory lives on a case-sensitive filesystem
+   * by writing a marker file and checking whether a differently-cased name
+   * resolves to it. Returns true (case-sensitive) or false (case-insensitive),
+   * defaulting to false if probing fails so we never unlink on a case-only rename.
+   */
+  detectCaseSensitive() {
+    const probeName = `.casesens-${crypto.randomBytes(4).toString('hex')}`
+    const probePath = path.join(this.collectionPath, probeName)
+    try {
+      fs.writeFileSync(probePath, '')
+      // On a case-insensitive FS the upper-cased name resolves to the same file.
+      return !fs.existsSync(path.join(this.collectionPath, probeName.toUpperCase()))
+    } catch {
+      // Conservative default: treat as case-insensitive to avoid data loss.
+      return false
+    } finally {
+      try {
+        if (fs.existsSync(probePath)) {
+          fs.unlinkSync(probePath)
+        }
+      } catch {
+        /* best-effort cleanup of the probe file */
+      }
+    }
+  }
+
   /**
    * Generate a unique ID similar to NeDB's format
    */
@@ -343,7 +377,13 @@ class FileStore extends StoreAdapter {
       reservedNames.add(fileBaseName.toLowerCase())
 
       this.writeAtomic(targetPath, updatedDoc)
-      if (targetPath !== entry.filePath && fs.existsSync(entry.filePath)) {
+      // Only unlink the previous file when it is a genuinely different physical
+      // file. On a case-insensitive FS a case-only rename (Login -> login) points
+      // at the same file, so unlinking would delete the document we just wrote.
+      const pathsDiffer = this.caseSensitive
+        ? targetPath !== entry.filePath
+        : targetPath.toLowerCase() !== entry.filePath.toLowerCase()
+      if (pathsDiffer && fs.existsSync(entry.filePath)) {
         fs.unlinkSync(entry.filePath)
       }
     }

mockServer/test/store/adapter.contract.test.js

@@ -155,4 +155,17 @@ describe.each(adapterFactories)('%s honours the StoreAdapter contract', (_name,
 
     expect(await store.find({ tags: ['purple'] })).toHaveLength(0)
   })
+
+  test('updating a naming field to a case-only variant keeps the document', async () => {
+    await store.insert({ _id: 'login', name: 'Login' })
+    const affected = await store.update({ _id: 'login' }, { $set: { name: 'login' } })
+    expect(affected).toBe(1)
+    // The document must still exist and read back with the updated value.
+    // Regression guard: on a case-insensitive filesystem (macOS/Windows default)
+    // a case-only rename used to make FileStore unlink the just-written file.
+    const doc = await store.findOne({ _id: 'login' })
+    expect(doc).not.toBeNull()
+    expect(doc.name).toBe('login')
+    expect(await store.find({})).toHaveLength(1)
+  })
 })