@strapi/data-transfer 4.25.18 → 4.25.20

package/dist/index.js

@@ -612,7 +612,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" }
     });
   }
   /**
@@ -904,8 +904,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") {
@@ -1896,6 +1896,7 @@ class LocalStrapiDestinationProvider {
   transaction;
   uploadsBackupDirectoryName;
   onWarning;
+  #diagnostics;
   /**
    * The entities mapper is used to map old entities to their new IDs
    */
@@ -1905,12 +1906,14 @@ 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) {
       throw new ProviderInitializationError("Could not access local strapi");
     }
+    this.strapi.db.lifecycles.disable();
     this.transaction = createTransaction(this.strapi);
   }
   // TODO: either move this to restore strategy, or restore strategy should given access to these instead of repeating the logic possibly in a different way
@@ -1922,14 +1925,27 @@ 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();
+    assertValidStrapi(this.strapi);
+    this.strapi.db.lifecycles.enable();
     if (autoDestroy === void 0 || autoDestroy === true) {
       await this.strapi?.destroy();
     }
   }
   #validateOptions() {
+    this.#reportInfo("validating options");
     if (!VALID_CONFLICT_STRATEGIES.includes(this.options.strategy)) {
       throw new ProviderValidationError(`Invalid strategy ${this.options.strategy}`, {
         check: "strategy",
@@ -1946,10 +1962,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;
     }
@@ -1962,9 +1980,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) {
@@ -1983,6 +2004,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();
@@ -1994,6 +2016,7 @@ class LocalStrapiDestinationProvider {
     };
   }
   getSchemas() {
+    this.#reportInfo("getting schema");
     assertValidStrapi(this.strapi, "Not able to get Schemas");
     const schemas = {
       ...this.strapi.contentTypes,
@@ -2003,6 +2026,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]) {
@@ -2029,6 +2053,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,
@@ -2044,6 +2069,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",
@@ -2061,17 +2087,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"
@@ -2166,6 +2195,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);
@@ -2177,6 +2207,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");
     }
@@ -2377,19 +2408,35 @@ 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();
+    this.strapi.db.lifecycles.disable();
+  }
+  #reportInfo(message) {
+    this.#diagnostics?.report({
+      details: {
+        createdAt: /* @__PURE__ */ new Date(),
+        message,
+        origin: "local-source-provider"
+      },
+      kind: "info"
+    });
   }
   async close() {
     const { autoDestroy } = this.options;
+    assertValidStrapi(this.strapi);
+    this.strapi.db.lifecycles.enable();
     if (autoDestroy === void 0 || autoDestroy === true) {
       await this.strapi?.destroy();
     }
   }
   getMetadata() {
+    this.#reportInfo("getting metadata");
     const strapiVersion = strapi.config.get("info.strapi");
     const createdAt = (/* @__PURE__ */ new Date()).toISOString();
     return {
@@ -2401,6 +2448,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),
@@ -2410,14 +2458,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 = {
       ...this.strapi.contentTypes,
       ...this.strapi.components
@@ -2429,13 +2480,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) {
@@ -2448,6 +2500,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) {
@@ -2470,6 +2532,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) {
@@ -2526,7 +2598,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", () => {
@@ -2560,6 +2632,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, {
@@ -2600,6 +2680,7 @@ class RemoteStrapiDestinationProvider {
   ws;
   dispatcher;
   transferID;
+  #diagnostics;
   constructor(options) {
     this.options = options;
     this.ws = null;
@@ -2698,7 +2779,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;
@@ -2715,6 +2807,7 @@ class RemoteStrapiDestinationProvider {
     const wsUrl = `${wsProtocol}//${url.host}${trimTrailingSlash(
       url.pathname
     )}${TRANSFER_PATH}/push`;
+    this.#reportInfo("establishing websocket connection");
     if (!auth) {
       ws2 = await connectToWebsocket(wsUrl);
     } else if (auth.type === "token") {
@@ -2728,10 +2821,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");
   }
@@ -2852,6 +2954,7 @@ class RemoteStrapiSourceProvider {
   options;
   ws;
   dispatcher;
+  #diagnostics;
   constructor(options) {
     this.options = options;
     this.ws = null;
@@ -3040,6 +3143,16 @@ class RemoteStrapiSourceProvider {
     }
     return res.transferID;
   }
+  #reportInfo(message) {
+    this.#diagnostics?.report({
+      details: {
+        createdAt: /* @__PURE__ */ new Date(),
+        message,
+        origin: "remote-source-provider"
+      },
+      kind: "info"
+    });
+  }
   async bootstrap() {
     const { url, auth } = this.options;
     let ws2;
@@ -3048,6 +3161,7 @@ class RemoteStrapiSourceProvider {
     const wsUrl = `${wsProtocol}//${url.host}${trimTrailingSlash(
       url.pathname
     )}${TRANSFER_PATH}/pull`;
+    this.#reportInfo("establishing websocket connection");
     if (!auth) {
       ws2 = await connectToWebsocket(wsUrl);
     } else if (auth.type === "token") {
@@ -3061,10 +3175,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");
   }
@@ -3284,6 +3407,8 @@ const handleWSUpgrade = (wss, ctx, callback) => {
       return;
     }
     disableTimeouts();
+    strapi.db.lifecycles.disable();
+    strapi.log.info("[Data transfer] Disabling lifecycle hooks");
     wss.emit("connection", client, ctx.req);
     callback(client, request);
   });
@@ -3296,6 +3421,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"
@@ -3329,6 +3455,9 @@ const handlerControllerFactory = (implementation) => (options) => {
         set response(response) {
           state.response = response;
         },
+        get diagnostics() {
+          return diagnostics;
+        },
         addUUID(uuid) {
           messageUUIDs.add(uuid);
         },
@@ -3444,6 +3573,10 @@ const handlerControllerFactory = (implementation) => (options) => {
         onError() {
         },
         onClose() {
+        },
+        onInfo() {
+        },
+        onWarning() {
         }
       };
       const handler = Object.assign(Object.create(prototype), implementation(prototype));
@@ -3456,6 +3589,8 @@ const handlerControllerFactory = (implementation) => (options) => {
           cannotRespondHandler(err);
         } finally {
           resetTimeouts();
+          strapi.db.lifecycles.enable();
+          strapi.log.info("[Data transfer] Restoring lifecycle hooks");
         }
       });
       ws2.on("error", async (...args) => {
@@ -3476,6 +3611,14 @@ const handlerControllerFactory = (implementation) => (options) => {
           cannotRespondHandler(err);
         }
       });
+      diagnostics.onDiagnostic((diagnostic) => {
+        const uuid = crypto.randomUUID();
+        const payload = JSON.stringify({
+          diagnostic,
+          uuid
+        });
+        handler.send(payload);
+      });
     };
     try {
       handleWSUpgrade(wss, ctx, cb);
@@ -3511,6 +3654,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 = {};
@@ -3587,6 +3750,7 @@ const createPushController = handlerControllerFactory((proto) => ({
     proto.addUUID(uuid);
     if (type === "command") {
       const { command: command2 } = msg;
+      this.onInfo(`received command:${command2} uuid:${uuid}`);
       await this.executeAndRespond(uuid, () => {
         this.assertValidTransferCommand(command2);
         if (command2 === "status") {
@@ -3595,6 +3759,7 @@ const createPushController = handlerControllerFactory((proto) => ({
         return this[command2](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();
@@ -3689,6 +3854,9 @@ const createPushController = handlerControllerFactory((proto) => ({
       }
       this.flow?.set(step);
     }
+    if (action2 === "bootstrap") {
+      return this.provider?.[action2](this.diagnostics);
+    }
     return this.provider?.[action2]();
   },
   async streamAsset(payload) {
@@ -3746,6 +3914,7 @@ const createPushController = handlerControllerFactory((proto) => ({
       getStrapi: () => strapi
     });
     this.provider.onWarning = (message) => {
+      this.onWarning(message);
       strapi.log.warn(message);
     };
     return { transferID: this.transferID };
@@ -3786,6 +3955,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(action2) {
     const validActions = VALID_TRANSFER_ACTIONS;
     if (validActions.includes(action2)) {
@@ -3815,6 +4004,7 @@ const createPullController = handlerControllerFactory((proto) => ({
     proto.addUUID(uuid);
     if (type === "command") {
       const { command: command2 } = msg;
+      this.onInfo(`received command:${command2} uuid:${uuid}`);
       await this.executeAndRespond(uuid, () => {
         this.assertValidTransferCommand(command2);
         if (command2 === "status") {
@@ -3823,6 +4013,7 @@ const createPullController = handlerControllerFactory((proto) => ({
         return this[command2](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();
@@ -3844,6 +4035,9 @@ const createPullController = handlerControllerFactory((proto) => ({
   async onTransferAction(msg) {
     const { action: action2 } = msg;
     this.assertValidTransferAction(action2);
+    if (action2 === "bootstrap") {
+      return this.provider?.[action2](this.diagnostics);
+    }
     return this.provider?.[action2]();
   },
   async flush(stage, id) {
@@ -4042,6 +4236,7 @@ class LocalFileSourceProvider {
   name = "source::local-file";
   options;
   #metadata;
+  #diagnostics;
   constructor(options) {
     this.options = options;
     const { encryption } = this.options;
@@ -4049,6 +4244,16 @@ 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.
    */
@@ -4077,12 +4282,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 schemas = await collect(this.createSchemasReadStream());
     if (fp.isEmpty(schemas)) {
       throw new ProviderInitializationError("Could not load schemas from Strapi data file.");
@@ -4090,21 +4297,26 @@ class LocalFileSourceProvider {
     return fp.keyBy("uid", 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,
@@ -4305,9 +4517,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: file2 } = this.options;
     let filePath = `${file2.path}.tar`;
@@ -4324,9 +4547,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");
@@ -4365,6 +4590,7 @@ class LocalFileDestinationProvider {
     }
   }
   async rollback() {
+    this.#reportInfo("rolling back");
     await this.close();
     await fse.rm(this.#archivePath, { force: true });
   }
@@ -4372,6 +4598,7 @@ class LocalFileDestinationProvider {
     return null;
   }
   async #writeMetadata() {
+    this.#reportInfo("writing metadata");
     const metadata = this.#providersMetadata.source;
     if (metadata) {
       await new Promise((resolve) => {
@@ -4392,6 +4619,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,
@@ -4404,6 +4632,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,
@@ -4416,6 +4645,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,
@@ -4428,6 +4658,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,
@@ -4441,6 +4672,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) {
@@ -4776,30 +5008,41 @@ const errorColors = {
   error: chalk__default.default.red,
   silly: chalk__default.default.yellow
 };
-const formatDiagnostic = (operation) => ({ details, kind }) => {
-  const logger$1 = logger.createLogger(
-    logger.configs.createOutputFileConfiguration(`${operation}_error_log_${Date.now()}.log`)
-  );
-  try {
-    if (kind === "error") {
-      const { message, severity = "fatal" } = details;
-      const colorizeError = errorColors[severity];
-      const errorMessage = colorizeError(`[${severity.toUpperCase()}] ${message}`);
-      logger$1.error(errorMessage);
-    }
-    if (kind === "info") {
-      const { message, params } = details;
-      const msg = `${message}
-${params ? JSON.stringify(params, null, 2) : ""}`;
-      logger$1.info(msg);
+const formatDiagnostic = (operation, info) => {
+  let logger$1;
+  const getLogger = () => {
+    if (!logger$1) {
+      logger$1 = logger.createLogger(
+        logger.configs.createOutputFileConfiguration(`${operation}_${Date.now()}.log`, {
+          level: "info",
+          format: logger.formats?.detailedLogs
+        })
+      );
     }
-    if (kind === "warning") {
-      const { origin: origin2, message } = details;
-      logger$1.warn(`(${origin2 ?? "transfer"}) ${message}`);
+    return logger$1;
+  };
+  return ({ details, kind }) => {
+    try {
+      if (kind === "error") {
+        const { message, severity = "fatal" } = details;
+        const colorizeError = errorColors[severity];
+        const errorMessage = colorizeError(`[${severity.toUpperCase()}] ${message}`);
+        getLogger().error(errorMessage);
+      }
+      if (kind === "info" && info) {
+        const { message, params, origin: origin2 } = details;
+        const msg = `[${origin2 ?? "transfer"}] ${message}
+${params ? JSON.stringify(params, null, 2) : ""}`;
+        getLogger().info(msg);
+      }
+      if (kind === "warning") {
+        const { origin: origin2, message } = details;
+        getLogger().warn(`(${origin2 ?? "transfer"}) ${message}`);
+      }
+    } catch (err) {
+      getLogger().error(err);
     }
-  } catch (err) {
-    logger$1.error(err);
-  }
+  };
 };
 const loadersFactory = (defaultLoaders = {}) => {
   const loaders = defaultLoaders;
@@ -4981,7 +5224,7 @@ const action$2 = async (opts) => {
       ]
     }
   });
-  engine.diagnostics.onDiagnostic(formatDiagnostic("export"));
+  engine.diagnostics.onDiagnostic(formatDiagnostic("export", opts.verbose));
   const progress = engine.progress.stream;
   const { updateLoader } = loadersFactory();
   progress.on(`stage::start`, ({ stage, data }) => {
@@ -5053,7 +5296,7 @@ const command$2 = ({ command: command2 }) => {
     )
   ).addOption(
     new commander.Option("--no-compress", "Disables gzip compression of output file").default(true)
-  ).addOption(
+  ).addOption(new commander.Option("--verbose", "Enable verbose logs")).addOption(
     new commander.Option(
       "-k, --key <string>",
       "Provide encryption key in command instead of using the prompt"
@@ -5109,7 +5352,7 @@ const action$1 = async (opts) => {
   destination.onWarning = (message) => console.warn(`
 ${chalk__default.default.yellow("warn")}: ${message}`);
   const engine2 = createTransferEngine$1(source, destination, engineOptions);
-  engine2.diagnostics.onDiagnostic(formatDiagnostic("import"));
+  engine2.diagnostics.onDiagnostic(formatDiagnostic("import", opts.verbose));
   const progress = engine2.progress.stream;
   const { updateLoader } = loadersFactory();
   engine2.onSchemaDiff(getDiffHandler(engine2, { force: opts.force, action: "import" }));
@@ -5167,7 +5410,7 @@ const command$1 = ({ command: command2 }) => {
       "-k, --key <string>",
       "Provide encryption key in command instead of using the prompt"
     )
-  ).addOption(forceOption).addOption(excludeOption).addOption(onlyOption).addOption(throttleOption).hook("preAction", validateExcludeOnly).hook("preAction", async (thisCommand) => {
+  ).addOption(new commander.Option("--verbose", "Enable verbose logs")).addOption(forceOption).addOption(excludeOption).addOption(onlyOption).addOption(throttleOption).hook("preAction", validateExcludeOnly).hook("preAction", async (thisCommand) => {
     const opts = thisCommand.opts();
     const ext = path__default.default.extname(String(opts.file));
     if (ext === ".enc") {
@@ -5297,7 +5540,7 @@ const action = async (opts) => {
       ]
     }
   });
-  engine.diagnostics.onDiagnostic(formatDiagnostic("transfer"));
+  engine.diagnostics.onDiagnostic(formatDiagnostic("transfer", opts.verbose));
   const progress = engine.progress.stream;
   const { updateLoader } = loadersFactory();
   engine.onSchemaDiff(getDiffHandler(engine, { force: opts.force, action: "transfer" }));
@@ -5349,7 +5592,7 @@ const command = ({ command: command2 }) => {
       "--to <destinationURL>",
       `URL of the remote Strapi instance to send data to`
     ).argParser(parseURL)
-  ).addOption(new commander.Option("--to-token <token>", `Transfer token for the remote Strapi destination`)).addOption(forceOption).addOption(excludeOption).addOption(onlyOption).addOption(throttleOption).hook("preAction", validateExcludeOnly).hook(
+  ).addOption(new commander.Option("--to-token <token>", `Transfer token for the remote Strapi destination`)).addOption(new commander.Option("--verbose", "Enable verbose logs")).addOption(forceOption).addOption(excludeOption).addOption(onlyOption).addOption(throttleOption).hook("preAction", validateExcludeOnly).hook(
     "preAction",
     ifOptions(
       (opts) => !(opts.from || opts.to) || opts.from && opts.to,