@oomol-lab/open-connector 1.6.4 → 1.6.5

package/src/server/files/transit-files.js

@@ -1,9 +1,8 @@
-import { once } from "node:events";
 import { createReadStream, createWriteStream } from "node:fs";
 import { mkdir, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { Readable } from "node:stream";
-import { finished } from "node:stream/promises";
+import { pipeline } from "node:stream/promises";
 import { assertFileSize, assertSafeFileId, contentTypeFromFileId, isSafeFileId, normalizeDescriptor, randomHex, safeExtension, TransitFileError, transitFileRead, transitFileResponse, uploadResult, } from "./transit-file-store.js";
 export class TransitFileService {
     rootDir;
@@ -18,19 +17,33 @@ export class TransitFileService {
     }
     async create(file) {
         assertFileSize(file.size, this.maxBytes);
-        await this.cleanupExpired();
-        await mkdir(this.rootDir, { recursive: true });
+        return this.createFromStream({ body: file.stream(), name: file.name, mimeType: file.type });
+    }
+    async createFromStream(file) {
         const fileId = `${randomHex(16)}${safeExtension(file.name)}`;
         const path = join(this.rootDir, fileId);
         const tempPath = `${path}.tmp`;
-        const sizeBytes = await this.writeFile(file, tempPath);
-        await rename(tempPath, path);
         const metadata = normalizeDescriptor({
             name: file.name || fileId,
-            mimeType: file.type || contentTypeFromFileId(fileId),
+            mimeType: file.mimeType || contentTypeFromFileId(fileId),
         });
-        await writeFile(metadataPath(path), JSON.stringify(metadata), { flag: "wx" });
-        return uploadResult(this.publicOrigin, fileId, { ...metadata, sizeBytes });
+        try {
+            file.signal?.throwIfAborted();
+            await this.cleanupExpired();
+            const sizeBytes = await this.writeStream(file, tempPath);
+            file.signal?.throwIfAborted();
+            await writeFile(metadataPath(path), JSON.stringify(metadata), { flag: "wx", signal: file.signal });
+            await rename(tempPath, path);
+            file.signal?.throwIfAborted();
+            return uploadResult(this.publicOrigin, fileId, { ...metadata, sizeBytes });
+        }
+        catch (error) {
+            if (!file.body.locked) {
+                await file.body.cancel(error).catch(() => undefined);
+            }
+            await Promise.all([tempPath, path, metadataPath(path)].map((filePath) => unlink(filePath).catch(() => undefined)));
+            throw error;
+        }
     }
     async createFromPath(file) {
         assertFileSize(file.sizeBytes, this.maxBytes);
@@ -114,34 +127,17 @@ export class TransitFileService {
             return fallback;
         }
     }
-    async writeFile(file, tempPath) {
-        const writer = createWriteStream(tempPath, { flags: "wx" });
-        const reader = file.stream().getReader();
+    async writeStream(file, tempPath) {
         let sizeBytes = 0;
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-                sizeBytes += value.byteLength;
-                assertFileSize(sizeBytes, this.maxBytes);
-                if (!writer.write(value)) {
-                    await once(writer, "drain");
-                }
+        const maxBytes = this.maxBytes;
+        await pipeline(Readable.fromWeb(file.body), async function* (source) {
+            for await (const chunk of source) {
+                sizeBytes += chunk.byteLength;
+                assertFileSize(sizeBytes, maxBytes);
+                yield chunk;
             }
-            writer.end();
-            await finished(writer);
-            return sizeBytes;
-        }
-        catch (error) {
-            writer.destroy();
-            await unlink(tempPath).catch(() => undefined);
-            throw error;
-        }
-        finally {
-            reader.releaseLock();
-        }
+        }, createWriteStream(tempPath, { flags: "wx" }), { signal: file.signal });
+        return sizeBytes;
     }
 }
 function isManagedFileName(fileName) {