@strapi/data-transfer 5.0.0-rc.8 → 5.0.0

package/dist/index.mjs

@@ -2550,6 +2550,17 @@ const connectToWebsocket = (address, options) => {
 const trimTrailingSlash = (input) => {
   return input.replace(/\/$/, "");
 };
+const wait = (ms) => {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+};
+const waitUntil = async (test, interval) => {
+  while (!test()) {
+    await wait(interval);
+  }
+  return Promise.resolve();
+};
 const TRANSFER_PATH = "/transfer/runner";
 const TRANSFER_METHODS = ["push", "pull"];
 const constants = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -2875,32 +2886,105 @@ class RemoteStrapiSourceProvider {
     });
   };
   async createAssetsReadStream() {
-    const assets = {};
     const stream2 = await this.#createStageReadStream("assets");
     const pass = new PassThrough({ objectMode: true });
+    const assets = {};
     stream2.on("data", async (payload) => {
       for (const item of payload) {
-        const { action } = item;
+        const { action, assetID } = item;
         if (action === "start") {
-          assets[item.assetID] = { ...item.data, stream: new PassThrough() };
-          await this.writeAsync(pass, assets[item.assetID]);
+          if (assets[assetID]) {
+            continue;
+          }
+          assets[assetID] = {
+            ...item.data,
+            stream: new PassThrough(),
+            status: "idle",
+            queue: []
+          };
+          await this.writeAsync(pass, assets[assetID]);
         } else if (action === "stream") {
-          const rawBuffer = item.data;
-          const chunk = Buffer.from(rawBuffer.data);
-          await this.writeAsync(assets[item.assetID].stream, chunk);
+          if (!assets[assetID]) {
+            continue;
+          }
+          switch (assets[assetID].status) {
+            case "idle":
+              await writeAssetChunk(assetID, item.data);
+              break;
+            case "busy":
+              assets[assetID].queue.push(item);
+              break;
+          }
         } else if (action === "end") {
-          await new Promise((resolve, reject2) => {
-            const { stream: assetStream } = assets[item.assetID];
-            assetStream.on("close", () => {
-              delete assets[item.assetID];
-              resolve();
-            }).on("error", reject2).end();
-          });
+          if (!assets[assetID]) {
+            continue;
+          }
+          switch (assets[assetID].status) {
+            case "idle":
+            case "errored":
+              await closeAssetStream(assetID);
+              break;
+            case "busy":
+              await Promise.race([
+                // Either: wait for the asset to be ready to be closed
+                waitUntil(() => assets[assetID].status !== "busy", 100),
+                // Or: if the last chunks are still not processed after ten seconds
+                wait(1e4)
+              ]);
+              await closeAssetStream(assetID);
+              break;
+          }
         }
       }
     }).on("close", () => {
       pass.end();
     });
+    const writeAssetChunk = async (id, data) => {
+      if (!assets[id]) {
+        throw new Error(`Failed to write asset chunk for "${id}". Asset not found.`);
+      }
+      const { status: currentStatus } = assets[id];
+      if (currentStatus !== "idle") {
+        throw new Error(
+          `Failed to write asset chunk for "${id}". The asset is currently "${currentStatus}"`
+        );
+      }
+      const nextItemInQueue = () => assets[id].queue.shift();
+      try {
+        assets[id].status = "busy";
+        await unsafe_writeAssetChunk(id, data);
+        let item = nextItemInQueue();
+        while (item) {
+          await unsafe_writeAssetChunk(id, item.data);
+          item = nextItemInQueue();
+        }
+        assets[id].status = "idle";
+      } catch {
+        assets[id].status = "errored";
+      }
+    };
+    const unsafe_writeAssetChunk = async (id, data) => {
+      const asset = assets[id];
+      if (!asset) {
+        throw new Error(`Failed to write asset chunk for "${id}". Asset not found.`);
+      }
+      const rawBuffer = data;
+      const chunk = Buffer.from(rawBuffer.data);
+      await this.writeAsync(asset.stream, chunk);
+    };
+    const closeAssetStream = async (id) => {
+      if (!assets[id]) {
+        throw new Error(`Failed to close asset "${id}". Asset not found.`);
+      }
+      assets[id].status = "closed";
+      await new Promise((resolve, reject2) => {
+        const { stream: stream22 } = assets[id];
+        stream22.on("close", () => {
+          delete assets[id];
+          resolve();
+        }).on("error", reject2).end();
+      });
+    };
     return pass;
   }
   createConfigurationReadStream() {