Fix fs-in-worker test

Author: simolus3

sqlite3/assets/wasm/bridge.h

@@ -16,7 +16,7 @@ import_dart("xAccess") extern int xAccess(int vfs, const char *zName, int flags,
 import_dart("xFullPathname") extern int xFullPathname(int vfs, const char *zName, int nOut, char *zOut);
 import_dart("xRandomness") extern int xRandomness(int vfs, int nByte, char* zOut);
 import_dart("xSleep") extern int xSleep(int vfs, int microseconds);
-import_dart("xCurrentTimeInt64") extern int xCurrentTimeInt64(int vfs, int* target);
+import_dart("xCurrentTimeInt64") extern int xCurrentTimeInt64(int vfs, int64_t* target);
 
 import_dart("xClose") extern int xClose(int file);
 import_dart("xRead") extern int xRead(int, void*, int iAmt, sqlite3_int64 iOfst);

sqlite3/assets/wasm/helpers.c

@@ -150,7 +150,7 @@ static int dartvfs_sleep(sqlite3_vfs* vfs, int microseconds) {
 }
 
 static int dartvfs_currentTimeInt64(sqlite3_vfs* vfs, sqlite3_int64* timeOut) {
-  int milliseconds;
+  int64_t milliseconds;
   int rc = xCurrentTimeInt64((int) vfs->pAppData, &milliseconds);
 
   // https://github.com/sqlite/sqlite/blob/8ee75f7c3ac1456b8d941781857be27bfddb57d6/src/os_unix.c#L6757

sqlite3/example/web/worker.dart

@@ -33,16 +33,17 @@ void main() {
 
       final sqlite3 =
           await WasmSqlite3.loadFromUrl(Uri.parse('sqlite3.debug.wasm'));
-      sqlite3.registerVirtualFileSystem(WasmVfs(workerOptions: options),
+      sqlite3.registerVirtualFileSystem(
+          await SimpleOpfsFileSystem.loadFromStorage('worker-test'),
           makeDefault: true);
 
-      sqlite3.open('/tmp/foo.db')
+      sqlite3.open('/database')
         ..execute('pragma user_version = 1')
         ..execute('CREATE TABLE foo (bar INTEGER NOT NULL);')
         ..execute('INSERT INTO foo (bar) VALUES (?)', [3])
         ..dispose();
 
-      final db = sqlite3.open('/tmp/foo.db');
+      final db = sqlite3.open('/database');
       print(db.select('SELECT * FROM foo'));
     } else {
       final message = data as WorkerOptions;

sqlite3/lib/common.dart

@@ -9,3 +9,4 @@ export 'src/functions.dart';
 export 'src/result_set.dart';
 export 'src/sqlite3.dart';
 export 'src/statement.dart';
+export 'src/vfs.dart';

sqlite3/lib/src/wasm/js_interop/file_system_access.dart

@@ -118,7 +118,7 @@ extension FileSystemDirectoryHandleApi on FileSystemDirectoryHandle {
   }
 }
 
-extension FileSystemFileHandleAPi on FileSystemFileHandle {
+extension FileSystemFileHandleApi on FileSystemFileHandle {
   @JS('createSyncAccessHandle')
   external Object _createSyncAccessHandle();
 

sqlite3/lib/src/wasm/js_interop/typed_data.dart

@@ -4,6 +4,8 @@ import 'dart:typed_data';
 import 'package:js/js.dart';
 import 'package:js/js_util.dart';
 
+import 'core.dart';
+
 @JS('Uint8Array')
 external Object get _uint8Array;
 
@@ -53,3 +55,10 @@ extension NativeUint8List on Uint8List {
     callMethod<void>(this, 'set', [from, offset]);
   }
 }
+
+extension NativeDataView on ByteData {
+  void setBigInt64(int offset, JsBigInt value, bool littleEndian) {
+    callMethod<void>(
+        this, 'setBigInt64', [offset, value.jsObject, littleEndian]);
+  }
+}

sqlite3/lib/src/wasm/file_system/indexed_db.dart renamed to sqlite3/lib/src/wasm/vfs/indexed_db.dart

@@ -10,9 +10,10 @@ import 'package:js/js.dart';
 import 'package:meta/meta.dart';
 
 import '../../constants.dart';
-import '../file_system.dart';
+import '../../vfs.dart';
 import '../js_interop.dart';
 import 'memory.dart';
+import 'utils.dart';
 
 /// An (asynchronous) file system implementation backed by IndexedDB.
 ///
@@ -400,7 +401,7 @@ class _OffsetAndBuffer {
 ///
 /// In the future, we may want to store individual blocks instead.
 
-class IndexedDbFileSystem implements FileSystem {
+class IndexedDbFileSystem extends BaseVirtualFileSystem {
   final AsynchronousIndexedDbFileSystem _asynchronous;
 
   var _isClosing = false;
@@ -415,7 +416,8 @@ class IndexedDbFileSystem implements FileSystem {
 
   IndexedDbFileSystem._(String dbName)
       : _asynchronous = AsynchronousIndexedDbFileSystem(dbName),
-        _memory = InMemoryFileSystem();
+        _memory = InMemoryFileSystem(),
+        super(name: 'indexeddb');
 
   /// Loads an IndexedDB file system identified by the [dbName].
   ///
@@ -443,8 +445,7 @@ class IndexedDbFileSystem implements FileSystem {
     // https://github.com/dart-lang/sdk/issues/48854
     await self.indexedDB!.deleteDatabase(dbName).timeout(
         const Duration(milliseconds: 1000),
-        onTimeout: () => throw FileSystemException(
-            0, "Failed to delete database. Database is still open"));
+        onTimeout: () => throw VfsException(1));
   }
 
   /// Whether this file system is closing or closed.
@@ -500,7 +501,7 @@ class IndexedDbFileSystem implements FileSystem {
 
   void _checkClosed() {
     if (isClosed) {
-      throw FileSystemException(SqlError.SQLITE_IOERR, 'FileSystem closed');
+      throw VfsException(SqlError.SQLITE_IOERR);
     }
   }
 
@@ -534,94 +535,110 @@ class IndexedDbFileSystem implements FileSystem {
   }
 
   @override
-  void createFile(
-    String path, {
-    bool errorIfNotExists = false,
-    bool errorIfAlreadyExists = false,
-  }) {
-    _checkClosed();
-    final existsBefore = _memory.exists(path);
-    _memory.createFile(
-      path,
-      errorIfAlreadyExists: errorIfAlreadyExists,
-      errorIfNotExists: errorIfNotExists,
-    );
+  int xAccess(String path, int flags) => _memory.xAccess(path, flags);
 
-    if (!existsBefore) {
-      _submitWork(_CreateFileWorkItem(this, path));
+  @override
+  void xDelete(String path, int syncDir) {
+    _memory.xDelete(path, syncDir);
+
+    if (!_inMemoryOnlyFiles.remove(path)) {
+      _submitWork(_DeleteFileWorkItem(this, path));
     }
   }
 
   @override
-  String createTemporaryFile() {
-    _checkClosed();
-    final path = _memory.createTemporaryFile();
-    _inMemoryOnlyFiles.add(path);
-    return path;
-  }
+  String xFullPathName(String path) => _memory.xFullPathName(path);
 
   @override
-  void deleteFile(String path) {
-    _memory.deleteFile(path);
-
-    if (!_inMemoryOnlyFiles.remove(path)) {
-      _submitWork(_DeleteFileWorkItem(this, path));
+  XOpenResult xOpen(Sqlite3Filename path, int flags) {
+    final pathStr = path.path ?? random.randomFileName(prefix: '/');
+    final existedBefore = _memory.xAccess(pathStr, 0) != 0;
+
+    final inMemoryFile = _memory.xOpen(Sqlite3Filename(pathStr), flags);
+    final deleteOnClose = (flags & SqlFlag.SQLITE_OPEN_DELETEONCLOSE) != 0;
+
+    if (!existedBefore) {
+      if (deleteOnClose) {
+        // No point in persisting this file, it doesn't exist and won't exist
+        // after we're done.
+        _inMemoryOnlyFiles.add(pathStr);
+      } else {
+        _submitWork(_CreateFileWorkItem(this, pathStr));
+      }
     }
+
+    return XOpenResult(
+        outFlags: 0, file: _IndexedDbFile(this, inMemoryFile.file, pathStr));
   }
 
   @override
-  Future<void> clear() async {
-    _memory.clear();
-    await _submitWorkFunction(_asynchronous.clear, 'clear');
+  void xSleep(Duration duration) {
+    // noop
   }
+}
+
+class _IndexedDbFile extends VirtualFileSystemFile {
+  final IndexedDbFileSystem vfs;
+  final VirtualFileSystemFile memoryFile;
+  final String path;
+
+  _IndexedDbFile(this.vfs, this.memoryFile, this.path);
 
   @override
-  bool exists(String path) {
-    _checkClosed();
-    return _memory.exists(path);
+  void xRead(Uint8List target, int fileOffset) {
+    memoryFile.xRead(target, fileOffset);
   }
 
   @override
-  List<String> get files {
-    _checkClosed();
-    return _memory.files;
-  }
+  int get xDeviceCharacteristics => 0;
 
   @override
-  int read(String path, Uint8List target, int offset) {
-    _checkClosed();
-    return _memory.read(path, target, offset);
-  }
+  int xCheckReservedLock() => memoryFile.xCheckReservedLock();
 
   @override
-  int sizeOfFile(String path) {
-    _checkClosed();
-    return _memory.sizeOfFile(path);
+  void xClose() {}
+
+  @override
+  int xFileSize() => memoryFile.xFileSize();
+
+  @override
+  void xLock(int mode) => memoryFile.xLock(mode);
+
+  @override
+  void xSync(int flags) {
+    // We can't wait for a sync either way, so this just has to be a noop
   }
 
   @override
-  void truncateFile(String path, int length) {
-    _checkClosed();
-    _memory.truncateFile(path, length);
+  void xTruncate(int size) {
+    vfs._checkClosed();
+    memoryFile.xTruncate(size);
 
-    if (!_inMemoryOnlyFiles.contains(path)) {
-      _submitWorkFunction(
-          () async => _asynchronous.truncate(await _fileId(path), length),
+    if (!vfs._inMemoryOnlyFiles.contains(path)) {
+      vfs._submitWorkFunction(
+          () async => vfs._asynchronous.truncate(await vfs._fileId(path), size),
           'truncate $path');
     }
   }
 
   @override
-  void write(String path, Uint8List bytes, int offset) {
-    _checkClosed();
+  void xUnlock(int mode) => memoryFile.xUnlock(mode);
+
+  @override
+  void xWrite(Uint8List buffer, int fileOffset) {
+    vfs._checkClosed();
 
-    final previousContent = _memory.fileData[path] ?? Uint8List(0);
+    final previousContent = vfs._memory.fileData[path] ?? Uint8List(0);
+    memoryFile.xWrite(buffer, fileOffset);
 
-    _memory.write(path, bytes, offset);
+    if (!vfs._inMemoryOnlyFiles.contains(path)) {
+      // We need to copy the buffer for the write because it will become invalid
+      // after this synchronous method returns.
+      final copy = Uint8List(buffer.length);
+      copy.setAll(0, buffer);
 
-    if (!_inMemoryOnlyFiles.contains(path)) {
-      _submitWork(_WriteFileWorkItem(this, path, previousContent)
-        ..writes.add(_OffsetAndBuffer(offset, bytes)));
+      vfs._submitWork(_WriteFileWorkItem(vfs, path, previousContent)
+        ..writes.add(_OffsetAndBuffer(fileOffset, copy)));
     }
   }
 }

sqlite3/lib/src/wasm/vfs/simple_opfs.dart

@@ -170,6 +170,15 @@ class SimpleOpfsFileSystem extends BaseVirtualFileSystem {
 
   @override
   void xSleep(Duration duration) {}
+
+  /// Closes the synchronous access handles kept open while this file system is
+  /// active.
+  void close() {
+    _metaHandle.close();
+    for (final file in _files.values) {
+      file.close();
+    }
+  }
 }
 
 class _SimpleOpfsFile extends BaseVfsFile {
@@ -194,7 +203,7 @@ class _SimpleOpfsFile extends BaseVfsFile {
 
   @override
   void xClose() {
-    syncHandle.close();
+    syncHandle.flush();
 
     if (deleteOnClose) {
       vfs._markExists(type, false);

sqlite3/lib/src/wasm/wasm_interop.dart

@@ -7,7 +7,6 @@ import 'package:js/js.dart';
 
 import '../../wasm.dart';
 import '../implementation/bindings.dart';
-import '../vfs.dart';
 import 'bindings.dart';
 import 'js_interop.dart';
 
@@ -449,6 +448,11 @@ extension WrappedMemory on Memory {
     buffer.asInt32List()[pointer >> 2] = value;
   }
 
+  void setInt64Value(Pointer pointer, JsBigInt value) {
+    assert(pointer != 0, 'Null pointer dereference');
+    buffer.asByteData().setBigInt64(pointer, value, true);
+  }
+
   String readString(int address, [int? length]) {
     assert(address != 0, 'Null pointer dereference');
     return utf8.decode(buffer.asUint8List(address, length ?? strlen(address)));
@@ -554,7 +558,8 @@ class _InjectedValues {
 
           // dartvfs_currentTimeInt64 will turn this into the right value, it's
           // annoying to do in JS due to the lack of proper ints.
-          memory.setInt32Value(target, time.millisecondsSinceEpoch);
+          memory.setInt64Value(
+              target, JsBigInt.fromInt(time.millisecondsSinceEpoch));
         }),
         'xDeviceCharacteristics': allowInterop((int fd) {
           final file = callbacks.openedFiles[fd]!;

sqlite3/lib/wasm.dart

@@ -18,5 +18,7 @@ import 'package:meta/meta.dart';
 
 export 'common.dart' hide CommmonSqlite3;
 
+export 'src/wasm/vfs/memory.dart' show InMemoryFileSystem;
 export 'src/wasm/vfs/simple_opfs.dart' show SimpleOpfsFileSystem;
+export 'src/wasm/vfs/indexed_db.dart' show IndexedDbFileSystem;
 export 'src/wasm/sqlite3.dart';

sqlite3/test/wasm/sqlite3_test.dart

@@ -30,6 +30,8 @@ void main() {
           }
 
           sqlite3 = await WasmSqlite3.load(response.bodyBytes);
+          sqlite3.registerVirtualFileSystem(InMemoryFileSystem(),
+              makeDefault: true);
         }
       });
 
@@ -75,7 +77,7 @@ void main() {
       });
 
       // See worker.dart for the supported backends
-      for (final backend in ['memory', 'opfs', 'indexeddb']) {
+      for (final backend in ['memory', 'opfs-simple', 'indexeddb']) {
         test(backend, () async {
           final worker = Worker(workerUri);
 

sqlite3/test/wasm/utils.dart

@@ -1,12 +1,17 @@
 import 'package:sqlite3/wasm.dart';
 import 'package:test/scaffolding.dart';
 
-Future<WasmSqlite3> loadSqlite3([SqliteEnvironment? environment]) async {
+Future<WasmSqlite3> loadSqlite3([VirtualFileSystem? defaultVfs]) async {
   final channel = spawnHybridUri('/test/wasm/asset_server.dart');
   final port = await channel.stream.first as int;
 
   final sqliteWasm =
       Uri.parse('http://localhost:$port/example/web/sqlite3.wasm');
 
-  return WasmSqlite3.loadFromUrl(sqliteWasm, environment: environment);
+  final sqlite3 = await WasmSqlite3.loadFromUrl(sqliteWasm);
+  sqlite3.registerVirtualFileSystem(
+    defaultVfs ?? InMemoryFileSystem(),
+    makeDefault: true,
+  );
+  return sqlite3;
 }