fix: handle concurrent mkdir race in NIO's createDirectory (#312)

Co-authored-by: Pedro Piñera Buendía <pepicrft@Pedros-MacBook-Pro.local>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 3 people

Sources/FileSystem/FileSystem.swift

@@ -550,7 +550,17 @@ public struct FileSystem: FileSysteming, Sendable {
                         .contains(.createTargetParentDirectories)
                 )
             } catch let error as _NIOFileSystem.FileSystemError {
-                if error.code == .invalidArgument {
+                if error.code == .fileAlreadyExists,
+                   options.contains(.createTargetParentDirectories)
+                {
+                    // NIO's createDirectory has a race condition where concurrent calls
+                    // creating the same intermediate directory fail with EEXIST in its
+                    // rebuild loop. Retry — the intermediate now exists.
+                    try await _NIOFileSystem.FileSystem.shared.createDirectory(
+                        at: .init(at.pathString),
+                        withIntermediateDirectories: true
+                    )
+                } else if error.code == .invalidArgument {
                     throw FileSystemError.makeDirectoryAbsentParent(at)
                 } else {
                     throw error

Tests/FileSystemTests/FileSystemTests.swift

@@ -150,6 +150,45 @@ private struct TestError: Error, Equatable {}
             }
         }
 
+        func test_makeDirectory_concurrentCreationOfSharedIntermediateDirectories() async throws {
+            try await subject.runInTemporaryDirectory(prefix: "FileSystem") { temporaryDirectory in
+                // Given
+                // Multiple paths sharing the same intermediate directories
+                let moduleNames = (0 ..< 20).map { "Module\($0)" }
+
+                // When — create directories concurrently, all sharing the same intermediates
+                var errors: [Error] = []
+                await withTaskGroup(of: Error?.self) { group in
+                    for moduleName in moduleNames {
+                        group.addTask {
+                            do {
+                                let path = temporaryDirectory.appending(
+                                    components: "parent", "shared", moduleName
+                                )
+                                try await self.subject.makeDirectory(at: path)
+                                return nil
+                            } catch {
+                                return error
+                            }
+                        }
+                    }
+                    for await error in group {
+                        if let error { errors.append(error) }
+                    }
+                }
+
+                // Then — all directories should have been created without errors
+                XCTAssertTrue(errors.isEmpty, "Concurrent makeDirectory failed: \(errors)")
+                for moduleName in moduleNames {
+                    let path = temporaryDirectory.appending(
+                        components: "parent", "shared", moduleName
+                    )
+                    let exists = try await self.subject.exists(path, isDirectory: true)
+                    XCTAssertTrue(exists, "Directory should exist at \(path)")
+                }
+            }
+        }
+
         func test_writeTextFile_and_readTextFile_returnsTheContent() async throws {
             try await subject.runInTemporaryDirectory(prefix: "FileSystem") { temporaryDirectory in
                 // Given