rac-delta 1.0.13 → 1.0.15

package/dist/infrastructure/chunk-sources/storage-chunk-source.js

@@ -80,7 +80,7 @@ class StorageChunkSource {
                         if (!stream) {
                             throw new exceptions_1.ChunkNotFoundException(`${hash} not found in storage`);
                         }
-                        const pass = new stream_1.PassThrough({ highWaterMark: 64 * 1024 });
+                        const pass = new stream_1.PassThrough({ highWaterMark: 1024 * 1024 });
                         stream.on('error', (err) => {
                             workerError = err instanceof Error ? err : new Error(String(err));
                             controller.abort();

package/dist/infrastructure/services/memory-reconstruction-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-reconstruction-service.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/services/memory-reconstruction-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAyB,MAAM,QAAQ,CAAC;AAIzD,OAAO,EACL,WAAW,EAEX,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,SAAS,EAAS,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,2BAA4B,YAAW,qBAAqB;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAE5C,cAAc,CAClB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACvC,OAAO,CAAC,IAAI,CAAC;IAmFV,eAAe,CACnB,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,qBAIR,GACA,OAAO,CAAC,IAAI,CAAC;IAgDV,mBAAmB,CACvB,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,WAAW,EACxB,cAAc,GAAE,MAAU,GACzB,OAAO,CAAC,QAAQ,CAAC;YAmCN,UAAU;IASxB,oEAAoE;YACtD,kBAAkB;IAiChC,oFAAoF;YACtE,iBAAiB;IAmF/B;;;OAGG;YACW,qBAAqB;YA2BrB,YAAY;YAcZ,aAAa;YAuDZ,gBAAgB;CAmChC"}
+{"version":3,"file":"memory-reconstruction-service.d.ts","sourceRoot":"","sources":["../../../src/infrastructure/services/memory-reconstruction-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAyB,MAAM,QAAQ,CAAC;AAIzD,OAAO,EACL,WAAW,EAEX,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,SAAS,EAAE,SAAS,EAAS,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,qBAAa,2BAA4B,YAAW,qBAAqB;IAC3D,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAE5C,cAAc,CAClB,IAAI,EAAE,SAAS,EACf,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACvC,OAAO,CAAC,IAAI,CAAC;IAmFV,eAAe,CACnB,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,WAAW,EACxB,OAAO,GAAE,qBAIR,GACA,OAAO,CAAC,IAAI,CAAC;IAgDV,mBAAmB,CACvB,KAAK,EAAE,SAAS,EAChB,WAAW,EAAE,WAAW,EACxB,cAAc,GAAE,MAAU,GACzB,OAAO,CAAC,QAAQ,CAAC;YA6CN,UAAU;IASxB,oEAAoE;YACtD,kBAAkB;IAiChC,oFAAoF;YACtE,iBAAiB;IAmF/B;;;OAGG;YACW,qBAAqB;YA2BrB,YAAY;YAcZ,aAAa;YAyCZ,gBAAgB;CAmChC"}

package/dist/infrastructure/services/memory-reconstruction-service.js

@@ -112,31 +112,42 @@ class MemoryReconstructionService {
     }
     // This will reconstruct to stream, not to disk
     async reconstructToStream(entry, chunkSource, maxConcurrency = 5) {
-        const output = new stream_1.PassThrough({ highWaterMark: 1024 * 1024 });
         const chunks = entry.chunks ?? [];
-        // Starts async reconstruction without blocking stream return
-        const processChunks = async () => {
+        const iterator = this.fetchChunksSmart(chunks, chunkSource, true);
+        const pass = new stream_1.PassThrough({ highWaterMark: 2 * 1024 * 1024 });
+        (async () => {
             try {
                 const active = new Set();
-                for await (const { data } of this.fetchChunksSmart(chunks, chunkSource)) {
+                for await (const { data } of iterator) {
                     const task = (async () => {
-                        await this.writeToStream(data, output);
+                        if (Buffer.isBuffer(data)) {
+                            if (!pass.write(data)) {
+                                await new Promise((resolve) => pass.once('drain', resolve));
+                            }
+                        }
+                        else {
+                            await new Promise((resolve, reject) => {
+                                data.on('error', reject);
+                                pass.on('error', reject);
+                                data.pipe(pass, { end: false });
+                                data.on('end', resolve);
+                            });
+                        }
                     })();
-                    task.finally(() => active.delete(task));
                     active.add(task);
+                    task.finally(() => active.delete(task));
                     if (active.size >= maxConcurrency) {
-                        await Promise.race(active);
+                        const finished = await Promise.race(active);
                     }
                 }
                 await Promise.all(active);
-                output.end();
+                pass.end();
             }
             catch (err) {
-                output.destroy(err instanceof Error ? err : new Error(String(err)));
+                pass.destroy(err instanceof Error ? err : new Error(String(err)));
             }
-        };
-        void processChunks();
-        return output;
+        })();
+        return pass;
     }
     async fileExists(path) {
         try {
@@ -272,41 +283,28 @@ class MemoryReconstructionService {
             return;
         }
         if (Buffer.isBuffer(data)) {
-            const canContinue = stream.write(data);
-            if (!canContinue) {
+            if (!stream.write(data)) {
                 await new Promise((resolve) => stream.once('drain', resolve));
             }
             onFinish?.(data.length);
             return;
         }
         let totalBytes = 0;
-        await new Promise((resolve, reject) => {
-            const onError = (err) => {
-                cleanup();
-                reject(err instanceof Error ? err : new Error(String(err)));
-            };
-            const onEnd = () => {
-                cleanup();
-                onFinish?.(totalBytes);
-                resolve();
-            };
-            const cleanup = () => {
-                data.off('error', onError);
-                data.off('end', onEnd);
-                stream.off('error', onError);
-            };
-            data.on('error', onError);
-            stream.on('error', onError);
-            data.on('end', onEnd);
-            data.on('data', (chunk) => {
+        await (0, promises_2.pipeline)(data, new stream_1.Writable({
+            write(chunk, _encoding, callBack) {
                 totalBytes += chunk.length;
-                const canContinue = stream.write(chunk);
-                if (!canContinue) {
-                    data.pause();
-                    stream.once('drain', () => data.resume());
+                if (!stream.write(chunk)) {
+                    stream.once('drain', callBack);
                 }
-            });
-        });
+                else {
+                    callBack();
+                }
+            },
+            final(callBack) {
+                callBack();
+            },
+        }));
+        onFinish?.(totalBytes);
     }
     async *fetchChunksSmart(chunks, chunkSource, preserveOrder = true) {
         const hashes = chunks.map((c) => c.hash);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rac-delta",
   "description": "Storage agnostic delta patching implementation of rac-delta protocol for NodeJs. With streaming support and file reconstruction.",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": {