@strapi/data-transfer 4.20.5 → 5.0.0-alpha.1

package/dist/index.js

@@ -12,20 +12,13 @@ const fse = require("fs-extra");
 const _ = require("lodash");
 const utils = require("@strapi/utils");
 const chalk = require("chalk");
-const https = require("https");
-const http = require("http");
+const webStream = require("stream/web");
 const ws = require("ws");
 const zip = require("zlib");
 const tar = require("tar");
 const Parser = require("stream-json/jsonl/Parser");
 const tar$1 = require("tar-stream");
 const Stringer = require("stream-json/jsonl/Stringer");
-const commander = require("commander");
-const Table = require("cli-table3");
-const logger = require("@strapi/logger");
-const strapiFactory = require("@strapi/strapi");
-const ora = require("ora");
-const inquirer = require("inquirer");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 function _interopNamespace(e) {
   if (e && e.__esModule)
@@ -49,15 +42,10 @@ const path__default = /* @__PURE__ */ _interopDefault(path);
 const fse__namespace = /* @__PURE__ */ _interopNamespace(fse);
 const ___default = /* @__PURE__ */ _interopDefault(_);
 const chalk__default = /* @__PURE__ */ _interopDefault(chalk);
-const https__default = /* @__PURE__ */ _interopDefault(https);
-const http__default = /* @__PURE__ */ _interopDefault(http);
+const webStream__namespace = /* @__PURE__ */ _interopNamespace(webStream);
 const zip__default = /* @__PURE__ */ _interopDefault(zip);
 const tar__default = /* @__PURE__ */ _interopDefault(tar);
 const tar__default$1 = /* @__PURE__ */ _interopDefault(tar$1);
-const Table__default = /* @__PURE__ */ _interopDefault(Table);
-const strapiFactory__default = /* @__PURE__ */ _interopDefault(strapiFactory);
-const ora__default = /* @__PURE__ */ _interopDefault(ora);
-const inquirer__default = /* @__PURE__ */ _interopDefault(inquirer);
 const getEncryptionStrategy = (algorithm) => {
   const strategies2 = {
     "aes-128-ecb"(key) {
@@ -122,7 +110,7 @@ const getDecryptionStrategy = (algorithm) => {
 const createDecryptionCipher = (key, algorithm = "aes-128-ecb") => {
   return getDecryptionStrategy(algorithm)(key);
 };
-const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$9 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   createDecryptionCipher,
   createEncryptionCipher
@@ -334,9 +322,9 @@ const middleware = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePr
   __proto__: null,
   runMiddleware
 }, Symbol.toStringTag, { value: "Module" }));
-const index$6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  encryption: index$7,
+  encryption: index$9,
   json,
   middleware,
   schema,
@@ -399,11 +387,11 @@ class TransferEngineError extends DataTransferError {
     super("engine", severity, message, details);
   }
 }
-let TransferEngineInitializationError$1 = class TransferEngineInitializationError extends TransferEngineError {
+class TransferEngineInitializationError extends TransferEngineError {
   constructor(message) {
     super(SeverityKind.FATAL, message, { step: "initialization" });
   }
-};
+}
 class TransferEngineValidationError extends TransferEngineError {
   constructor(message, details) {
     super(SeverityKind.FATAL, message, { step: "validation", details });
@@ -417,7 +405,7 @@ class TransferEngineTransferError extends TransferEngineError {
 const errors = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   TransferEngineError,
-  TransferEngineInitializationError: TransferEngineInitializationError$1,
+  TransferEngineInitializationError,
   TransferEngineTransferError,
   TransferEngineValidationError
 }, Symbol.toStringTag, { value: "Module" }));
@@ -529,8 +517,8 @@ const TransferGroupPresets = {
     configuration: true
   }
 };
-const DEFAULT_VERSION_STRATEGY$1 = "ignore";
-const DEFAULT_SCHEMA_STRATEGY$1 = "strict";
+const DEFAULT_VERSION_STRATEGY = "ignore";
+const DEFAULT_SCHEMA_STRATEGY = "strict";
 class TransferEngine {
   sourceProvider;
   destinationProvider;
@@ -723,7 +711,7 @@ class TransferEngine {
    * If there is a mismatch, throws a validation error.
    */
   #assertStrapiVersionIntegrity(sourceVersion, destinationVersion) {
-    const strategy = this.options.versionStrategy || DEFAULT_VERSION_STRATEGY$1;
+    const strategy = this.options.versionStrategy || DEFAULT_VERSION_STRATEGY;
     const reject2 = () => {
       throw new TransferEngineValidationError(
         `The source and destination provide are targeting incompatible Strapi versions (using the "${strategy}" strategy). The source (${this.sourceProvider.name}) version is ${sourceVersion} and the destination (${this.destinationProvider.name}) version is ${destinationVersion}`,
@@ -766,7 +754,7 @@ class TransferEngine {
    * If there are differences and/or incompatibilities between source and destination schemas, then throw a validation error.
    */
   #assertSchemasMatching(sourceSchemas, destinationSchemas) {
-    const strategy = this.options.schemaStrategy || DEFAULT_SCHEMA_STRATEGY$1;
+    const strategy = this.options.schemaStrategy || DEFAULT_SCHEMA_STRATEGY;
     if (strategy === "ignore") {
       return;
     }
@@ -1143,16 +1131,16 @@ ${formattedDiffs}`,
     await this.#transferStage({ stage, source, destination, transform, tracker });
   }
 }
-const createTransferEngine$2 = (sourceProvider, destinationProvider, options) => {
+const createTransferEngine = (sourceProvider, destinationProvider, options) => {
   return new TransferEngine(sourceProvider, destinationProvider, options);
 };
-const engineDatatransfer = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  DEFAULT_SCHEMA_STRATEGY: DEFAULT_SCHEMA_STRATEGY$1,
-  DEFAULT_VERSION_STRATEGY: DEFAULT_VERSION_STRATEGY$1,
+  DEFAULT_SCHEMA_STRATEGY,
+  DEFAULT_VERSION_STRATEGY,
   TRANSFER_STAGES,
   TransferGroupPresets,
-  createTransferEngine: createTransferEngine$2,
+  createTransferEngine,
   errors
 }, Symbol.toStringTag, { value: "Module" }));
 const isDialectMySQL = () => strapi.db?.dialect.client === "mysql";
@@ -1182,7 +1170,7 @@ const createComponents = async (uid, data) => {
         if (!Array.isArray(componentValue)) {
           throw new Error("Expected an array to create repeatable component");
         }
-        const components = await utils.mapAsync(
+        const components = await utils.async.map(
           componentValue,
           (value) => createComponent(componentUID, value),
           { concurrency: isDialectMySQL() && !strapi.db?.inTransaction() ? 1 : Infinity }
@@ -1226,7 +1214,7 @@ const createComponents = async (uid, data) => {
           }
         };
       };
-      componentBody[attributeName] = await utils.mapAsync(
+      componentBody[attributeName] = await utils.async.map(
         dynamiczoneValues,
         createDynamicZoneComponents,
         { concurrency: isDialectMySQL() && !strapi.db?.inTransaction() ? 1 : Infinity }
@@ -1241,7 +1229,7 @@ const getComponents = async (uid, entity2) => {
   if (___default.default.isEmpty(componentAttributes)) {
     return {};
   }
-  return strapi.query(uid).load(entity2, componentAttributes);
+  return strapi.db.query(uid).load(entity2, componentAttributes);
 };
 const deleteComponents = async (uid, entityToDelete, { loadComponents = true } = {}) => {
   const { attributes = {} } = strapi.getModel(uid);
@@ -1251,7 +1239,7 @@ const deleteComponents = async (uid, entityToDelete, { loadComponents = true } =
     if (attribute.type === "component" || attribute.type === "dynamiczone") {
       let value;
       if (loadComponents) {
-        value = await strapi.query(uid).load(entityToDelete, attributeName);
+        value = await strapi.db.query(uid).load(entityToDelete, attributeName);
       } else {
         value = entityToDelete[attributeName];
       }
@@ -1260,7 +1248,7 @@ const deleteComponents = async (uid, entityToDelete, { loadComponents = true } =
       }
       if (attribute.type === "component") {
         const { component: componentUID } = attribute;
-        await utils.mapAsync(
+        await utils.async.map(
           ___default.default.castArray(value),
           (subValue) => deleteComponent(componentUID, subValue),
           {
@@ -1268,7 +1256,7 @@ const deleteComponents = async (uid, entityToDelete, { loadComponents = true } =
           }
         );
       } else {
-        await utils.mapAsync(
+        await utils.async.map(
           ___default.default.castArray(value),
           (subValue) => deleteComponent(subValue.__component, subValue),
           { concurrency: isDialectMySQL() && !strapi.db?.inTransaction() ? 1 : Infinity }
@@ -1289,11 +1277,11 @@ const createComponent = async (uid, data) => {
     // ... and assign the newly created component instead
     fp.assign(componentData)
   );
-  return strapi.query(uid).create({ data: transform(data) });
+  return strapi.db.query(uid).create({ data: transform(data) });
 };
 const deleteComponent = async (uid, componentToDelete) => {
   await deleteComponents(uid, componentToDelete);
-  await strapi.query(uid).delete({ where: { id: componentToDelete.id } });
+  await strapi.db.query(uid).delete({ where: { id: componentToDelete.id } });
 };
 const sanitizeComponentLikeAttributes = (model, data) => {
   const { attributes } = model;
@@ -1645,7 +1633,7 @@ const link = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty
   __proto__: null,
   createLinkQuery
 }, Symbol.toStringTag, { value: "Module" }));
-const index$5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$6 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   entity,
   link
@@ -1724,7 +1712,7 @@ const restoreCoreStore = async (strapi2, values) => {
 };
 const restoreWebhooks = async (strapi2, values) => {
   const data = omitInvalidCreationAttributes(values);
-  return strapi2.db.query("webhook").create({ data });
+  return strapi2.db.query("strapi::webhook").create({ data });
 };
 const restoreConfigs = async (strapi2, config) => {
   if (config.type === "core-store") {
@@ -1812,10 +1800,8 @@ const deleteRecords = async (strapi2, options) => {
 };
 const deleteEntitiesRecords = async (strapi2, options = {}) => {
   const { entities } = options;
-  const query = createEntityQuery(strapi2);
-  const contentTypes = Object.values(
-    strapi2.contentTypes
-  );
+  const models = strapi2.get("models").get();
+  const contentTypes = Object.values(strapi2.contentTypes);
   const contentTypesToClear = contentTypes.filter((contentType) => {
     let removeThisContentType = true;
     if (entities?.include) {
@@ -1828,17 +1814,35 @@ const deleteEntitiesRecords = async (strapi2, options = {}) => {
       removeThisContentType = entities.filters.every((filter2) => filter2(contentType));
     }
     return removeThisContentType;
+  }).map((contentType) => contentType.uid);
+  const modelsToClear = models.filter((model) => {
+    if (contentTypesToClear.includes(model.uid)) {
+      return false;
+    }
+    let removeThisModel = true;
+    if (entities?.include) {
+      removeThisModel = entities.include.includes(model.uid);
+    }
+    if (entities?.exclude && entities.exclude.includes(model.uid)) {
+      removeThisModel = false;
+    }
+    return removeThisModel;
+  }).map((model) => model.uid);
+  const [results, updateResults] = useResults([...contentTypesToClear, ...modelsToClear]);
+  const contentTypeQuery = createEntityQuery(strapi2);
+  const contentTypePromises = contentTypesToClear.map(async (uid) => {
+    const result = await contentTypeQuery(uid).deleteMany(entities?.params);
+    if (result) {
+      updateResults(result.count || 0, uid);
+    }
   });
-  const [results, updateResults] = useResults(
-    contentTypesToClear.map((contentType) => contentType.uid)
-  );
-  const deletePromises = contentTypesToClear.map(async (contentType) => {
-    const result = await query(contentType.uid).deleteMany(entities?.params);
+  const modelsPromises = modelsToClear.map(async (uid) => {
+    const result = await strapi2.db.query(uid).deleteMany({});
     if (result) {
-      updateResults(result.count || 0, contentType.uid);
+      updateResults(result.count || 0, uid);
     }
   });
-  await Promise.all(deletePromises);
+  await Promise.all([...contentTypePromises, ...modelsPromises]);
   return results;
 };
 const deleteConfigurationRecords = async (strapi2, options = {}) => {
@@ -1848,7 +1852,7 @@ const deleteConfigurationRecords = async (strapi2, options = {}) => {
     models.push("strapi::core-store");
   }
   if (webhook) {
-    models.push("webhook");
+    models.push("strapi::webhook");
   }
   const [results, updateResults] = useResults(models);
   const deletePromises = models.map(async (uid) => {
@@ -1882,7 +1886,7 @@ const assertValidStrapi = (strapi2, msg = "") => {
   }
 };
 const VALID_CONFLICT_STRATEGIES = ["restore"];
-const DEFAULT_CONFLICT_STRATEGY$1 = "restore";
+const DEFAULT_CONFLICT_STRATEGY = "restore";
 class LocalStrapiDestinationProvider {
   name = "destination::local-strapi";
   type = "destination";
@@ -1949,10 +1953,10 @@ class LocalStrapiDestinationProvider {
       return;
     }
     const stream2 = this.strapi.db.queryBuilder("plugin::upload.file").select("*").transacting(trx).stream();
-    for await (const file2 of stream2) {
-      await this.strapi.plugin("upload").provider.delete(file2);
-      if (file2.formats) {
-        for (const fileFormat of Object.values(file2.formats)) {
+    for await (const file of stream2) {
+      await this.strapi.plugin("upload").provider.delete(file);
+      if (file.formats) {
+        for (const fileFormat of Object.values(file.formats)) {
           await this.strapi.plugin("upload").provider.delete(fileFormat);
         }
       }
@@ -2023,7 +2027,7 @@ class LocalStrapiDestinationProvider {
     if (!this.#areAssetsIncluded()) {
       return;
     }
-    if (this.strapi.config.get("plugin.upload").provider === "local") {
+    if (this.strapi.config.get("plugin::upload").provider === "local") {
       const assetsDirectory = path__default.default.join(this.strapi.dirs.static.public, "uploads");
       const backupDirectory = path__default.default.join(
         this.strapi.dirs.static.public,
@@ -2055,7 +2059,7 @@ class LocalStrapiDestinationProvider {
     if (!this.#areAssetsIncluded()) {
       return;
     }
-    if (this.strapi.config.get("plugin.upload").provider === "local") {
+    if (this.strapi.config.get("plugin::upload").provider === "local") {
       assertValidStrapi(this.strapi);
       const backupDirectory = path__default.default.join(
         this.strapi.dirs.static.public,
@@ -2116,7 +2120,7 @@ class LocalStrapiDestinationProvider {
             stream: stream$1.Readable.from(chunk.stream),
             buffer: chunk?.buffer
           };
-          const provider = strapi2.config.get("plugin.upload").provider;
+          const provider = strapi2.config.get("plugin::upload").provider;
           try {
             await strapi2.plugin("upload").provider.uploadStream(uploadData);
             if (!restoreMediaEntitiesContent) {
@@ -2187,7 +2191,7 @@ class LocalStrapiDestinationProvider {
     });
   }
 }
-const createLocalStrapiDestinationProvider$2 = (options) => {
+const createLocalStrapiDestinationProvider = (options) => {
   return new LocalStrapiDestinationProvider(options);
 };
 const createEntitiesStream = (strapi2) => {
@@ -2251,7 +2255,7 @@ const createConfigurationStream = (strapi2) => {
         wrapConfigurationItem("core-store")
       ]);
       const webhooksStream = streamChain.chain([
-        strapi2.db.queryBuilder("webhook").stream(),
+        strapi2.db.queryBuilder("strapi::webhook").stream(),
         wrapConfigurationItem("webhook")
       ]);
       const streams = [coreStoreStream, webhooksStream];
@@ -2267,44 +2271,42 @@ const wrapConfigurationItem = (type) => (value) => ({
   type,
   value
 });
-const protocolForPath = (filepath) => {
-  return filepath?.startsWith("https") ? https__default.default : http__default.default;
-};
-function getFileStream(filepath, isLocal = false) {
+function getFileStream(filepath, strapi2, isLocal = false) {
   if (isLocal) {
     return fse.createReadStream(filepath);
   }
   const readableStream = new stream$1.PassThrough();
-  protocolForPath(filepath).get(filepath, (res) => {
-    if (res.statusCode !== 200) {
-      readableStream.emit(
-        "error",
-        new Error(`Request failed with status code ${res.statusCode}`)
-      );
+  strapi2.fetch(filepath).then((res) => {
+    if (res.status !== 200) {
+      readableStream.emit("error", new Error(`Request failed with status code ${res.status}`));
       return;
     }
-    res.pipe(readableStream);
-  }).on("error", (error) => {
+    if (res.body) {
+      stream$1.Readable.fromWeb(new webStream__namespace.ReadableStream(res.body)).pipe(readableStream);
+    } else {
+      readableStream.emit("error", new Error("Empty data found for file"));
+    }
+  }).catch((error) => {
     readableStream.emit("error", error);
   });
   return readableStream;
 }
-function getFileStats(filepath, isLocal = false) {
+function getFileStats(filepath, strapi2, isLocal = false) {
   if (isLocal) {
     return fse.stat(filepath);
   }
   return new Promise((resolve, reject2) => {
-    protocolForPath(filepath).get(filepath, (res) => {
-      if (res.statusCode !== 200) {
-        reject2(new Error(`Request failed with status code ${res.statusCode}`));
+    strapi2.fetch(filepath).then((res) => {
+      if (res.status !== 200) {
+        reject2(new Error(`Request failed with status code ${res.status}`));
         return;
       }
-      const contentLength = res.headers["content-length"];
+      const contentLength = res.headers.get("content-length");
       const stats = {
         size: contentLength ? parseInt(contentLength, 10) : 0
       };
       resolve(stats);
-    }).on("error", (error) => {
+    }).catch((error) => {
       reject2(error);
     });
   });
@@ -2312,25 +2314,25 @@ function getFileStats(filepath, isLocal = false) {
 const createAssetsStream = (strapi2) => {
   const generator = async function* () {
     const stream2 = strapi2.db.queryBuilder("plugin::upload.file").select("*").stream();
-    for await (const file2 of stream2) {
-      const isLocalProvider = file2.provider === "local";
-      const filepath = isLocalProvider ? path.join(strapi2.dirs.static.public, file2.url) : file2.url;
-      const stats = await getFileStats(filepath, isLocalProvider);
-      const stream22 = getFileStream(filepath, isLocalProvider);
+    for await (const file of stream2) {
+      const isLocalProvider = file.provider === "local";
+      const filepath = isLocalProvider ? path.join(strapi2.dirs.static.public, file.url) : file.url;
+      const stats = await getFileStats(filepath, strapi2, isLocalProvider);
+      const stream22 = getFileStream(filepath, strapi2, isLocalProvider);
       yield {
-        metadata: file2,
+        metadata: file,
         filepath,
-        filename: file2.hash + file2.ext,
+        filename: file.hash + file.ext,
         stream: stream22,
         stats: { size: stats.size }
       };
-      if (file2.formats) {
-        for (const format of Object.keys(file2.formats)) {
-          const fileFormat = file2.formats[format];
+      if (file.formats) {
+        for (const format of Object.keys(file.formats)) {
+          const fileFormat = file.formats[format];
           const fileFormatFilepath = isLocalProvider ? path.join(strapi2.dirs.static.public, fileFormat.url) : fileFormat.url;
-          const fileFormatStats = await getFileStats(fileFormatFilepath, isLocalProvider);
-          const fileFormatStream = getFileStream(fileFormatFilepath, isLocalProvider);
-          const metadata = { ...fileFormat, type: format, id: file2.id, mainHash: file2.hash };
+          const fileFormatStats = await getFileStats(fileFormatFilepath, strapi2, isLocalProvider);
+          const fileFormatStream = getFileStream(fileFormatFilepath, strapi2, isLocalProvider);
+          const metadata = { ...fileFormat, type: format, id: file.id, mainHash: file.hash };
           yield {
             metadata,
             filepath: fileFormatFilepath,
@@ -2344,7 +2346,7 @@ const createAssetsStream = (strapi2) => {
   };
   return stream$1.Duplex.from(generator());
 };
-const createLocalStrapiSourceProvider$2 = (options) => {
+const createLocalStrapiSourceProvider = (options) => {
   return new LocalStrapiSourceProvider(options);
 };
 class LocalStrapiSourceProvider {
@@ -2472,8 +2474,8 @@ const createDispatcher = (ws2, retryMessageOptions = {
   const dispatchCommand = (payload) => {
     return dispatch({ type: "command", ...payload });
   };
-  const dispatchTransferAction = async (action2) => {
-    const payload = { type: "transfer", kind: "action", action: action2 };
+  const dispatchTransferAction = async (action) => {
+    const payload = { type: "transfer", kind: "action", action };
     return dispatch(payload, { attachTransfer: true }) ?? Promise.resolve(null);
   };
   const dispatchTransferStep = async (payload) => {
@@ -2807,7 +2809,7 @@ class RemoteStrapiDestinationProvider {
     });
   }
 }
-const createRemoteStrapiDestinationProvider$1 = (options) => {
+const createRemoteStrapiDestinationProvider = (options) => {
   return new RemoteStrapiDestinationProvider(options);
 };
 class RemoteStrapiSourceProvider {
@@ -2879,15 +2881,15 @@ class RemoteStrapiSourceProvider {
     const pass = new stream$1.PassThrough({ objectMode: true });
     stream2.on("data", async (payload) => {
       for (const item of payload) {
-        const { action: action2 } = item;
-        if (action2 === "start") {
+        const { action } = item;
+        if (action === "start") {
           assets[item.assetID] = { ...item.data, stream: new stream$1.PassThrough() };
           await this.writeAsync(pass, assets[item.assetID]);
-        } else if (action2 === "stream") {
+        } else if (action === "stream") {
           const rawBuffer = item.data;
           const chunk = Buffer.from(rawBuffer.data);
           await this.writeAsync(assets[item.assetID].stream, chunk);
-        } else if (action2 === "end") {
+        } else if (action === "end") {
           await new Promise((resolve, reject2) => {
             const { stream: assetStream } = assets[item.assetID];
             assetStream.on("close", () => {
@@ -3015,17 +3017,17 @@ class RemoteStrapiSourceProvider {
     return null;
   }
 }
-const createRemoteStrapiSourceProvider$1 = (options) => {
+const createRemoteStrapiSourceProvider = (options) => {
   return new RemoteStrapiSourceProvider(options);
 };
-const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$5 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  DEFAULT_CONFLICT_STRATEGY: DEFAULT_CONFLICT_STRATEGY$1,
+  DEFAULT_CONFLICT_STRATEGY,
   VALID_CONFLICT_STRATEGIES,
-  createLocalStrapiDestinationProvider: createLocalStrapiDestinationProvider$2,
-  createLocalStrapiSourceProvider: createLocalStrapiSourceProvider$2,
-  createRemoteStrapiDestinationProvider: createRemoteStrapiDestinationProvider$1,
-  createRemoteStrapiSourceProvider: createRemoteStrapiSourceProvider$1
+  createLocalStrapiDestinationProvider,
+  createLocalStrapiSourceProvider,
+  createRemoteStrapiDestinationProvider,
+  createRemoteStrapiSourceProvider
 }, Symbol.toStringTag, { value: "Module" }));
 const DEFAULT_TRANSFER_FLOW = [
   {
@@ -3232,9 +3234,9 @@ const handlerControllerFactory = (implementation) => (options) => {
             throw new Error("Invalid Transfer Process");
           }
         },
-        assertValidTransferCommand(command2) {
-          const isDefined = typeof this[command2] === "function";
-          const isValidTransferCommand = VALID_TRANSFER_COMMANDS.includes(command2);
+        assertValidTransferCommand(command) {
+          const isDefined = typeof this[command] === "function";
+          const isValidTransferCommand = VALID_TRANSFER_COMMANDS.includes(command);
           if (!isDefined || !isValidTransferCommand) {
             throw new Error("Invalid transfer command");
           }
@@ -3418,12 +3420,12 @@ const createPushController = handlerControllerFactory((proto) => ({
       throw new Error("Invalid Transfer Process");
     }
   },
-  assertValidTransferAction(action2) {
-    if (VALID_TRANSFER_ACTIONS$1.includes(action2)) {
+  assertValidTransferAction(action) {
+    if (VALID_TRANSFER_ACTIONS$1.includes(action)) {
       return;
     }
-    throw new ProviderTransferError(`Invalid action provided: "${action2}"`, {
-      action: action2,
+    throw new ProviderTransferError(`Invalid action provided: "${action}"`, {
+      action,
       validActions: Object.keys(VALID_TRANSFER_ACTIONS$1)
     });
   },
@@ -3474,13 +3476,13 @@ const createPushController = handlerControllerFactory((proto) => ({
     const { uuid, type } = msg;
     proto.addUUID(uuid);
     if (type === "command") {
-      const { command: command2 } = msg;
+      const { command } = msg;
       await this.executeAndRespond(uuid, () => {
-        this.assertValidTransferCommand(command2);
-        if (command2 === "status") {
+        this.assertValidTransferCommand(command);
+        if (command === "status") {
           return this.status();
         }
-        return this[command2](msg.params);
+        return this[command](msg.params);
       });
     } else if (type === "transfer") {
       await this.executeAndRespond(uuid, async () => {
@@ -3565,19 +3567,19 @@ const createPushController = handlerControllerFactory((proto) => ({
     }
   },
   async onTransferAction(msg) {
-    const { action: action2 } = msg;
-    this.assertValidTransferAction(action2);
-    const step = { kind: "action", action: action2 };
+    const { action } = msg;
+    this.assertValidTransferAction(action);
+    const step = { kind: "action", action };
     const isStepRegistered = this.flow?.has(step);
     if (isStepRegistered) {
       if (this.flow?.cannot(step)) {
-        throw new ProviderTransferError(`Invalid action "${action2}" found for the current flow `, {
-          action: action2
+        throw new ProviderTransferError(`Invalid action "${action}" found for the current flow `, {
+          action
         });
       }
       this.flow?.set(step);
     }
-    return this.provider?.[action2]();
+    return this.provider?.[action]();
   },
   async streamAsset(payload) {
     const assetsStream = this.streams?.assets;
@@ -3586,20 +3588,20 @@ const createPushController = handlerControllerFactory((proto) => ({
       return;
     }
     for (const item of payload) {
-      const { action: action2, assetID } = item;
+      const { action, assetID } = item;
       if (!assetsStream) {
         throw new Error("Stream not defined");
       }
-      if (action2 === "start") {
+      if (action === "start") {
         this.assets[assetID] = { ...item.data, stream: new stream$1.PassThrough() };
         writeAsync(assetsStream, this.assets[assetID]);
       }
-      if (action2 === "stream") {
+      if (action === "stream") {
         const rawBuffer = item.data;
         const chunk = Buffer.from(rawBuffer.data);
         await writeAsync(this.assets[assetID].stream, chunk);
       }
-      if (action2 === "end") {
+      if (action === "end") {
         await new Promise((resolve, reject2) => {
           const { stream: assetStream } = this.assets[assetID];
           assetStream.on("close", () => {
@@ -3628,7 +3630,7 @@ const createPushController = handlerControllerFactory((proto) => ({
     this.assets = {};
     this.streams = {};
     this.flow = createFlow(DEFAULT_TRANSFER_FLOW);
-    this.provider = createLocalStrapiDestinationProvider$2({
+    this.provider = createLocalStrapiDestinationProvider({
       ...params.options,
       autoDestroy: false,
       getStrapi: () => strapi
@@ -3674,13 +3676,13 @@ const createPullController = handlerControllerFactory((proto) => ({
     this.streams = {};
     delete this.provider;
   },
-  assertValidTransferAction(action2) {
+  assertValidTransferAction(action) {
     const validActions = VALID_TRANSFER_ACTIONS;
-    if (validActions.includes(action2)) {
+    if (validActions.includes(action)) {
       return;
     }
-    throw new ProviderTransferError(`Invalid action provided: "${action2}"`, {
-      action: action2,
+    throw new ProviderTransferError(`Invalid action provided: "${action}"`, {
+      action,
       validActions: Object.keys(VALID_TRANSFER_ACTIONS)
     });
   },
@@ -3702,13 +3704,13 @@ const createPullController = handlerControllerFactory((proto) => ({
     const { uuid, type } = msg;
     proto.addUUID(uuid);
     if (type === "command") {
-      const { command: command2 } = msg;
+      const { command } = msg;
       await this.executeAndRespond(uuid, () => {
-        this.assertValidTransferCommand(command2);
-        if (command2 === "status") {
+        this.assertValidTransferCommand(command);
+        if (command === "status") {
           return this.status();
         }
-        return this[command2](msg.params);
+        return this[command](msg.params);
       });
     } else if (type === "transfer") {
       await this.executeAndRespond(uuid, async () => {
@@ -3730,9 +3732,9 @@ const createPullController = handlerControllerFactory((proto) => ({
     }
   },
   async onTransferAction(msg) {
-    const { action: action2 } = msg;
-    this.assertValidTransferAction(action2);
-    return this.provider?.[action2]();
+    const { action } = msg;
+    this.assertValidTransferAction(action);
+    return this.provider?.[action]();
   },
   async flush(stage, id) {
     const batchSize = 1024 * 1024;
@@ -3779,8 +3781,8 @@ const createPullController = handlerControllerFactory((proto) => ({
     }
   },
   async onTransferStep(msg) {
-    const { step, action: action2 } = msg;
-    if (action2 === "start") {
+    const { step, action } = msg;
+    if (action === "start") {
       if (this.streams?.[step] instanceof stream$1.Readable) {
         throw new Error("Stream already created, something went wrong");
       }
@@ -3789,7 +3791,7 @@ const createPullController = handlerControllerFactory((proto) => ({
       this.flush(step, flushUUID);
       return { ok: true, id: flushUUID };
     }
-    if (action2 === "end") {
+    if (action === "end") {
       const stream2 = this.streams?.[step];
       if (stream2?.readableEnded === false) {
         await new Promise((resolve) => {
@@ -3861,7 +3863,7 @@ const createPullController = handlerControllerFactory((proto) => ({
     this.transferID = crypto.randomUUID();
     this.startedAt = Date.now();
     this.streams = {};
-    this.provider = createLocalStrapiSourceProvider$2({
+    this.provider = createLocalStrapiSourceProvider({
       autoDestroy: false,
       getStrapi: () => strapi
     });
@@ -3889,22 +3891,22 @@ const createPullController = handlerControllerFactory((proto) => ({
     return { active: false, kind: null, elapsed: null, startedAt: null };
   }
 }));
-const index$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$4 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   createPullController,
   createPushController,
   handlerControllerFactory
 }, Symbol.toStringTag, { value: "Module" }));
-const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$3 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   constants,
-  handlers: index$3
+  handlers: index$4
 }, Symbol.toStringTag, { value: "Module" }));
-const strapiDatatransfer = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const index$2 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  providers: index$4,
-  queries: index$5,
-  remote: index$2
+  providers: index$5,
+  queries: index$6,
+  remote: index$3
 }, Symbol.toStringTag, { value: "Module" }));
 const isFilePathInDirname = (posixDirName, filePath) => {
   const normalizedDir = path__default.default.posix.dirname(unknownPathToPosix(filePath));
@@ -3922,7 +3924,7 @@ const unknownPathToPosix = (filePath) => {
   return path__default.default.normalize(filePath).split(path__default.default.win32.sep).join(path__default.default.posix.sep);
 };
 const METADATA_FILE_PATH = "metadata.json";
-const createLocalFileSourceProvider$1 = (options) => {
+const createLocalFileSourceProvider = (options) => {
   return new LocalFileSourceProvider(options);
 };
 class LocalFileSourceProvider {
@@ -4007,18 +4009,18 @@ class LocalFileSourceProvider {
           async onentry(entry) {
             const { path: filePath, size = 0 } = entry;
             const normalizedPath = unknownPathToPosix(filePath);
-            const file2 = path__default.default.basename(normalizedPath);
+            const file = path__default.default.basename(normalizedPath);
             let metadata;
             try {
-              metadata = await loadAssetMetadata(`assets/metadata/${file2}.json`);
+              metadata = await loadAssetMetadata(`assets/metadata/${file}.json`);
             } catch (error) {
               console.warn(
-                ` Failed to read metadata for ${file2}, Strapi will try to fix this issue automatically`
+                ` Failed to read metadata for ${file}, Strapi will try to fix this issue automatically`
               );
             }
             const asset = {
               metadata,
-              filename: file2,
+              filename: file,
               filepath: normalizedPath,
               stats: { size },
               stream: entry
@@ -4032,10 +4034,10 @@ class LocalFileSourceProvider {
     return outStream;
   }
   #getBackupStream() {
-    const { file: file2, encryption, compression } = this.options;
+    const { file, encryption, compression } = this.options;
     const streams = [];
     try {
-      streams.push(fse__namespace.default.createReadStream(file2.path));
+      streams.push(fse__namespace.default.createReadStream(file.path));
     } catch (e) {
       throw new Error(`Could not read backup file path provided at "${this.options.file.path}"`);
     }
@@ -4183,7 +4185,7 @@ const createTarEntryStream = (archive, pathFactory, maxSize = 256e6) => {
     }
   });
 };
-const createLocalFileDestinationProvider$1 = (options) => {
+const createLocalFileDestinationProvider = (options) => {
   return new LocalFileDestinationProvider(options);
 };
 class LocalFileDestinationProvider {
@@ -4197,8 +4199,8 @@ class LocalFileDestinationProvider {
     this.options = options;
   }
   get #archivePath() {
-    const { encryption, compression, file: file2 } = this.options;
-    let filePath = `${file2.path}.tar`;
+    const { encryption, compression, file } = this.options;
+    let filePath = `${file.path}.tar`;
     if (compression.enabled) {
       filePath += ".gz";
     }
@@ -4362,951 +4364,15 @@ class LocalFileDestinationProvider {
 }
 const index$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  createLocalFileDestinationProvider: createLocalFileDestinationProvider$1,
-  createLocalFileSourceProvider: createLocalFileSourceProvider$1
-}, Symbol.toStringTag, { value: "Module" }));
-const file = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  providers: index$1
+  createLocalFileDestinationProvider,
+  createLocalFileSourceProvider
 }, Symbol.toStringTag, { value: "Module" }));
-const bytesPerKb = 1024;
-const sizes = ["B ", "KB", "MB", "GB", "TB", "PB"];
-const readableBytes = (bytes, decimals = 1, padStart = 0) => {
-  if (!bytes) {
-    return "0";
-  }
-  const i = Math.floor(Math.log(bytes) / Math.log(bytesPerKb));
-  const result = `${parseFloat((bytes / bytesPerKb ** i).toFixed(decimals))} ${sizes[i].padStart(
-    2
-  )}`;
-  return result.padStart(padStart);
-};
-const exitWith = (code, message, options = {}) => {
-  const { logger: logger2 = console, prc = process } = options;
-  const log = (message2) => {
-    if (code === 0) {
-      logger2.log(chalk__default.default.green(message2));
-    } else {
-      logger2.error(chalk__default.default.red(message2));
-    }
-  };
-  if (fp.isString(message)) {
-    log(message);
-  } else if (fp.isArray(message)) {
-    message.forEach((msg) => log(msg));
-  }
-  prc.exit(code);
-};
-const assertUrlHasProtocol = (url, protocol) => {
-  if (!url.protocol) {
-    exitWith(1, `${url.toString()} does not have a protocol`);
-  }
-  if (!protocol) {
-    return;
-  }
-  if (fp.isString(protocol)) {
-    if (protocol !== url.protocol) {
-      exitWith(1, `${url.toString()} must have the protocol ${protocol}`);
-    }
-    return;
-  }
-  if (!protocol.some((protocol2) => url.protocol === protocol2)) {
-    return exitWith(
-      1,
-      `${url.toString()} must have one of the following protocols: ${protocol.join(",")}`
-    );
-  }
-};
-const ifOptions = (conditionCallback, isMetCallback = async () => {
-}, isNotMetCallback = async () => {
-}) => {
-  return async (command2) => {
-    const opts = command2.opts();
-    if (await conditionCallback(opts)) {
-      await isMetCallback(command2);
-    } else {
-      await isNotMetCallback(command2);
-    }
-  };
-};
-const parseList = (value) => {
-  try {
-    return value.split(",").map((item) => item.trim());
-  } catch (e) {
-    exitWith(1, `Unrecognized input: ${value}`);
-  }
-  return [];
-};
-const getParseListWithChoices = (choices, errorMessage = "Invalid options:") => {
-  return (value) => {
-    const list = parseList(value);
-    const invalid = list.filter((item) => {
-      return !choices.includes(item);
-    });
-    if (invalid.length > 0) {
-      exitWith(1, `${errorMessage}: ${invalid.join(",")}`);
-    }
-    return list;
-  };
-};
-const parseInteger = (value) => {
-  const parsedValue = parseInt(value, 10);
-  if (fp.isNaN(parsedValue)) {
-    throw new commander.InvalidOptionArgumentError(`Not an integer: ${value}`);
-  }
-  return parsedValue;
-};
-const parseURL = (value) => {
-  try {
-    const url = new URL(value);
-    if (!url.host) {
-      throw new commander.InvalidOptionArgumentError(`Could not parse url ${value}`);
-    }
-    return url;
-  } catch (e) {
-    throw new commander.InvalidOptionArgumentError(`Could not parse url ${value}`);
-  }
-};
-const promptEncryptionKey = async (thisCommand) => {
-  const opts = thisCommand.opts();
-  if (!opts.encrypt && opts.key) {
-    return exitWith(1, "Key may not be present unless encryption is used");
-  }
-  if (opts.encrypt && !(opts.key && opts.key.length > 0)) {
-    try {
-      const answers = await inquirer__default.default.prompt([
-        {
-          type: "password",
-          message: "Please enter an encryption key",
-          name: "key",
-          validate(key) {
-            if (key.length > 0)
-              return true;
-            return "Key must be present when using the encrypt option";
-          }
-        }
-      ]);
-      opts.key = answers.key;
-    } catch (e) {
-      return exitWith(1, "Failed to get encryption key");
-    }
-    if (!opts.key) {
-      return exitWith(1, "Failed to get encryption key");
-    }
-  }
-};
-const getCommanderConfirmMessage = (message, { failMessage } = {}) => {
-  return async (command2) => {
-    const confirmed = await confirmMessage(message, { force: command2.opts().force });
-    if (!confirmed) {
-      exitWith(1, failMessage);
-    }
-  };
-};
-const confirmMessage = async (message, { force } = {}) => {
-  if (force === true) {
-    console.log(`${chalk__default.default.green("?")} ${chalk__default.default.bold(message)} ${chalk__default.default.cyan("Yes")}`);
-    return true;
-  }
-  const answers = await inquirer__default.default.prompt([
-    {
-      type: "confirm",
-      message,
-      name: `confirm`,
-      default: false
-    }
-  ]);
-  return answers.confirm;
-};
-const forceOption = new commander.Option(
-  "--force",
-  `Automatically answer "yes" to all prompts, including potentially destructive requests, and run non-interactively.`
-);
-const {
-  errors: { TransferEngineInitializationError: TransferEngineInitializationError2 }
-} = engineDatatransfer;
-const exitMessageText = (process2, error = false) => {
-  const processCapitalized = process2[0].toUpperCase() + process2.slice(1);
-  if (!error) {
-    return chalk__default.default.bold(
-      chalk__default.default.green(`${processCapitalized} process has been completed successfully!`)
-    );
-  }
-  return chalk__default.default.bold(chalk__default.default.red(`${processCapitalized} process failed.`));
-};
-const pad = (n) => {
-  return (n < 10 ? "0" : "") + String(n);
-};
-const yyyymmddHHMMSS = () => {
-  const date = /* @__PURE__ */ new Date();
-  return date.getFullYear() + pad(date.getMonth() + 1) + pad(date.getDate()) + pad(date.getHours()) + pad(date.getMinutes()) + pad(date.getSeconds());
-};
-const getDefaultExportName = () => {
-  return `export_${yyyymmddHHMMSS()}`;
-};
-const buildTransferTable = (resultData) => {
-  if (!resultData) {
-    return;
-  }
-  const table = new Table__default.default({
-    head: ["Type", "Count", "Size"].map((text) => chalk__default.default.bold.blue(text))
-  });
-  let totalBytes = 0;
-  let totalItems = 0;
-  Object.keys(resultData).forEach((stage) => {
-    const item = resultData[stage];
-    if (!item) {
-      return;
-    }
-    table.push([
-      { hAlign: "left", content: chalk__default.default.bold(stage) },
-      { hAlign: "right", content: item.count },
-      { hAlign: "right", content: `${readableBytes(item.bytes, 1, 11)} ` }
-    ]);
-    totalBytes += item.bytes;
-    totalItems += item.count;
-    if (item.aggregates) {
-      Object.keys(item.aggregates).sort().forEach((subkey) => {
-        if (!item.aggregates) {
-          return;
-        }
-        const subitem = item.aggregates[subkey];
-        table.push([
-          { hAlign: "left", content: `-- ${chalk__default.default.bold.grey(subkey)}` },
-          { hAlign: "right", content: chalk__default.default.grey(subitem.count) },
-          { hAlign: "right", content: chalk__default.default.grey(`(${readableBytes(subitem.bytes, 1, 11)})`) }
-        ]);
-      });
-    }
-  });
-  table.push([
-    { hAlign: "left", content: chalk__default.default.bold.green("Total") },
-    { hAlign: "right", content: chalk__default.default.bold.green(totalItems) },
-    { hAlign: "right", content: `${chalk__default.default.bold.green(readableBytes(totalBytes, 1, 11))} ` }
-  ]);
-  return table;
-};
-const DEFAULT_IGNORED_CONTENT_TYPES = [
-  "admin::permission",
-  "admin::user",
-  "admin::role",
-  "admin::api-token",
-  "admin::api-token-permission",
-  "admin::transfer-token",
-  "admin::transfer-token-permission",
-  "admin::audit-log",
-  "plugin::content-releases.release",
-  "plugin::content-releases.release-action"
-];
-const abortTransfer = async ({
-  engine,
-  strapi: strapi2
-}) => {
-  try {
-    await engine.abortTransfer();
-    await strapi2.destroy();
-  } catch (e) {
-    return false;
-  }
-  return true;
-};
-const setSignalHandler = async (handler, signals = ["SIGINT", "SIGTERM", "SIGQUIT"]) => {
-  signals.forEach((signal) => {
-    process.removeAllListeners(signal);
-    process.on(signal, handler);
-  });
-};
-const createStrapiInstance = async (opts = {}) => {
-  try {
-    const appContext = await strapiFactory__default.default.compile();
-    const app = strapiFactory__default.default({ ...opts, ...appContext });
-    app.log.level = opts.logLevel || "error";
-    return await app.load();
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ECONNREFUSED") {
-      throw new Error("Process failed. Check the database connection with your Strapi project.");
-    }
-    throw error;
-  }
-};
-const transferDataTypes = Object.keys(TransferGroupPresets);
-const throttleOption = new commander.Option(
-  "--throttle <delay after each entity>",
-  `Add a delay in milliseconds between each transferred entity`
-).argParser(parseInteger).hideHelp();
-const excludeOption = new commander.Option(
-  "--exclude <comma-separated data types>",
-  `Exclude data using comma-separated types. Available types: ${transferDataTypes.join(",")}`
-).argParser(getParseListWithChoices(transferDataTypes, 'Invalid options for "exclude"'));
-const onlyOption = new commander.Option(
-  "--only <command-separated data types>",
-  `Include only these types of data (plus schemas). Available types: ${transferDataTypes.join(",")}`
-).argParser(getParseListWithChoices(transferDataTypes, 'Invalid options for "only"'));
-const validateExcludeOnly = (command2) => {
-  const { exclude, only } = command2.opts();
-  if (!only || !exclude) {
-    return;
-  }
-  const choicesInBoth = only.filter((n) => {
-    return exclude.indexOf(n) !== -1;
-  });
-  if (choicesInBoth.length > 0) {
-    exitWith(
-      1,
-      `Data types may not be used in both "exclude" and "only" in the same command. Found in both: ${choicesInBoth.join(
-        ","
-      )}`
-    );
-  }
-};
-const errorColors = {
-  fatal: chalk__default.default.red,
-  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);
-    }
-    if (kind === "warning") {
-      const { origin: origin2, message } = details;
-      logger$1.warn(`(${origin2 ?? "transfer"}) ${message}`);
-    }
-  } catch (err) {
-    logger$1.error(err);
-  }
-};
-const loadersFactory = (defaultLoaders = {}) => {
-  const loaders = defaultLoaders;
-  const updateLoader = (stage, data) => {
-    if (!(stage in loaders)) {
-      createLoader(stage);
-    }
-    const stageData = data[stage];
-    const elapsedTime = stageData?.startTime ? (stageData?.endTime || Date.now()) - stageData.startTime : 0;
-    const size = `size: ${readableBytes(stageData?.bytes ?? 0)}`;
-    const elapsed = `elapsed: ${elapsedTime} ms`;
-    const speed = elapsedTime > 0 ? `(${readableBytes((stageData?.bytes ?? 0) * 1e3 / elapsedTime)}/s)` : "";
-    loaders[stage].text = `${stage}: ${stageData?.count ?? 0} transfered (${size}) (${elapsed}) ${!stageData?.endTime ? speed : ""}`;
-    return loaders[stage];
-  };
-  const createLoader = (stage) => {
-    Object.assign(loaders, { [stage]: ora__default.default() });
-    return loaders[stage];
-  };
-  const getLoader = (stage) => {
-    return loaders[stage];
-  };
-  return {
-    updateLoader,
-    createLoader,
-    getLoader
-  };
-};
-const getTransferTelemetryPayload = (engine) => {
-  return {
-    eventProperties: {
-      source: engine?.sourceProvider?.name,
-      destination: engine?.destinationProvider?.name
-    }
-  };
-};
-const getDiffHandler = (engine, {
-  force,
-  action: action2
-}) => {
-  return async (context, next) => {
-    setSignalHandler(async () => {
-      await abortTransfer({ engine, strapi });
-      exitWith(1, exitMessageText(action2, true));
-    });
-    let workflowsStatus;
-    const source = "Schema Integrity";
-    Object.entries(context.diffs).forEach(([uid, diffs]) => {
-      for (const diff2 of diffs) {
-        const path2 = [uid].concat(diff2.path).join(".");
-        const endPath = diff2.path[diff2.path.length - 1];
-        if (uid === "admin::workflow" || uid === "admin::workflow-stage" || endPath?.startsWith("strapi_stage") || endPath?.startsWith("strapi_assignee")) {
-          workflowsStatus = diff2.kind;
-        } else if (diff2.kind === "added") {
-          engine.reportWarning(chalk__default.default.red(`${chalk__default.default.bold(path2)} does not exist on source`), source);
-        } else if (diff2.kind === "deleted") {
-          engine.reportWarning(
-            chalk__default.default.red(`${chalk__default.default.bold(path2)} does not exist on destination`),
-            source
-          );
-        } else if (diff2.kind === "modified") {
-          engine.reportWarning(chalk__default.default.red(`${chalk__default.default.bold(path2)} has a different data type`), source);
-        }
-      }
-    });
-    if (workflowsStatus === "added") {
-      engine.reportWarning(chalk__default.default.red(`Review workflows feature does not exist on source`), source);
-    } else if (workflowsStatus === "deleted") {
-      engine.reportWarning(
-        chalk__default.default.red(`Review workflows feature does not exist on destination`),
-        source
-      );
-    } else if (workflowsStatus === "modified") {
-      engine.panic(
-        new TransferEngineInitializationError2("Unresolved differences in schema [review workflows]")
-      );
-    }
-    const confirmed = await confirmMessage(
-      "There are differences in schema between the source and destination, and the data listed above will be lost. Are you sure you want to continue?",
-      {
-        force
-      }
-    );
-    setSignalHandler(() => abortTransfer({ engine, strapi }));
-    if (confirmed) {
-      context.ignoredDiffs = fp.merge(context.diffs, context.ignoredDiffs);
-    }
-    return next(context);
-  };
-};
-const getAssetsBackupHandler = (engine, {
-  force,
-  action: action2
-}) => {
-  return async (context, next) => {
-    setSignalHandler(async () => {
-      await abortTransfer({ engine, strapi });
-      exitWith(1, exitMessageText(action2, true));
-    });
-    console.warn(
-      "The backup for the assets could not be created inside the public directory. Ensure Strapi has write permissions on the public directory."
-    );
-    const confirmed = await confirmMessage(
-      "Do you want to continue without backing up your public/uploads files?",
-      {
-        force
-      }
-    );
-    if (confirmed) {
-      context.ignore = true;
-    }
-    setSignalHandler(() => abortTransfer({ engine, strapi }));
-    return next(context);
-  };
-};
-const shouldSkipStage = (opts, dataKind) => {
-  if (opts.exclude?.includes(dataKind)) {
-    return true;
-  }
-  if (opts.only) {
-    return !opts.only.includes(dataKind);
-  }
-  return false;
-};
-const parseRestoreFromOptions = (opts) => {
-  const entitiesOptions = {
-    exclude: DEFAULT_IGNORED_CONTENT_TYPES,
-    include: void 0
-  };
-  if (opts.only && !opts.only.includes("content") || opts.exclude?.includes("content")) {
-    entitiesOptions.include = [];
-  }
-  const restoreConfig = {
-    entities: entitiesOptions,
-    assets: !shouldSkipStage(opts, "files"),
-    configuration: {
-      webhook: !shouldSkipStage(opts, "config"),
-      coreStore: !shouldSkipStage(opts, "config")
-    }
-  };
-  return restoreConfig;
-};
-const {
-  providers: { createLocalFileDestinationProvider }
-} = file;
-const {
-  providers: { createLocalStrapiSourceProvider: createLocalStrapiSourceProvider$1 }
-} = strapiDatatransfer;
-const BYTES_IN_MB = 1024 * 1024;
-const action$2 = async (opts) => {
-  if (!fp.isObject(opts)) {
-    exitWith(1, "Could not parse command arguments");
-  }
-  const strapi2 = await createStrapiInstance();
-  const source = createSourceProvider(strapi2);
-  const destination = createDestinationProvider(opts);
-  const engine = createTransferEngine$2(source, destination, {
-    versionStrategy: "ignore",
-    // for an export to file, versionStrategy will always be skipped
-    schemaStrategy: "ignore",
-    // for an export to file, schemaStrategy will always be skipped
-    exclude: opts.exclude,
-    only: opts.only,
-    throttle: opts.throttle,
-    transforms: {
-      links: [
-        {
-          filter(link2) {
-            return !DEFAULT_IGNORED_CONTENT_TYPES.includes(link2.left.type) && !DEFAULT_IGNORED_CONTENT_TYPES.includes(link2.right.type);
-          }
-        }
-      ],
-      entities: [
-        {
-          filter(entity2) {
-            return !DEFAULT_IGNORED_CONTENT_TYPES.includes(entity2.type);
-          }
-        }
-      ]
-    }
-  });
-  engine.diagnostics.onDiagnostic(formatDiagnostic("export"));
-  const progress = engine.progress.stream;
-  const { updateLoader } = loadersFactory();
-  progress.on(`stage::start`, ({ stage, data }) => {
-    updateLoader(stage, data).start();
-  });
-  progress.on("stage::finish", ({ stage, data }) => {
-    updateLoader(stage, data).succeed();
-  });
-  progress.on("stage::progress", ({ stage, data }) => {
-    updateLoader(stage, data);
-  });
-  progress.on("transfer::start", async () => {
-    console.log(`Starting export...`);
-    await strapi2.telemetry.send("didDEITSProcessStart", getTransferTelemetryPayload(engine));
-  });
-  let results;
-  let outFile;
-  try {
-    setSignalHandler(() => abortTransfer({ engine, strapi: strapi2 }));
-    results = await engine.transfer();
-    outFile = results.destination?.file?.path ?? "";
-    const outFileExists = await fse__namespace.default.pathExists(outFile);
-    if (!outFileExists) {
-      throw new TransferEngineTransferError(`Export file not created "${outFile}"`);
-    }
-    await strapi2.telemetry.send("didDEITSProcessFinish", getTransferTelemetryPayload(engine));
-    try {
-      const table = buildTransferTable(results.engine);
-      console.log(table?.toString());
-    } catch (e) {
-      console.error("There was an error displaying the results of the transfer.");
-    }
-    console.log(`Export archive is in ${chalk__default.default.green(outFile)}`);
-    exitWith(0, exitMessageText("export"));
-  } catch {
-    await strapi2.telemetry.send("didDEITSProcessFail", getTransferTelemetryPayload(engine));
-    exitWith(1, exitMessageText("export", true));
-  }
-};
-const createSourceProvider = (strapi2) => {
-  return createLocalStrapiSourceProvider$1({
-    async getStrapi() {
-      return strapi2;
-    }
-  });
-};
-const createDestinationProvider = (opts) => {
-  const { file: file2, compress, encrypt, key, maxSizeJsonl } = opts;
-  const filepath = fp.isString(file2) && file2.length > 0 ? file2 : getDefaultExportName();
-  const maxSizeJsonlInMb = fp.isFinite(fp.toNumber(maxSizeJsonl)) ? fp.toNumber(maxSizeJsonl) * BYTES_IN_MB : void 0;
-  return createLocalFileDestinationProvider({
-    file: {
-      path: filepath,
-      maxSizeJsonl: maxSizeJsonlInMb
-    },
-    encryption: {
-      enabled: encrypt ?? false,
-      key: encrypt ? key : void 0
-    },
-    compression: {
-      enabled: compress ?? false
-    }
-  });
-};
-const command$2 = ({ command: command2 }) => {
-  command2.command("export").description("Export data from Strapi to file").allowExcessArguments(false).addOption(
-    new commander.Option("--no-encrypt", `Disables 'aes-128-ecb' encryption of the output file`).default(
-      true
-    )
-  ).addOption(
-    new commander.Option("--no-compress", "Disables gzip compression of output file").default(true)
-  ).addOption(
-    new commander.Option(
-      "-k, --key <string>",
-      "Provide encryption key in command instead of using the prompt"
-    )
-  ).addOption(
-    new commander.Option("-f, --file <file>", "name to use for exported file (without extensions)")
-  ).addOption(excludeOption).addOption(onlyOption).addOption(throttleOption).hook("preAction", validateExcludeOnly).hook("preAction", promptEncryptionKey).action(action$2);
-};
-const {
-  providers: { createLocalFileSourceProvider }
-} = file;
-const {
-  providers: { createLocalStrapiDestinationProvider: createLocalStrapiDestinationProvider$1, DEFAULT_CONFLICT_STRATEGY }
-} = strapiDatatransfer;
-const { createTransferEngine: createTransferEngine$1, DEFAULT_VERSION_STRATEGY, DEFAULT_SCHEMA_STRATEGY } = engineDatatransfer;
-const action$1 = async (opts) => {
-  if (!fp.isObject(opts)) {
-    exitWith(1, "Could not parse arguments");
-  }
-  const sourceOptions = getLocalFileSourceOptions(opts);
-  const source = createLocalFileSourceProvider(sourceOptions);
-  const strapiInstance = await createStrapiInstance();
-  const engineOptions = {
-    versionStrategy: DEFAULT_VERSION_STRATEGY,
-    schemaStrategy: DEFAULT_SCHEMA_STRATEGY,
-    exclude: opts.exclude,
-    only: opts.only,
-    throttle: opts.throttle,
-    transforms: {
-      links: [
-        {
-          filter(link2) {
-            return !DEFAULT_IGNORED_CONTENT_TYPES.includes(link2.left.type) && !DEFAULT_IGNORED_CONTENT_TYPES.includes(link2.right.type);
-          }
-        }
-      ],
-      entities: [
-        {
-          filter: (entity2) => !DEFAULT_IGNORED_CONTENT_TYPES.includes(entity2.type)
-        }
-      ]
-    }
-  };
-  const destinationOptions = {
-    async getStrapi() {
-      return strapiInstance;
-    },
-    autoDestroy: false,
-    strategy: opts.conflictStrategy || DEFAULT_CONFLICT_STRATEGY,
-    restore: parseRestoreFromOptions(engineOptions)
-  };
-  const destination = createLocalStrapiDestinationProvider$1(destinationOptions);
-  destination.onWarning = (message) => console.warn(`
-${chalk__default.default.yellow("warn")}: ${message}`);
-  const engine2 = createTransferEngine$1(source, destination, engineOptions);
-  engine2.diagnostics.onDiagnostic(formatDiagnostic("import"));
-  const progress = engine2.progress.stream;
-  const { updateLoader } = loadersFactory();
-  engine2.onSchemaDiff(getDiffHandler(engine2, { force: opts.force, action: "import" }));
-  progress.on(`stage::start`, ({ stage, data }) => {
-    updateLoader(stage, data).start();
-  });
-  progress.on("stage::finish", ({ stage, data }) => {
-    updateLoader(stage, data).succeed();
-  });
-  progress.on("stage::progress", ({ stage, data }) => {
-    updateLoader(stage, data);
-  });
-  progress.on("transfer::start", async () => {
-    console.log("Starting import...");
-    await strapiInstance.telemetry.send(
-      "didDEITSProcessStart",
-      getTransferTelemetryPayload(engine2)
-    );
-  });
-  let results;
-  try {
-    setSignalHandler(() => abortTransfer({ engine: engine2, strapi }));
-    results = await engine2.transfer();
-    try {
-      const table = buildTransferTable(results.engine);
-      console.log(table?.toString());
-    } catch (e) {
-      console.error("There was an error displaying the results of the transfer.");
-    }
-    await strapiInstance.telemetry.send(
-      "didDEITSProcessFinish",
-      getTransferTelemetryPayload(engine2)
-    );
-    await strapiInstance.destroy();
-    exitWith(0, exitMessageText("import"));
-  } catch (e) {
-    await strapiInstance.telemetry.send("didDEITSProcessFail", getTransferTelemetryPayload(engine2));
-    exitWith(1, exitMessageText("import", true));
-  }
-};
-const getLocalFileSourceOptions = (opts) => {
-  const options = {
-    file: { path: opts.file ?? "" },
-    compression: { enabled: !!opts.decompress },
-    encryption: { enabled: !!opts.decrypt, key: opts.key }
-  };
-  return options;
-};
-const command$1 = ({ command: command2 }) => {
-  command2.command("import").description("Import data from file to Strapi").allowExcessArguments(false).requiredOption(
-    "-f, --file <file>",
-    "path and filename for the Strapi export file you want to import"
-  ).addOption(
-    new commander.Option(
-      "-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) => {
-    const opts = thisCommand.opts();
-    const ext = path__default.default.extname(String(opts.file));
-    if (ext === ".enc") {
-      if (!opts.key) {
-        const answers = await inquirer__default.default.prompt([
-          {
-            type: "password",
-            message: "Please enter your decryption key",
-            name: "key"
-          }
-        ]);
-        if (!answers.key?.length) {
-          exitWith(1, "No key entered, aborting import.");
-        }
-        opts.key = answers.key;
-      }
-    }
-  }).hook("preAction", (thisCommand) => {
-    const opts = thisCommand.opts();
-    const { extname, parse } = path__default.default;
-    let file2 = opts.file;
-    if (extname(file2) === ".enc") {
-      file2 = parse(file2).name;
-      thisCommand.opts().decrypt = true;
-    } else {
-      thisCommand.opts().decrypt = false;
-    }
-    if (extname(file2) === ".gz") {
-      file2 = parse(file2).name;
-      thisCommand.opts().decompress = true;
-    } else {
-      thisCommand.opts().decompress = false;
-    }
-    if (extname(file2) !== ".tar") {
-      exitWith(
-        1,
-        `The file '${opts.file}' does not appear to be a valid Strapi data file. It must have an extension ending in .tar[.gz][.enc]`
-      );
-    }
-  }).hook(
-    "preAction",
-    getCommanderConfirmMessage(
-      "The import will delete your existing data! Are you sure you want to proceed?",
-      { failMessage: "Import process aborted" }
-    )
-  ).action(action$1);
-};
-const { createTransferEngine } = engineDatatransfer;
-const {
-  providers: {
-    createRemoteStrapiDestinationProvider,
-    createLocalStrapiSourceProvider,
-    createLocalStrapiDestinationProvider,
-    createRemoteStrapiSourceProvider
-  }
-} = strapiDatatransfer;
-const action = async (opts) => {
-  if (!fp.isObject(opts)) {
-    exitWith(1, "Could not parse command arguments");
-  }
-  if (!(opts.from || opts.to) || opts.from && opts.to) {
-    exitWith(1, "Exactly one source (from) or destination (to) option must be provided");
-  }
-  const strapi2 = await createStrapiInstance();
-  let source;
-  let destination;
-  if (!opts.from) {
-    source = createLocalStrapiSourceProvider({
-      getStrapi: () => strapi2
-    });
-  } else {
-    if (!opts.fromToken) {
-      exitWith(1, "Missing token for remote destination");
-    }
-    source = createRemoteStrapiSourceProvider({
-      getStrapi: () => strapi2,
-      url: opts.from,
-      auth: {
-        type: "token",
-        token: opts.fromToken
-      }
-    });
-  }
-  if (!opts.to) {
-    destination = createLocalStrapiDestinationProvider({
-      getStrapi: () => strapi2,
-      strategy: "restore",
-      restore: parseRestoreFromOptions(opts)
-    });
-  } else {
-    if (!opts.toToken) {
-      exitWith(1, "Missing token for remote destination");
-    }
-    destination = createRemoteStrapiDestinationProvider({
-      url: opts.to,
-      auth: {
-        type: "token",
-        token: opts.toToken
-      },
-      strategy: "restore",
-      restore: parseRestoreFromOptions(opts)
-    });
-  }
-  if (!source || !destination) {
-    exitWith(1, "Could not create providers");
-  }
-  const engine = createTransferEngine(source, destination, {
-    versionStrategy: "exact",
-    schemaStrategy: "strict",
-    exclude: opts.exclude,
-    only: opts.only,
-    throttle: opts.throttle,
-    transforms: {
-      links: [
-        {
-          filter(link2) {
-            return !DEFAULT_IGNORED_CONTENT_TYPES.includes(link2.left.type) && !DEFAULT_IGNORED_CONTENT_TYPES.includes(link2.right.type);
-          }
-        }
-      ],
-      entities: [
-        {
-          filter(entity2) {
-            return !DEFAULT_IGNORED_CONTENT_TYPES.includes(entity2.type);
-          }
-        }
-      ]
-    }
-  });
-  engine.diagnostics.onDiagnostic(formatDiagnostic("transfer"));
-  const progress = engine.progress.stream;
-  const { updateLoader } = loadersFactory();
-  engine.onSchemaDiff(getDiffHandler(engine, { force: opts.force, action: "transfer" }));
-  engine.addErrorHandler(
-    "ASSETS_DIRECTORY_ERR",
-    getAssetsBackupHandler(engine, { force: opts.force, action: "transfer" })
-  );
-  progress.on(`stage::start`, ({ stage, data }) => {
-    updateLoader(stage, data).start();
-  });
-  progress.on("stage::finish", ({ stage, data }) => {
-    updateLoader(stage, data).succeed();
-  });
-  progress.on("stage::progress", ({ stage, data }) => {
-    updateLoader(stage, data);
-  });
-  progress.on("stage::error", ({ stage, data }) => {
-    updateLoader(stage, data).fail();
-  });
-  progress.on("transfer::start", async () => {
-    console.log(`Starting transfer...`);
-    await strapi2.telemetry.send("didDEITSProcessStart", getTransferTelemetryPayload(engine));
-  });
-  let results;
-  try {
-    setSignalHandler(() => abortTransfer({ engine, strapi: strapi2 }));
-    results = await engine.transfer();
-    await strapi2.telemetry.send("didDEITSProcessFinish", getTransferTelemetryPayload(engine));
-    try {
-      const table = buildTransferTable(results.engine);
-      console.log(table?.toString());
-    } catch (e) {
-      console.error("There was an error displaying the results of the transfer.");
-    }
-    exitWith(0, exitMessageText("transfer"));
-  } catch (e) {
-    await strapi2.telemetry.send("didDEITSProcessFail", getTransferTelemetryPayload(engine));
-    exitWith(1, exitMessageText("transfer", true));
-  }
-};
-const command = ({ command: command2 }) => {
-  command2.command("transfer").description("Transfer data from one source to another").allowExcessArguments(false).addOption(
-    new commander.Option(
-      "--from <sourceURL>",
-      `URL of the remote Strapi instance to get data from`
-    ).argParser(parseURL)
-  ).addOption(new commander.Option("--from-token <token>", `Transfer token for the remote Strapi source`)).addOption(
-    new commander.Option(
-      "--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(
-    "preAction",
-    ifOptions(
-      (opts) => !(opts.from || opts.to) || opts.from && opts.to,
-      async () => exitWith(
-        1,
-        "Exactly one remote source (from) or destination (to) option must be provided"
-      )
-    )
-  ).hook(
-    "preAction",
-    ifOptions(
-      (opts) => opts.from,
-      async (thisCommand) => {
-        assertUrlHasProtocol(thisCommand.opts().from, ["https:", "http:"]);
-        if (!thisCommand.opts().fromToken) {
-          const answers = await inquirer__default.default.prompt([
-            {
-              type: "password",
-              message: "Please enter your transfer token for the remote Strapi source",
-              name: "fromToken"
-            }
-          ]);
-          if (!answers.fromToken?.length) {
-            exitWith(1, "No token provided for remote source, aborting transfer.");
-          }
-          thisCommand.opts().fromToken = answers.fromToken;
-        }
-        await getCommanderConfirmMessage(
-          "The transfer will delete all the local Strapi assets and its database. Are you sure you want to proceed?",
-          { failMessage: "Transfer process aborted" }
-        )(thisCommand);
-      }
-    )
-  ).hook(
-    "preAction",
-    ifOptions(
-      (opts) => opts.to,
-      async (thisCommand) => {
-        assertUrlHasProtocol(thisCommand.opts().to, ["https:", "http:"]);
-        if (!thisCommand.opts().toToken) {
-          const answers = await inquirer__default.default.prompt([
-            {
-              type: "password",
-              message: "Please enter your transfer token for the remote Strapi destination",
-              name: "toToken"
-            }
-          ]);
-          if (!answers.toToken?.length) {
-            exitWith(1, "No token provided for remote destination, aborting transfer.");
-          }
-          thisCommand.opts().toToken = answers.toToken;
-        }
-        await getCommanderConfirmMessage(
-          "The transfer will delete existing data from the remote Strapi! Are you sure you want to proceed?",
-          { failMessage: "Transfer process aborted" }
-        )(thisCommand);
-      }
-    )
-  ).action(action);
-};
 const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  export: command$2,
-  import: command$1,
-  transfer: command
+  providers: index$1
 }, Symbol.toStringTag, { value: "Module" }));
-exports.commands = index;
-exports.engine = engineDatatransfer;
-exports.file = file;
-exports.strapi = strapiDatatransfer;
-exports.utils = index$6;
+exports.engine = index$7;
+exports.file = index;
+exports.strapi = index$2;
+exports.utils = index$8;
 //# sourceMappingURL=index.js.map