FS Journal: Handle renaming OPFS files via delete + create (instead of file.move()) (#64)

## Rationale

With this commit, objects pulled from a Git repo are correctly stored in
OPFS. Before, each object was correctly stored in MEMFS, but in OPFS it
was reflected as a 0 bytes file.

 ## Technical details

This commit ditches the OPFS file.move() method for renaming files.

Why?

Each object pulled from a Git repository is first buffered in a file
called ".tmp" and then renamed to its final name. However, the WRITE
operation does not store the written bytes, only the path.

By the time the filesystem journal is flushed, we cannot assume that the
"rename from" path still contains the same bytes as it did when the
WRITE operation was executed. Therefore, it's safer to delete the old
file and create a new one.

It is still possible that the new file was already deleted or renamed to
another location. That's fine. A later stage of replaying the journal
will take care of that.

Ideally, PHP.wasm would not use journaling at all, but a native WASMFS
layer for handling OPFS.

See #1878 for more
details.

 ## Testing instructions

Unfortunately, we don't have a unit test suite for the MEMFS<->OPFS
journaling.

Here's a manual test you can perform:

Create a new OPFS site and run this in devtools:

```php
playground.run({ code: `<?php
file_put_contents('/wordpress/test.txt', 'abc');
rename('/wordpress/test.txt', '/wordpress/test2.txt');
var_dump(file_get_contents('/wordpress/test2.txt'));
?>`}).then(t => console.log(t.text), console.log)
```

Now refresh the page and confirm the test2.txt file is not empty:

```ts
await playground.readFileAsText("/wordpress/test2.txt");
```

Author: adamziel

packages/php-wasm/web/src/lib/directory-handle-mount.ts

@@ -5,7 +5,7 @@ import {
 	PHP,
 	__private__dont__use,
 } from '@php-wasm/universal';
-import { Semaphore, joinPaths } from '@php-wasm/util';
+import { Semaphore, basename, joinPaths } from '@php-wasm/util';
 import { logger } from '@php-wasm/logger';
 import { FilesystemOperation, journalFSEvents } from '@php-wasm/fs-journal';
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -370,7 +370,6 @@ class OpfsRewriter {
 					this.opfs,
 					opfsTargetPath
 				);
-				const targetName = getFilename(opfsTargetPath);
 
 				if (entry.nodeType === 'directory') {
 					const opfsDir = await opfsTargetParent.getDirectoryHandle(
@@ -391,8 +390,41 @@ class OpfsRewriter {
 						recursive: true,
 					});
 				} else {
-					const file = await opfsParent.getFileHandle(name);
-					file.move(opfsTargetParent, targetName);
+					/**
+					 * Delete the old file and creating a new one.
+					 *
+					 * We cannot use the OPFS move() method here. Imagine pulling from
+					 * a Git repository – each pulled object is first buffered in a
+					 * file called ".tmp" and then renamed to its final name. However,
+					 * the WRITE operation does not store the written bytes, only the
+					 * path.
+					 *
+					 * By the time the filesystem journal is flushed, we cannot
+					 * assume that the "rename from" path still contains the same bytes
+					 * as it did when the WRITE operation was executed. Therefore, it's
+					 * safer to delete the old file and create a new one.
+					 *
+					 * It is still possible that the new file was already deleted
+					 * or renamed to another location. That's fine. A later stage
+					 * of replaying the journal will take care of that.
+					 *
+					 * Ideally, PHP.wasm would not use journaling at all, but
+					 * a native WASMFS layer for handling OPFS.
+					 *
+					 * See https://github.com/WordPress/wordpress-playground/pull/1878
+					 * for more details.
+					 */
+					try {
+						await opfsParent.removeEntry(name);
+					} catch (e) {
+						// If the directory already doesn't exist, it's fine
+					}
+					await overwriteOpfsFile(
+						opfsTargetParent,
+						basename(opfsTargetPath),
+						this.php[__private__dont__use].FS,
+						entry.toPath
+					);
 				}
 			}
 		} catch (e) {