@strapi/data-transfer 5.4.1 → 5.5.0

package/dist/index.js

@@ -21,8 +21,7 @@ const tar$1 = require("tar-stream");
 const Stringer = require("stream-json/jsonl/Stringer");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 function _interopNamespace(e) {
-  if (e && e.__esModule)
-    return e;
+  if (e && e.__esModule) return e;
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
     for (const k in e) {
@@ -326,8 +325,57 @@ const middleware = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   __proto__: null,
   runMiddleware
 }, Symbol.toStringTag, { value: "Module" }));
+const createDiagnosticReporter = (options = {}) => {
+  const { stackSize = -1 } = options;
+  const emitter = new events.EventEmitter();
+  const stack = [];
+  const addListener = (event, listener) => {
+    emitter.on(event, listener);
+  };
+  const isDiagnosticValid = (diagnostic2) => {
+    if (!diagnostic2.kind || !diagnostic2.details || !diagnostic2.details.message) {
+      return false;
+    }
+    return true;
+  };
+  return {
+    stack: {
+      get size() {
+        return stack.length;
+      },
+      get items() {
+        return stack;
+      }
+    },
+    report(diagnostic2) {
+      if (!isDiagnosticValid(diagnostic2)) {
+        return this;
+      }
+      emitter.emit("diagnostic", diagnostic2);
+      emitter.emit(`diagnostic.${diagnostic2.kind}`, diagnostic2);
+      if (stackSize !== -1 && stack.length >= stackSize) {
+        stack.shift();
+      }
+      stack.push(diagnostic2);
+      return this;
+    },
+    onDiagnostic(listener) {
+      addListener("diagnostic", listener);
+      return this;
+    },
+    on(kind, listener) {
+      addListener(`diagnostic.${kind}`, listener);
+      return this;
+    }
+  };
+};
+const diagnostic = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createDiagnosticReporter
+}, Symbol.toStringTag, { value: "Module" }));
 const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
+  diagnostics: diagnostic,
   encryption: index$9,
   json,
   middleware,
@@ -428,50 +476,6 @@ const validateProvider = (type, provider) => {
     );
   }
 };
-const createDiagnosticReporter = (options = {}) => {
-  const { stackSize = -1 } = options;
-  const emitter = new events.EventEmitter();
-  const stack = [];
-  const addListener = (event, listener) => {
-    emitter.on(event, listener);
-  };
-  const isDiagnosticValid = (diagnostic) => {
-    if (!diagnostic.kind || !diagnostic.details || !diagnostic.details.message) {
-      return false;
-    }
-    return true;
-  };
-  return {
-    stack: {
-      get size() {
-        return stack.length;
-      },
-      get items() {
-        return stack;
-      }
-    },
-    report(diagnostic) {
-      if (!isDiagnosticValid(diagnostic)) {
-        return this;
-      }
-      emitter.emit("diagnostic", diagnostic);
-      emitter.emit(`diagnostic.${diagnostic.kind}`, diagnostic);
-      if (stackSize !== -1 && stack.length >= stackSize) {
-        stack.shift();
-      }
-      stack.push(diagnostic);
-      return this;
-    },
-    onDiagnostic(listener) {
-      addListener("diagnostic", listener);
-      return this;
-    },
-    on(kind, listener) {
-      addListener(`diagnostic.${kind}`, listener);
-      return this;
-    }
-  };
-};
 class ProviderError extends DataTransferError {
   constructor(severity, message, details) {
     super("provider", severity, message, details);
@@ -604,7 +608,7 @@ class TransferEngine {
   reportInfo(message, params) {
     this.diagnostics.report({
       kind: "info",
-      details: { createdAt: /* @__PURE__ */ new Date(), message, params }
+      details: { createdAt: /* @__PURE__ */ new Date(), message, params, origin: "engine" }
     });
   }
   /**
@@ -896,8 +900,8 @@ ${formattedDiffs}`,
    */
   async bootstrap() {
     const results = await Promise.allSettled([
-      this.sourceProvider.bootstrap?.(),
-      this.destinationProvider.bootstrap?.()
+      this.sourceProvider.bootstrap?.(this.diagnostics),
+      this.destinationProvider.bootstrap?.(this.diagnostics)
     ]);
     results.forEach((result) => {
       if (result.status === "rejected") {
@@ -1902,6 +1906,7 @@ class LocalStrapiDestinationProvider {
   transaction;
   uploadsBackupDirectoryName;
   onWarning;
+  #diagnostics;
   /**
    * The entities mapper is used to map old entities to their new IDs
    */
@@ -1911,7 +1916,8 @@ class LocalStrapiDestinationProvider {
     this.#entitiesMapper = {};
     this.uploadsBackupDirectoryName = `uploads_backup_${Date.now()}`;
   }
-  async bootstrap() {
+  async bootstrap(diagnostics) {
+    this.#diagnostics = diagnostics;
     this.#validateOptions();
     this.strapi = await this.options.getStrapi();
     if (!this.strapi) {
@@ -1928,6 +1934,16 @@ class LocalStrapiDestinationProvider {
     const excluded = this.options.restore?.entities?.exclude && this.options.restore?.entities.exclude.includes(type);
     return !excluded && !notIncluded;
   };
+  #reportInfo(message) {
+    this.#diagnostics?.report({
+      details: {
+        createdAt: /* @__PURE__ */ new Date(),
+        message,
+        origin: "local-destination-provider"
+      },
+      kind: "info"
+    });
+  }
   async close() {
     const { autoDestroy } = this.options;
     this.transaction?.end();
@@ -1936,6 +1952,7 @@ class LocalStrapiDestinationProvider {
     }
   }
   #validateOptions() {
+    this.#reportInfo("validating options");
     if (!VALID_CONFLICT_STRATEGIES.includes(this.options.strategy)) {
       throw new ProviderValidationError(`Invalid strategy ${this.options.strategy}`, {
         check: "strategy",
@@ -1952,10 +1969,12 @@ class LocalStrapiDestinationProvider {
     if (!this.options.restore) {
       throw new ProviderValidationError("Missing restore options");
     }
+    this.#reportInfo("deleting record ");
     return deleteRecords(this.strapi, this.options.restore);
   }
   async #deleteAllAssets(trx) {
     assertValidStrapi(this.strapi);
+    this.#reportInfo("deleting all assets");
     if (!this.#areAssetsIncluded()) {
       return;
     }
@@ -1968,9 +1987,12 @@ class LocalStrapiDestinationProvider {
         }
       }
     }
+    this.#reportInfo("deleted all assets");
   }
   async rollback() {
+    this.#reportInfo("Rolling back transaction");
     await this.transaction?.rollback();
+    this.#reportInfo("Rolled back transaction");
   }
   async beforeTransfer() {
     if (!this.strapi) {
@@ -1989,6 +2011,7 @@ class LocalStrapiDestinationProvider {
     });
   }
   getMetadata() {
+    this.#reportInfo("getting metadata");
     assertValidStrapi(this.strapi, "Not able to get Schemas");
     const strapiVersion = this.strapi.config.get("info.strapi");
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -2000,6 +2023,7 @@ class LocalStrapiDestinationProvider {
     };
   }
   getSchemas() {
+    this.#reportInfo("getting schema");
     assertValidStrapi(this.strapi, "Not able to get Schemas");
     const schemas = schemasToValidJSON({
       ...this.strapi.contentTypes,
@@ -2009,6 +2033,7 @@ class LocalStrapiDestinationProvider {
   }
   createEntitiesWriteStream() {
     assertValidStrapi(this.strapi, "Not able to import entities");
+    this.#reportInfo("creating entities stream");
     const { strategy } = this.options;
     const updateMappingTable = (type, oldID, newID) => {
       if (!this.#entitiesMapper[type]) {
@@ -2035,6 +2060,7 @@ class LocalStrapiDestinationProvider {
       return;
     }
     if (this.strapi.config.get("plugin::upload").provider === "local") {
+      this.#reportInfo("creating assets backup directory");
       const assetsDirectory = path__default.default.join(this.strapi.dirs.static.public, "uploads");
       const backupDirectory = path__default.default.join(
         this.strapi.dirs.static.public,
@@ -2050,6 +2076,7 @@ class LocalStrapiDestinationProvider {
         await fse__namespace.move(assetsDirectory, backupDirectory);
         await fse__namespace.mkdir(assetsDirectory);
         await fse__namespace.outputFile(path__default.default.join(assetsDirectory, ".gitkeep"), "");
+        this.#reportInfo(`created assets backup directory ${backupDirectory}`);
       } catch (err) {
         throw new ProviderTransferError(
           "The backup folder for the assets could not be created inside the public folder. Please ensure Strapi has write permissions on the public directory",
@@ -2067,17 +2094,20 @@ class LocalStrapiDestinationProvider {
       return;
     }
     if (this.strapi.config.get("plugin::upload").provider === "local") {
+      this.#reportInfo("removing assets backup");
       assertValidStrapi(this.strapi);
       const backupDirectory = path__default.default.join(
         this.strapi.dirs.static.public,
         this.uploadsBackupDirectoryName
       );
       await fse__namespace.rm(backupDirectory, { recursive: true, force: true });
+      this.#reportInfo("successfully removed assets backup");
     }
   }
   // TODO: Move this logic to the restore strategy
   async createAssetsWriteStream() {
     assertValidStrapi(this.strapi, "Not able to stream Assets");
+    this.#reportInfo("creating assets write stream");
     if (!this.#areAssetsIncluded()) {
       throw new ProviderTransferError(
         "Attempting to transfer assets when `assets` is not set in restore options"
@@ -2086,7 +2116,6 @@ class LocalStrapiDestinationProvider {
     const removeAssetsBackup = this.#removeAssetsBackup.bind(this);
     const strapi2 = this.strapi;
     const transaction2 = this.transaction;
-    const backupDirectory = this.uploadsBackupDirectoryName;
     const fileEntitiesMapper = this.#entitiesMapper["plugin::upload.file"];
     const restoreMediaEntitiesContent = this.#isContentTypeIncluded("plugin::upload.file");
     return new stream$1.Writable({
@@ -2097,47 +2126,28 @@ class LocalStrapiDestinationProvider {
       },
       async write(chunk, _encoding, callback) {
         await transaction2?.attach(async () => {
-          if (!chunk.metadata) {
-            const assetsDirectory = path__default.default.join(strapi2.dirs.static.public, "uploads");
-            const entryPath = path__default.default.join(assetsDirectory, chunk.filename);
-            const writableStream = fse__namespace.createWriteStream(entryPath);
-            chunk.stream.pipe(writableStream).on("close", () => {
-              callback(null);
-            }).on("error", async (error) => {
-              const errorMessage = error.code === "ENOSPC" ? " Your server doesn't have space to proceed with the import. " : " ";
-              try {
-                await fse__namespace.rm(assetsDirectory, { recursive: true, force: true });
-                this.destroy(
-                  new ProviderTransferError(
-                    `There was an error during the transfer process.${errorMessage}The original files have been restored to ${assetsDirectory}`
-                  )
-                );
-              } catch (err) {
-                throw new ProviderTransferError(
-                  `There was an error doing the rollback process. The original files are in ${backupDirectory}, but we failed to restore them to ${assetsDirectory}`
-                );
-              } finally {
-                callback(error);
-              }
-            });
-            return;
-          }
           const uploadData = {
             ...chunk.metadata,
             stream: stream$1.Readable.from(chunk.stream),
             buffer: chunk?.buffer
           };
           const provider = strapi2.config.get("plugin::upload").provider;
+          const fileId = fileEntitiesMapper?.[uploadData.id];
+          if (!fileId) {
+            callback(new Error(`File ID not found for ID: ${uploadData.id}`));
+          }
           try {
             await strapi2.plugin("upload").provider.uploadStream(uploadData);
             if (!restoreMediaEntitiesContent) {
               return callback();
             }
             if (uploadData?.type) {
-              const condition = uploadData?.id ? { id: fileEntitiesMapper[uploadData.id] } : { hash: uploadData.mainHash };
               const entry2 = await strapi2.db.query("plugin::upload.file").findOne({
-                where: condition
+                where: { id: fileId }
               });
+              if (!entry2) {
+                throw new Error("file not found");
+              }
               const specificFormat = entry2?.formats?.[uploadData.type];
               if (specificFormat) {
                 specificFormat.url = uploadData.url;
@@ -2152,8 +2162,11 @@ class LocalStrapiDestinationProvider {
               return callback();
             }
             const entry = await strapi2.db.query("plugin::upload.file").findOne({
-              where: { id: fileEntitiesMapper[uploadData.id] }
+              where: { id: fileId }
             });
+            if (!entry) {
+              throw new Error("file not found");
+            }
             entry.url = uploadData.url;
             await strapi2.db.query("plugin::upload.file").update({
               where: { id: entry.id },
@@ -2172,6 +2185,7 @@ class LocalStrapiDestinationProvider {
   }
   async createConfigurationWriteStream() {
     assertValidStrapi(this.strapi, "Not able to stream Configurations");
+    this.#reportInfo("creating configuration write stream");
     const { strategy } = this.options;
     if (strategy === "restore") {
       return createConfigurationWriteStream(this.strapi, this.transaction);
@@ -2183,6 +2197,7 @@ class LocalStrapiDestinationProvider {
     });
   }
   async createLinksWriteStream() {
+    this.#reportInfo("creating links write stream");
     if (!this.strapi) {
       throw new Error("Not able to stream links. Strapi instance not found");
     }
@@ -2381,12 +2396,24 @@ class LocalStrapiSourceProvider {
   type = "source";
   options;
   strapi;
+  #diagnostics;
   constructor(options) {
     this.options = options;
   }
-  async bootstrap() {
+  async bootstrap(diagnostics) {
+    this.#diagnostics = diagnostics;
     this.strapi = await this.options.getStrapi();
   }
+  #reportInfo(message) {
+    this.#diagnostics?.report({
+      details: {
+        createdAt: /* @__PURE__ */ new Date(),
+        message,
+        origin: "local-source-provider"
+      },
+      kind: "info"
+    });
+  }
   async close() {
     const { autoDestroy } = this.options;
     if (autoDestroy === void 0 || autoDestroy === true) {
@@ -2394,6 +2421,7 @@ class LocalStrapiSourceProvider {
     }
   }
   getMetadata() {
+    this.#reportInfo("getting metadata");
     const strapiVersion = strapi.config.get("info.strapi");
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     return {
@@ -2405,6 +2433,7 @@ class LocalStrapiSourceProvider {
   }
   async createEntitiesReadStream() {
     assertValidStrapi(this.strapi, "Not able to stream entities");
+    this.#reportInfo("creating entities read stream");
     return streamChain.chain([
       // Entities stream
       createEntitiesStream(this.strapi),
@@ -2414,14 +2443,17 @@ class LocalStrapiSourceProvider {
   }
   createLinksReadStream() {
     assertValidStrapi(this.strapi, "Not able to stream links");
+    this.#reportInfo("creating links read stream");
     return createLinksStream(this.strapi);
   }
   createConfigurationReadStream() {
     assertValidStrapi(this.strapi, "Not able to stream configuration");
+    this.#reportInfo("creating configuration read stream");
     return createConfigurationStream(this.strapi);
   }
   getSchemas() {
     assertValidStrapi(this.strapi, "Not able to get Schemas");
+    this.#reportInfo("getting schemas");
     const schemas = schemasToValidJSON({
       ...this.strapi.contentTypes,
       ...this.strapi.components
@@ -2433,13 +2465,14 @@ class LocalStrapiSourceProvider {
   }
   createAssetsReadStream() {
     assertValidStrapi(this.strapi, "Not able to stream assets");
+    this.#reportInfo("creating assets read stream");
     return createAssetsStream(this.strapi);
   }
 }
 const createDispatcher = (ws2, retryMessageOptions = {
   retryMessageMaxRetries: 5,
   retryMessageTimeout: 3e4
-}) => {
+}, reportInfo) => {
   const state = {};
   const dispatch = async (message, options = {}) => {
     if (!ws2) {
@@ -2452,6 +2485,16 @@ const createDispatcher = (ws2, retryMessageOptions = {
       if (options.attachTransfer) {
         Object.assign(payload, { transferID: state.transfer?.id });
       }
+      if (message.type === "command") {
+        reportInfo?.(
+          `dispatching message command:${message.command} uuid:${uuid} sent:${numberOfTimesMessageWasSent}`
+        );
+      } else if (message.type === "transfer") {
+        const messageToSend = message;
+        reportInfo?.(
+          `dispatching message action:${messageToSend.action} ${messageToSend.kind === "step" ? `step:${messageToSend.step}` : ""} uuid:${uuid} sent:${numberOfTimesMessageWasSent}`
+        );
+      }
       const stringifiedPayload = JSON.stringify(payload);
       ws2.send(stringifiedPayload, (error) => {
         if (error) {
@@ -2474,6 +2517,16 @@ const createDispatcher = (ws2, retryMessageOptions = {
       const interval = setInterval(sendPeriodically, retryMessageTimeout);
       const onResponse = (raw) => {
         const response = JSON.parse(raw.toString());
+        if (message.type === "command") {
+          reportInfo?.(
+            `received response to message command: ${message.command} uuid: ${uuid} sent: ${numberOfTimesMessageWasSent}`
+          );
+        } else if (message.type === "transfer") {
+          const messageToSend = message;
+          reportInfo?.(
+            `received response to message action:${messageToSend.action} ${messageToSend.kind === "step" ? `step:${messageToSend.step}` : ""} uuid:${uuid} sent:${numberOfTimesMessageWasSent}`
+          );
+        }
         if (response.uuid === uuid) {
           clearInterval(interval);
           if (response.error) {
@@ -2530,7 +2583,7 @@ const createDispatcher = (ws2, retryMessageOptions = {
     dispatchTransferStep
   };
 };
-const connectToWebsocket = (address, options) => {
+const connectToWebsocket = (address, options, diagnostics) => {
   return new Promise((resolve, reject2) => {
     const server = new ws.WebSocket(address, options);
     server.once("open", () => {
@@ -2564,6 +2617,14 @@ const connectToWebsocket = (address, options) => {
         )
       );
     });
+    server.on("message", (raw) => {
+      const response = JSON.parse(raw.toString());
+      if (response.diagnostic) {
+        diagnostics?.report({
+          ...response.diagnostic
+        });
+      }
+    });
     server.once("error", (err) => {
       reject2(
         new ProviderTransferError(err.message, {
@@ -2605,6 +2666,7 @@ class RemoteStrapiDestinationProvider {
   dispatcher;
   transferID;
   stats;
+  #diagnostics;
   constructor(options) {
     this.options = options;
     this.ws = null;
@@ -2731,7 +2793,18 @@ class RemoteStrapiDestinationProvider {
       }
     });
   }
-  async bootstrap() {
+  #reportInfo(message) {
+    this.#diagnostics?.report({
+      details: {
+        createdAt: /* @__PURE__ */ new Date(),
+        message,
+        origin: "remote-destination-provider"
+      },
+      kind: "info"
+    });
+  }
+  async bootstrap(diagnostics) {
+    this.#diagnostics = diagnostics;
     const { url, auth } = this.options;
     const validProtocols = ["https:", "http:"];
     let ws2;
@@ -2748,11 +2821,12 @@ class RemoteStrapiDestinationProvider {
     const wsUrl = `${wsProtocol}//${url.host}${trimTrailingSlash(
       url.pathname
     )}${TRANSFER_PATH}/push`;
+    this.#reportInfo("establishing websocket connection");
     if (!auth) {
-      ws2 = await connectToWebsocket(wsUrl);
+      ws2 = await connectToWebsocket(wsUrl, void 0, this.#diagnostics);
     } else if (auth.type === "token") {
       const headers = { Authorization: `Bearer ${auth.token}` };
-      ws2 = await connectToWebsocket(wsUrl, { headers });
+      ws2 = await connectToWebsocket(wsUrl, { headers }, this.#diagnostics);
     } else {
       throw new ProviderValidationError("Auth method not available", {
         check: "auth.type",
@@ -2761,10 +2835,19 @@ class RemoteStrapiDestinationProvider {
         }
       });
     }
+    this.#reportInfo("established websocket connection");
     this.ws = ws2;
     const { retryMessageOptions } = this.options;
-    this.dispatcher = createDispatcher(this.ws, retryMessageOptions);
+    this.#reportInfo("creating dispatcher");
+    this.dispatcher = createDispatcher(
+      this.ws,
+      retryMessageOptions,
+      (message) => this.#reportInfo(message)
+    );
+    this.#reportInfo("created dispatcher");
+    this.#reportInfo("initialize transfer");
     this.transferID = await this.initTransfer();
+    this.#reportInfo(`initialized transfer ${this.transferID}`);
     this.dispatcher.setTransferProperties({ id: this.transferID, kind: "push" });
     await this.dispatcher.dispatchTransferAction("bootstrap");
   }
@@ -2891,6 +2974,7 @@ class RemoteStrapiSourceProvider {
     this.dispatcher = null;
   }
   results;
+  #diagnostics;
   async #createStageReadStream(stage) {
     const startResult = await this.#startStep(stage);
     if (startResult instanceof Error) {
@@ -3073,7 +3157,18 @@ class RemoteStrapiSourceProvider {
     }
     return res.transferID;
   }
-  async bootstrap() {
+  #reportInfo(message) {
+    this.#diagnostics?.report({
+      details: {
+        createdAt: /* @__PURE__ */ new Date(),
+        message,
+        origin: "remote-source-provider"
+      },
+      kind: "info"
+    });
+  }
+  async bootstrap(diagnostics) {
+    this.#diagnostics = diagnostics;
     const { url, auth } = this.options;
     let ws2;
     this.assertValidProtocol(url);
@@ -3081,11 +3176,12 @@ class RemoteStrapiSourceProvider {
     const wsUrl = `${wsProtocol}//${url.host}${trimTrailingSlash(
       url.pathname
     )}${TRANSFER_PATH}/pull`;
+    this.#reportInfo("establishing websocket connection");
     if (!auth) {
-      ws2 = await connectToWebsocket(wsUrl);
+      ws2 = await connectToWebsocket(wsUrl, void 0, this.#diagnostics);
     } else if (auth.type === "token") {
       const headers = { Authorization: `Bearer ${auth.token}` };
-      ws2 = await connectToWebsocket(wsUrl, { headers });
+      ws2 = await connectToWebsocket(wsUrl, { headers }, this.#diagnostics);
     } else {
       throw new ProviderValidationError("Auth method not available", {
         check: "auth.type",
@@ -3094,10 +3190,19 @@ class RemoteStrapiSourceProvider {
         }
       });
     }
+    this.#reportInfo("established websocket connection");
     this.ws = ws2;
     const { retryMessageOptions } = this.options;
-    this.dispatcher = createDispatcher(this.ws, retryMessageOptions);
+    this.#reportInfo("creating dispatcher");
+    this.dispatcher = createDispatcher(
+      this.ws,
+      retryMessageOptions,
+      (message) => this.#reportInfo(message)
+    );
+    this.#reportInfo("creating dispatcher");
+    this.#reportInfo("initialize transfer");
     const transferID = await this.initTransfer();
+    this.#reportInfo(`initialized transfer ${transferID}`);
     this.dispatcher.setTransferProperties({ id: transferID, kind: "pull" });
     await this.dispatcher.dispatchTransferAction("bootstrap");
   }
@@ -3327,6 +3432,7 @@ const handlerControllerFactory = (implementation) => (options) => {
     const cb = (ws2) => {
       const state = { id: void 0 };
       const messageUUIDs = /* @__PURE__ */ new Set();
+      const diagnostics = createDiagnosticReporter();
       const cannotRespondHandler = (err) => {
         strapi?.log?.error(
           "[Data transfer] Cannot send error response to client, closing connection"
@@ -3360,6 +3466,9 @@ const handlerControllerFactory = (implementation) => (options) => {
         set response(response) {
           state.response = response;
         },
+        get diagnostics() {
+          return diagnostics;
+        },
         addUUID(uuid) {
           messageUUIDs.add(uuid);
         },
@@ -3475,6 +3584,10 @@ const handlerControllerFactory = (implementation) => (options) => {
         onError() {
         },
         onClose() {
+        },
+        onInfo() {
+        },
+        onWarning() {
         }
       };
       const handler = Object.assign(Object.create(prototype), implementation(prototype));
@@ -3507,6 +3620,14 @@ const handlerControllerFactory = (implementation) => (options) => {
           cannotRespondHandler(err);
         }
       });
+      diagnostics.onDiagnostic((diagnostic2) => {
+        const uuid = crypto.randomUUID();
+        const payload = JSON.stringify({
+          diagnostic: diagnostic2,
+          uuid
+        });
+        handler.send(payload);
+      });
     };
     try {
       handleWSUpgrade(wss, ctx, cb);
@@ -3542,6 +3663,26 @@ const createPushController = handlerControllerFactory((proto) => ({
   verifyAuth() {
     return proto.verifyAuth.call(this, TRANSFER_KIND$1);
   },
+  onInfo(message) {
+    this.diagnostics?.report({
+      details: {
+        message,
+        origin: "push-handler",
+        createdAt: /* @__PURE__ */ new Date()
+      },
+      kind: "info"
+    });
+  },
+  onWarning(message) {
+    this.diagnostics?.report({
+      details: {
+        message,
+        createdAt: /* @__PURE__ */ new Date(),
+        origin: "push-handler"
+      },
+      kind: "warning"
+    });
+  },
   cleanup() {
     proto.cleanup.call(this);
     this.streams = {};
@@ -3618,6 +3759,7 @@ const createPushController = handlerControllerFactory((proto) => ({
     proto.addUUID(uuid);
     if (type === "command") {
       const { command } = msg;
+      this.onInfo(`received command:${command} uuid:${uuid}`);
       await this.executeAndRespond(uuid, () => {
         this.assertValidTransferCommand(command);
         if (command === "status") {
@@ -3626,6 +3768,7 @@ const createPushController = handlerControllerFactory((proto) => ({
         return this[command](msg.params);
       });
     } else if (type === "transfer") {
+      this.onInfo(`received transfer action:${msg.action} step:${msg.kind} uuid:${uuid}`);
       await this.executeAndRespond(uuid, async () => {
         await this.verifyAuth();
         this.assertValidTransfer();
@@ -3727,6 +3870,9 @@ const createPushController = handlerControllerFactory((proto) => ({
       }
       this.flow?.set(step);
     }
+    if (action === "bootstrap") {
+      return this.provider?.[action](this.diagnostics);
+    }
     return this.provider?.[action]();
   },
   async streamAsset(payload) {
@@ -3792,6 +3938,7 @@ const createPushController = handlerControllerFactory((proto) => ({
       getStrapi: () => strapi
     });
     this.provider.onWarning = (message) => {
+      this.onWarning(message);
       strapi.log.warn(message);
     };
     return { transferID: this.transferID };
@@ -3832,6 +3979,26 @@ const createPullController = handlerControllerFactory((proto) => ({
     this.streams = {};
     delete this.provider;
   },
+  onInfo(message) {
+    this.diagnostics?.report({
+      details: {
+        message,
+        origin: "pull-handler",
+        createdAt: /* @__PURE__ */ new Date()
+      },
+      kind: "info"
+    });
+  },
+  onWarning(message) {
+    this.diagnostics?.report({
+      details: {
+        message,
+        createdAt: /* @__PURE__ */ new Date(),
+        origin: "pull-handler"
+      },
+      kind: "warning"
+    });
+  },
   assertValidTransferAction(action) {
     const validActions = VALID_TRANSFER_ACTIONS;
     if (validActions.includes(action)) {
@@ -3861,6 +4028,7 @@ const createPullController = handlerControllerFactory((proto) => ({
     proto.addUUID(uuid);
     if (type === "command") {
       const { command } = msg;
+      this.onInfo(`received command:${command} uuid:${uuid}`);
       await this.executeAndRespond(uuid, () => {
         this.assertValidTransferCommand(command);
         if (command === "status") {
@@ -3869,6 +4037,7 @@ const createPullController = handlerControllerFactory((proto) => ({
         return this[command](msg.params);
       });
     } else if (type === "transfer") {
+      this.onInfo(`received transfer action:${msg.action} step:${msg.kind} uuid:${uuid}`);
       await this.executeAndRespond(uuid, async () => {
         await this.verifyAuth();
         this.assertValidTransfer();
@@ -3890,6 +4059,9 @@ const createPullController = handlerControllerFactory((proto) => ({
   async onTransferAction(msg) {
     const { action } = msg;
     this.assertValidTransferAction(action);
+    if (action === "bootstrap") {
+      return this.provider?.[action](this.diagnostics);
+    }
     return this.provider?.[action]();
   },
   async flush(stage, id) {
@@ -4088,6 +4260,7 @@ class LocalFileSourceProvider {
   name = "source::local-file";
   options;
   #metadata;
+  #diagnostics;
   constructor(options) {
     this.options = options;
     const { encryption } = this.options;
@@ -4095,10 +4268,21 @@ class LocalFileSourceProvider {
       throw new Error("Missing encryption key");
     }
   }
+  #reportInfo(message) {
+    this.#diagnostics?.report({
+      details: {
+        createdAt: /* @__PURE__ */ new Date(),
+        message,
+        origin: "file-source-provider"
+      },
+      kind: "info"
+    });
+  }
   /**
    * Pre flight checks regarding the provided options, making sure that the file can be opened (decrypted, decompressed), etc.
    */
-  async bootstrap() {
+  async bootstrap(diagnostics) {
+    this.#diagnostics = diagnostics;
     const { path: filePath } = this.options.file;
     try {
       await this.#loadMetadata();
@@ -4123,12 +4307,14 @@ class LocalFileSourceProvider {
     return this.#parseJSONFile(backupStream, path2);
   }
   async getMetadata() {
+    this.#reportInfo("getting metadata");
     if (!this.#metadata) {
       await this.#loadMetadata();
     }
     return this.#metadata ?? null;
   }
   async getSchemas() {
+    this.#reportInfo("getting schemas");
     const schemaCollection = await collect(
       this.createSchemasReadStream()
     );
@@ -4139,21 +4325,26 @@ class LocalFileSourceProvider {
     return schemasToValidJSON(schemas);
   }
   createEntitiesReadStream() {
+    this.#reportInfo("creating entities read stream");
     return this.#streamJsonlDirectory("entities");
   }
   createSchemasReadStream() {
+    this.#reportInfo("creating schemas read stream");
     return this.#streamJsonlDirectory("schemas");
   }
   createLinksReadStream() {
+    this.#reportInfo("creating links read stream");
     return this.#streamJsonlDirectory("links");
   }
   createConfigurationReadStream() {
+    this.#reportInfo("creating configuration read stream");
     return this.#streamJsonlDirectory("configuration");
   }
   createAssetsReadStream() {
     const inStream = this.#getBackupStream();
     const outStream = new stream$1.PassThrough({ objectMode: true });
     const loadAssetMetadata = this.#loadAssetMetadata.bind(this);
+    this.#reportInfo("creating assets read stream");
     stream$1.pipeline(
       [
         inStream,
@@ -4173,9 +4364,7 @@ class LocalFileSourceProvider {
             try {
               metadata = await loadAssetMetadata(`assets/metadata/${file}.json`);
             } catch (error) {
-              console.warn(
-                ` Failed to read metadata for ${file}, Strapi will try to fix this issue automatically`
-              );
+              throw new Error(`Failed to read metadata for ${file}`);
             }
             const asset = {
               metadata,
@@ -4354,9 +4543,20 @@ class LocalFileDestinationProvider {
   results = {};
   #providersMetadata = {};
   #archive = {};
+  #diagnostics;
   constructor(options) {
     this.options = options;
   }
+  #reportInfo(message) {
+    this.#diagnostics?.report({
+      details: {
+        createdAt: /* @__PURE__ */ new Date(),
+        message,
+        origin: "file-destination-provider"
+      },
+      kind: "info"
+    });
+  }
   get #archivePath() {
     const { encryption, compression, file } = this.options;
     let filePath = `${file.path}.tar`;
@@ -4373,9 +4573,11 @@ class LocalFileDestinationProvider {
     return this;
   }
   createGzip() {
+    this.#reportInfo("creating gzip");
     return zip__default.default.createGzip();
   }
-  bootstrap() {
+  bootstrap(diagnostics) {
+    this.#diagnostics = diagnostics;
     const { compression, encryption } = this.options;
     if (encryption.enabled && !encryption.key) {
       throw new Error("Can't encrypt without a key");
@@ -4414,6 +4616,7 @@ class LocalFileDestinationProvider {
     }
   }
   async rollback() {
+    this.#reportInfo("rolling back");
     await this.close();
     await fse.rm(this.#archivePath, { force: true });
   }
@@ -4421,6 +4624,7 @@ class LocalFileDestinationProvider {
     return null;
   }
   async #writeMetadata() {
+    this.#reportInfo("writing metadata");
     const metadata = this.#providersMetadata.source;
     if (metadata) {
       await new Promise((resolve) => {
@@ -4441,6 +4645,7 @@ class LocalFileDestinationProvider {
     if (!this.#archive.stream) {
       throw new Error("Archive stream is unavailable");
     }
+    this.#reportInfo("creating schemas write stream");
     const filePathFactory = createFilePathFactory("schemas");
     const entryStream = createTarEntryStream(
       this.#archive.stream,
@@ -4453,6 +4658,7 @@ class LocalFileDestinationProvider {
     if (!this.#archive.stream) {
       throw new Error("Archive stream is unavailable");
     }
+    this.#reportInfo("creating entities write stream");
     const filePathFactory = createFilePathFactory("entities");
     const entryStream = createTarEntryStream(
       this.#archive.stream,
@@ -4465,6 +4671,7 @@ class LocalFileDestinationProvider {
     if (!this.#archive.stream) {
       throw new Error("Archive stream is unavailable");
     }
+    this.#reportInfo("creating links write stream");
     const filePathFactory = createFilePathFactory("links");
     const entryStream = createTarEntryStream(
       this.#archive.stream,
@@ -4477,6 +4684,7 @@ class LocalFileDestinationProvider {
     if (!this.#archive.stream) {
       throw new Error("Archive stream is unavailable");
     }
+    this.#reportInfo("creating configuration write stream");
     const filePathFactory = createFilePathFactory("configuration");
     const entryStream = createTarEntryStream(
       this.#archive.stream,
@@ -4490,6 +4698,7 @@ class LocalFileDestinationProvider {
     if (!archiveStream) {
       throw new Error("Archive stream is unavailable");
     }
+    this.#reportInfo("creating assets write stream");
     return new stream$1.Writable({
       objectMode: true,
       write(data, _encoding, callback) {