explicity truncate files when not keeping existing data

scripts/test.ts

@@ -1,14 +1,20 @@
-import NodeFileSystemDirectoryHandle from '../dist/NodeFileSystemDirectoryHandle.js'
+import NodeFileSystemDirectoryHandle from '../src/NodeFileSystemDirectoryHandle.ts'
 
+const textText="Hello World!"
 const cwd_directory_handle = new NodeFileSystemDirectoryHandle('.')
-const test_directory_handle=await cwd_directory_handle.getDirectoryHandle('test',{'create':true})
+const test_directory_handle = await cwd_directory_handle.getDirectoryHandle('test', { 'create': true })
-const file_handle = await test_directory_handle.getFileHandle('test.txt', { 'create': true })
+for (let i = 0; i < 10000; i++) {
-const writable = await file_handle.createWritable()
+    const file_handle = await test_directory_handle.getFileHandle(i+'.txt', { 'create': true })
-writable.write('Hello World!')
+    let writable = await file_handle.createWritable()
-writable.close()
+    await writable.write(textText+textText)
-const file = await file_handle.getFile()
+    await writable.close()
-console.log(file.type)
+    writable = await file_handle.createWritable()
-console.log(await file.text())
+    await writable.write(textText)
+    await writable.close()
+    const file = await file_handle.getFile()
+    const text = await file.text()
+    if(text!==textText) throw new Error("failed to read back written data")
+}
 const result = await cwd_directory_handle.getFileHandle('test/test.txt').catch(error => 'blocked path traversal')
 if (typeof result === 'string') console.log(result)
 else console.error('path traversal not blocked')

src/NodeFileSystemFileHandle.ts

@@ -9,7 +9,7 @@ import type {
     FileSystemGetFileOptions,
     FileSystemCreateWritableOptions,
     FileSystemWritableFileStream,
-    File
+    File as WebFile
 } from '@sugoidogo/importable-types-web'
 
 export default class NodeFileSystemFileHandle extends NodeFileSystemHandle implements FileSystemFileHandle {
@@ -24,13 +24,10 @@ export default class NodeFileSystemFileHandle extends NodeFileSystemHandle imple
     async createWritable(options: FileSystemCreateWritableOptions = {}): Promise<FileSystemWritableFileStream> {
         return new NodeFileSystemWritableFileStream(this.path,options)
     }
-    async getFile(): Promise<File> {
+    async getFile(): Promise<WebFile> {
         const stats = await asyncfs.stat(this.path)
         const type = mime.getType(this.name.split('.').pop())
-        return asyncfs.readFile(this.path).then(buffer => Object.assign(new Blob([buffer], { type }), {
+        const buffer = await asyncfs.readFile(this.path)
-            lastModified: stats.mtimeMs,
+        return new File([buffer], this.path, { "lastModified": stats.mtimeMs, "type": type }) as any //TODO Node File and Web File have some incompatibilities
-            name: this.path,
-            webkitRelativePath: this.path
-        })) as unknown as File // TODO ArrayBufferView and DataView are incompatible types
     }
 }

src/NodeFileSystemWriteableFileStream.ts

@@ -1,5 +1,4 @@
 import * as fs from 'node:fs'
-import * as asyncfs from 'node:fs/promises'
 import * as path from 'node:path'
 import { Writable } from 'node:stream'
 import type {
@@ -11,34 +10,39 @@ import type {
 
 export default class NodeFileSystemWritableFileStream extends WritableStream implements FileSystemWritableFileStream {
     #seek_position = 0
-    #name: string
+    #fd: number
-    constructor(name: string, options: FileSystemCreateWritableOptions={}) {
+    constructor(name: string, options: FileSystemCreateWritableOptions = {}) {
         name = path.normalize(name)
-        super(Writable.toWeb(fs.createWriteStream(name)))
+        let flags = 'w'
-        this.#name = name
+        if (options.keepExistingData) flags = 'r+'
-        if(!options.keepExistingData) this.truncate(0)
+        const fd = fs.openSync(name, flags)
+        if (!options.keepExistingData) fs.ftruncateSync(fd, 0)
+        super(Writable.toWeb(fs.createWriteStream(name, { "fd": fd })))
+        this.#fd = fd
     }
     async seek(position: number): Promise<void> {
+        if (this.locked) throw new Error("stream is locked")
         this.#seek_position = position
     }
-    truncate(size: number): Promise<void> {
+    async truncate(size: number): Promise<void> {
-        return asyncfs.truncate(this.#name, size)
+        if (this.locked) throw new Error("stream is locked")
+        return fs.ftruncateSync(this.#fd, size)
     }
     async write(wdata: FileSystemWriteChunkType): Promise<void> {
+        if (this.locked) throw new Error("stream is locked")
         if (wdata instanceof Blob) wdata = await wdata.bytes()
         if (typeof wdata === 'string') wdata = new TextEncoder().encode(wdata)
         let wsize: number = null
         let pseek_position = this.#seek_position
         if ((wdata as WriteParams).type) {
             const { type, position, size, data } = (wdata as WriteParams)
-            if (type === 'truncate') return asyncfs.truncate(this.#name, size)
+            if (type === 'truncate') return this.truncate(size)
             if (position) this.#seek_position = position
             if (type === 'seek') return
             if (size) wsize = size
             wdata = data
         }
-        const file = await asyncfs.open(this.#name,'r+')
+        fs.writeSync(this.#fd, (wdata as Uint8Array), null, wsize, this.#seek_position)
-        await file.write((wdata as Uint8Array), null, wsize, this.#seek_position)
         this.#seek_position = pseek_position
     }
 }