@strapi/data-transfer 4.14.0-alpha.0 → 4.14.0

package/dist/engine/index.js

@@ -22,18 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _TransferEngine_instances, _TransferEngine_metadata, _TransferEngine_schema, _TransferEngine_handlers, _TransferEngine_currentStream, _TransferEngine_createStageTransformStream, _TransferEngine_updateTransferProgress, _TransferEngine_progressTracker, _TransferEngine_emitTransferUpdate, _TransferEngine_emitStageUpdate, _TransferEngine_assertStrapiVersionIntegrity, _TransferEngine_assertSchemasMatching, _TransferEngine_transferStage, _TransferEngine_resolveProviderResource, _TransferEngine_getSchemas;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errors = exports.createTransferEngine = exports.DEFAULT_SCHEMA_STRATEGY = exports.DEFAULT_VERSION_STRATEGY = exports.TransferGroupPresets = exports.TRANSFER_STAGES = void 0;
 const stream_1 = require("stream");
@@ -81,36 +69,41 @@ exports.TransferGroupPresets = {
 exports.DEFAULT_VERSION_STRATEGY = 'ignore';
 exports.DEFAULT_SCHEMA_STRATEGY = 'strict';
 class TransferEngine {
+    sourceProvider;
+    destinationProvider;
+    options;
+    #metadata = {};
+    #schema = {};
+    // Progress of the current stage
+    progress;
+    diagnostics;
+    #handlers = {
+        schemaDiff: [],
+        errors: {},
+    };
     onSchemaDiff(handler) {
-        __classPrivateFieldGet(this, _TransferEngine_handlers, "f")?.schemaDiff?.push(handler);
+        this.#handlers?.schemaDiff?.push(handler);
     }
     addErrorHandler(handlerName, handler) {
-        if (!__classPrivateFieldGet(this, _TransferEngine_handlers, "f").errors[handlerName]) {
-            __classPrivateFieldGet(this, _TransferEngine_handlers, "f").errors[handlerName] = [];
+        if (!this.#handlers.errors[handlerName]) {
+            this.#handlers.errors[handlerName] = [];
         }
-        __classPrivateFieldGet(this, _TransferEngine_handlers, "f").errors[handlerName]?.push(handler);
+        this.#handlers.errors[handlerName]?.push(handler);
     }
     async attemptResolveError(error) {
         const context = {};
         if (error instanceof providers_1.ProviderTransferError && error.details?.details.code) {
             const errorCode = error.details?.details.code;
-            if (!__classPrivateFieldGet(this, _TransferEngine_handlers, "f").errors[errorCode]) {
-                __classPrivateFieldGet(this, _TransferEngine_handlers, "f").errors[errorCode] = [];
+            if (!this.#handlers.errors[errorCode]) {
+                this.#handlers.errors[errorCode] = [];
             }
-            await utils.middleware.runMiddleware(context ?? {}, __classPrivateFieldGet(this, _TransferEngine_handlers, "f").errors[errorCode] ?? []);
+            await utils.middleware.runMiddleware(context ?? {}, this.#handlers.errors[errorCode] ?? []);
         }
         return !!context.ignore;
     }
+    // Save the currently open stream so that we can access it at any time
+    #currentStream;
     constructor(sourceProvider, destinationProvider, options) {
-        _TransferEngine_instances.add(this);
-        _TransferEngine_metadata.set(this, {});
-        _TransferEngine_schema.set(this, {});
-        _TransferEngine_handlers.set(this, {
-            schemaDiff: [],
-            errors: {},
-        });
-        // Save the currently open stream so that we can access it at any time
-        _TransferEngine_currentStream.set(this, void 0);
         this.diagnostics = (0, diagnostic_1.createDiagnosticReporter)();
         (0, validation_1.validateProvider)('source', sourceProvider);
         (0, validation_1.validateProvider)('destination', destinationProvider);
@@ -159,6 +152,207 @@ class TransferEngine {
             details: { createdAt: new Date(), message, params },
         });
     }
+    /**
+     * Create and return a transform stream based on the given stage and options.
+     *
+     * Allowed transformations includes 'filter' and 'map'.
+     */
+    #createStageTransformStream(key, options = {}) {
+        const { includeGlobal = true } = options;
+        const { throttle } = this.options;
+        const { global: globalTransforms, [key]: stageTransforms } = this.options?.transforms ?? {};
+        let stream = new stream_1.PassThrough({ objectMode: true });
+        const applyTransforms = (transforms = []) => {
+            const chainTransforms = [];
+            for (const transform of transforms) {
+                if ('filter' in transform) {
+                    chainTransforms.push(utils.stream.filter(transform.filter));
+                }
+                if ('map' in transform) {
+                    chainTransforms.push(utils.stream.map(transform.map));
+                }
+            }
+            if (chainTransforms.length) {
+                stream = stream.pipe((0, stream_chain_1.chain)(chainTransforms));
+            }
+        };
+        if (includeGlobal) {
+            applyTransforms(globalTransforms);
+        }
+        if ((0, fp_1.isNumber)(throttle) && throttle > 0) {
+            stream = stream.pipe(new stream_1.PassThrough({
+                objectMode: true,
+                async transform(data, _encoding, callback) {
+                    await new Promise((resolve) => {
+                        setTimeout(resolve, throttle);
+                    });
+                    callback(null, data);
+                },
+            }));
+        }
+        applyTransforms(stageTransforms);
+        return stream;
+    }
+    /**
+     * Update the Engine's transfer progress data for a given stage.
+     *
+     * Providing aggregate options enable custom computation to get the size (bytes) or the aggregate key associated with the data
+     */
+    #updateTransferProgress(stage, data, aggregate) {
+        if (!this.progress.data[stage]) {
+            this.progress.data[stage] = { count: 0, bytes: 0, startTime: Date.now() };
+        }
+        const stageProgress = this.progress.data[stage];
+        if (!stageProgress) {
+            return;
+        }
+        const size = aggregate?.size?.(data) ?? JSON.stringify(data).length;
+        const key = aggregate?.key?.(data);
+        stageProgress.count += 1;
+        stageProgress.bytes += size;
+        // Handle aggregate updates if necessary
+        if (key) {
+            if (!stageProgress.aggregates) {
+                stageProgress.aggregates = {};
+            }
+            const { aggregates } = stageProgress;
+            if (!aggregates[key]) {
+                aggregates[key] = { count: 0, bytes: 0 };
+            }
+            aggregates[key].count += 1;
+            aggregates[key].bytes += size;
+        }
+    }
+    /**
+     * Create and return a PassThrough stream.
+     *
+     * Upon writing data into it, it'll update the Engine's transfer progress data and trigger stage update events.
+     */
+    #progressTracker(stage, aggregate) {
+        return new stream_1.PassThrough({
+            objectMode: true,
+            transform: (data, _encoding, callback) => {
+                this.#updateTransferProgress(stage, data, aggregate);
+                this.#emitStageUpdate('progress', stage);
+                callback(null, data);
+            },
+        });
+    }
+    /**
+     * Shorthand method used to trigger transfer update events to every listeners
+     */
+    #emitTransferUpdate(type, payload) {
+        this.progress.stream.emit(`transfer::${type}`, payload);
+    }
+    /**
+     * Shorthand method used to trigger stage update events to every listeners
+     */
+    #emitStageUpdate(type, transferStage) {
+        this.progress.stream.emit(`stage::${type}`, {
+            data: this.progress.data,
+            stage: transferStage,
+        });
+    }
+    /**
+     * Run a version check between two strapi version (source and destination) using the strategy given to the engine during initialization.
+     *
+     * If there is a mismatch, throws a validation error.
+     */
+    #assertStrapiVersionIntegrity(sourceVersion, destinationVersion) {
+        const strategy = this.options.versionStrategy || exports.DEFAULT_VERSION_STRATEGY;
+        const reject = () => {
+            throw new errors_1.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}`, {
+                check: 'strapi.version',
+                strategy,
+                versions: { source: sourceVersion, destination: destinationVersion },
+            });
+        };
+        if (!sourceVersion ||
+            !destinationVersion ||
+            strategy === 'ignore' ||
+            destinationVersion === sourceVersion) {
+            return;
+        }
+        let diff;
+        try {
+            diff = (0, semver_1.diff)(sourceVersion, destinationVersion);
+        }
+        catch {
+            reject();
+        }
+        if (!diff) {
+            return;
+        }
+        const validPatch = ['prelease', 'build'];
+        const validMinor = [...validPatch, 'patch', 'prepatch'];
+        const validMajor = [...validMinor, 'minor', 'preminor'];
+        if (strategy === 'patch' && validPatch.includes(diff)) {
+            return;
+        }
+        if (strategy === 'minor' && validMinor.includes(diff)) {
+            return;
+        }
+        if (strategy === 'major' && validMajor.includes(diff)) {
+            return;
+        }
+        reject();
+    }
+    /**
+     * Run a check between two set of schemas (source and destination) using the strategy given to the engine during initialization.
+     *
+     * 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 || exports.DEFAULT_SCHEMA_STRATEGY;
+        if (strategy === 'ignore') {
+            return;
+        }
+        const keys = (0, fp_1.uniq)(Object.keys(sourceSchemas).concat(Object.keys(destinationSchemas)));
+        const diffs = {};
+        keys.forEach((key) => {
+            const sourceSchema = sourceSchemas[key];
+            const destinationSchema = destinationSchemas[key];
+            const schemaDiffs = (0, validation_1.compareSchemas)(sourceSchema, destinationSchema, strategy);
+            if (schemaDiffs.length) {
+                diffs[key] = schemaDiffs;
+            }
+        });
+        if (!(0, fp_1.isEmpty)(diffs)) {
+            const formattedDiffs = Object.entries(diffs)
+                .map(([uid, ctDiffs]) => {
+                let msg = `- ${uid}:${os_1.EOL}`;
+                msg += ctDiffs
+                    .sort((a, b) => (a.kind > b.kind ? -1 : 1))
+                    .map((diff) => {
+                    const path = diff.path.join('.');
+                    if (diff.kind === 'added') {
+                        return `${path} exists in destination schema but not in source schema and the data will not be transferred.`;
+                    }
+                    if (diff.kind === 'deleted') {
+                        return `${path} exists in source schema but not in destination schema and the data will not be transferred.`;
+                    }
+                    if (diff.kind === 'modified') {
+                        if (diff.types[0] === diff.types[1]) {
+                            return `Schema value changed at "${path}": "${diff.values[0]}" (${diff.types[0]}) => "${diff.values[1]}" (${diff.types[1]})`;
+                        }
+                        return `Schema has differing data types at "${path}": "${diff.values[0]}" (${diff.types[0]}) => "${diff.values[1]}" (${diff.types[1]})`;
+                    }
+                    throw new errors_1.TransferEngineValidationError(`Invalid diff found for "${uid}"`, {
+                        check: `schema on ${uid}`,
+                    });
+                })
+                    .map((line) => `  - ${line}`)
+                    .join(os_1.EOL);
+                return msg;
+            })
+                .join(os_1.EOL);
+            throw new errors_1.TransferEngineValidationError(`Invalid schema changes detected during integrity checks (using the ${strategy} strategy). Please find a summary of the changes below:\n${formattedDiffs}`, {
+                check: 'schema.changes',
+                strategy,
+                diffs,
+            });
+        }
+    }
     shouldSkipStage(stage) {
         const { exclude, only } = this.options;
         // schemas must always be included
@@ -167,12 +361,12 @@ class TransferEngine {
         }
         // everything is included by default unless 'only' has been set
         let included = (0, fp_1.isEmpty)(only);
-        if (only?.length > 0) {
+        if (only && only.length > 0) {
             included = only.some((transferGroup) => {
                 return exports.TransferGroupPresets[transferGroup][stage];
             });
         }
-        if (exclude?.length > 0) {
+        if (exclude && exclude.length > 0) {
             if (included) {
                 included = !exclude.some((transferGroup) => {
                     return exports.TransferGroupPresets[transferGroup][stage];
@@ -181,20 +375,74 @@ class TransferEngine {
         }
         return !included;
     }
+    async #transferStage(options) {
+        const { stage, source, destination, transform, tracker } = options;
+        const updateEndTime = () => {
+            const stageData = this.progress.data[stage];
+            if (stageData) {
+                stageData.endTime = Date.now();
+            }
+        };
+        if (!source || !destination || this.shouldSkipStage(stage)) {
+            // Wait until source and destination are closed
+            const results = await Promise.allSettled([source, destination].map((stream) => {
+                // if stream is undefined or already closed, resolve immediately
+                if (!stream || stream.destroyed) {
+                    return Promise.resolve();
+                }
+                // Wait until the close event is produced and then destroy the stream and resolve
+                return new Promise((resolve, reject) => {
+                    stream.on('close', resolve).on('error', reject).destroy();
+                });
+            }));
+            results.forEach((state) => {
+                if (state.status === 'rejected') {
+                    this.reportWarning(state.reason, `transfer(${stage})`);
+                }
+            });
+            this.#emitStageUpdate('skip', stage);
+            return;
+        }
+        this.#emitStageUpdate('start', stage);
+        await new Promise((resolve, reject) => {
+            let stream = source;
+            if (transform) {
+                stream = stream.pipe(transform);
+            }
+            if (tracker) {
+                stream = stream.pipe(tracker);
+            }
+            this.#currentStream = stream
+                .pipe(destination)
+                .on('error', (e) => {
+                updateEndTime();
+                this.#emitStageUpdate('error', stage);
+                this.reportError(e, 'error');
+                destination.destroy(e);
+                reject(e);
+            })
+                .on('close', () => {
+                this.#currentStream = undefined;
+                updateEndTime();
+                resolve();
+            });
+        });
+        this.#emitStageUpdate('finish', stage);
+    }
     // Cause an ongoing transfer to abort gracefully
     async abortTransfer() {
         const err = new errors_1.TransferEngineError('fatal', 'Transfer aborted.');
-        if (!__classPrivateFieldGet(this, _TransferEngine_currentStream, "f")) {
+        if (!this.#currentStream) {
             throw err;
         }
-        __classPrivateFieldGet(this, _TransferEngine_currentStream, "f").destroy(err);
+        this.#currentStream.destroy(err);
     }
     async init() {
         // Resolve providers' resource and store
         // them in the engine's internal state
-        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_resolveProviderResource).call(this);
+        await this.#resolveProviderResource();
         // Update the destination provider's source metadata
-        const { source: sourceMetadata } = __classPrivateFieldGet(this, _TransferEngine_metadata, "f");
+        const { source: sourceMetadata } = this.#metadata;
         if (sourceMetadata) {
             this.destinationProvider.setMetadata?.('source', sourceMetadata);
         }
@@ -227,16 +475,38 @@ class TransferEngine {
             }
         });
     }
+    async #resolveProviderResource() {
+        const sourceMetadata = await this.sourceProvider.getMetadata();
+        const destinationMetadata = await this.destinationProvider.getMetadata();
+        if (sourceMetadata) {
+            this.#metadata.source = sourceMetadata;
+        }
+        if (destinationMetadata) {
+            this.#metadata.destination = destinationMetadata;
+        }
+    }
+    async #getSchemas() {
+        if (!this.#schema.source) {
+            this.#schema.source = (await this.sourceProvider.getSchemas?.());
+        }
+        if (!this.#schema.destination) {
+            this.#schema.destination = (await this.destinationProvider.getSchemas?.());
+        }
+        return {
+            sourceSchemas: this.#schema.source,
+            destinationSchemas: this.#schema.destination,
+        };
+    }
     async integrityCheck() {
         const sourceMetadata = await this.sourceProvider.getMetadata();
         const destinationMetadata = await this.destinationProvider.getMetadata();
         if (sourceMetadata && destinationMetadata) {
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_assertStrapiVersionIntegrity).call(this, sourceMetadata?.strapi?.version, destinationMetadata?.strapi?.version);
+            this.#assertStrapiVersionIntegrity(sourceMetadata?.strapi?.version, destinationMetadata?.strapi?.version);
         }
-        const { sourceSchemas, destinationSchemas } = await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_getSchemas).call(this);
+        const { sourceSchemas, destinationSchemas } = await this.#getSchemas();
         try {
             if (sourceSchemas && destinationSchemas) {
-                __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_assertSchemasMatching).call(this, sourceSchemas, destinationSchemas);
+                this.#assertSchemasMatching(sourceSchemas, destinationSchemas);
             }
         }
         catch (error) {
@@ -250,10 +520,10 @@ class TransferEngine {
                     destination: this.destinationProvider,
                 };
                 // if we don't have any handlers, throw the original error
-                if ((0, fp_1.isEmpty)(__classPrivateFieldGet(this, _TransferEngine_handlers, "f").schemaDiff)) {
+                if ((0, fp_1.isEmpty)(this.#handlers.schemaDiff)) {
                     throw error;
                 }
-                await utils.middleware.runMiddleware(context, __classPrivateFieldGet(this, _TransferEngine_handlers, "f").schemaDiff);
+                await utils.middleware.runMiddleware(context, this.#handlers.schemaDiff);
                 // if there are any remaining diffs that weren't ignored
                 const unresolvedDiffs = utils.json.diff(context.diffs, context.ignoredDiffs);
                 if (unresolvedDiffs.length) {
@@ -271,11 +541,11 @@ class TransferEngine {
         // reset data between transfers
         this.progress.data = {};
         try {
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'init');
+            this.#emitTransferUpdate('init');
             await this.bootstrap();
             await this.init();
             await this.integrityCheck();
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'start');
+            this.#emitTransferUpdate('start');
             await this.beforeTransfer();
             // Run the transfer stages
             await this.transferSchemas();
@@ -285,10 +555,10 @@ class TransferEngine {
             await this.transferConfiguration();
             // Gracefully close the providers
             await this.close();
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'finish');
+            this.#emitTransferUpdate('finish');
         }
         catch (e) {
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'error', { error: e });
+            this.#emitTransferUpdate('error', { error: e });
             const lastDiagnostic = (0, fp_1.last)(this.diagnostics.stack.items);
             // Do not report an error diagnostic if the last one reported the same error
             if (e instanceof Error &&
@@ -334,11 +604,11 @@ class TransferEngine {
         }
         const source = await this.sourceProvider.createSchemasReadStream?.();
         const destination = await this.destinationProvider.createSchemasWriteStream?.();
-        const transform = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_createStageTransformStream).call(this, stage);
-        const tracker = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_progressTracker).call(this, stage, {
+        const transform = this.#createStageTransformStream(stage);
+        const tracker = this.#progressTracker(stage, {
             key: (value) => value.modelType,
         });
-        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
+        await this.#transferStage({ stage, source, destination, transform, tracker });
     }
     async transferEntities() {
         const stage = 'entities';
@@ -348,11 +618,11 @@ class TransferEngine {
         const source = await this.sourceProvider.createEntitiesReadStream?.();
         const destination = await this.destinationProvider.createEntitiesWriteStream?.();
         const transform = (0, stream_chain_1.chain)([
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_createStageTransformStream).call(this, stage),
+            this.#createStageTransformStream(stage),
             new stream_1.Transform({
                 objectMode: true,
                 transform: async (entity, _encoding, callback) => {
-                    const { destinationSchemas: schemas } = await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_getSchemas).call(this);
+                    const { destinationSchemas: schemas } = await this.#getSchemas();
                     if (!schemas) {
                         return callback(null, entity);
                     }
@@ -372,8 +642,8 @@ class TransferEngine {
                 },
             }),
         ]);
-        const tracker = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_progressTracker).call(this, stage, { key: (value) => value.type });
-        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
+        const tracker = this.#progressTracker(stage, { key: (value) => value.type });
+        await this.#transferStage({ stage, source, destination, transform, tracker });
     }
     async transferLinks() {
         const stage = 'links';
@@ -383,11 +653,11 @@ class TransferEngine {
         const source = await this.sourceProvider.createLinksReadStream?.();
         const destination = await this.destinationProvider.createLinksWriteStream?.();
         const transform = (0, stream_chain_1.chain)([
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_createStageTransformStream).call(this, stage),
+            this.#createStageTransformStream(stage),
             new stream_1.Transform({
                 objectMode: true,
                 transform: async (link, _encoding, callback) => {
-                    const { destinationSchemas: schemas } = await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_getSchemas).call(this);
+                    const { destinationSchemas: schemas } = await this.#getSchemas();
                     if (!schemas) {
                         return callback(null, link);
                     }
@@ -401,8 +671,8 @@ class TransferEngine {
                 },
             }),
         ]);
-        const tracker = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_progressTracker).call(this, stage);
-        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
+        const tracker = this.#progressTracker(stage);
+        await this.#transferStage({ stage, source, destination, transform, tracker });
     }
     async transferAssets() {
         const stage = 'assets';
@@ -411,12 +681,12 @@ class TransferEngine {
         }
         const source = await this.sourceProvider.createAssetsReadStream?.();
         const destination = await this.destinationProvider.createAssetsWriteStream?.();
-        const transform = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_createStageTransformStream).call(this, stage);
-        const tracker = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_progressTracker).call(this, stage, {
+        const transform = this.#createStageTransformStream(stage);
+        const tracker = this.#progressTracker(stage, {
             size: (value) => value.stats.size,
             key: (value) => (0, path_1.extname)(value.filename) || 'No extension',
         });
-        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
+        await this.#transferStage({ stage, source, destination, transform, tracker });
     }
     async transferConfiguration() {
         const stage = 'configuration';
@@ -425,248 +695,11 @@ class TransferEngine {
         }
         const source = await this.sourceProvider.createConfigurationReadStream?.();
         const destination = await this.destinationProvider.createConfigurationWriteStream?.();
-        const transform = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_createStageTransformStream).call(this, stage);
-        const tracker = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_progressTracker).call(this, stage);
-        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
+        const transform = this.#createStageTransformStream(stage);
+        const tracker = this.#progressTracker(stage);
+        await this.#transferStage({ stage, source, destination, transform, tracker });
     }
 }
-_TransferEngine_metadata = new WeakMap(), _TransferEngine_schema = new WeakMap(), _TransferEngine_handlers = new WeakMap(), _TransferEngine_currentStream = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_createStageTransformStream = function _TransferEngine_createStageTransformStream(key, options = {}) {
-    const { includeGlobal = true } = options;
-    const { throttle } = this.options;
-    const { global: globalTransforms, [key]: stageTransforms } = this.options?.transforms ?? {};
-    let stream = new stream_1.PassThrough({ objectMode: true });
-    const applyTransforms = (transforms = []) => {
-        const chainTransforms = [];
-        for (const transform of transforms) {
-            if ('filter' in transform) {
-                chainTransforms.push(utils.stream.filter(transform.filter));
-            }
-            if ('map' in transform) {
-                chainTransforms.push(utils.stream.map(transform.map));
-            }
-        }
-        if (chainTransforms.length) {
-            stream = stream.pipe((0, stream_chain_1.chain)(chainTransforms));
-        }
-    };
-    if (includeGlobal) {
-        applyTransforms(globalTransforms);
-    }
-    if ((0, fp_1.isNumber)(throttle) && throttle > 0) {
-        stream = stream.pipe(new stream_1.PassThrough({
-            objectMode: true,
-            async transform(data, _encoding, callback) {
-                await new Promise((resolve) => {
-                    setTimeout(resolve, throttle);
-                });
-                callback(null, data);
-            },
-        }));
-    }
-    applyTransforms(stageTransforms);
-    return stream;
-}, _TransferEngine_updateTransferProgress = function _TransferEngine_updateTransferProgress(stage, data, aggregate) {
-    if (!this.progress.data[stage]) {
-        this.progress.data[stage] = { count: 0, bytes: 0, startTime: Date.now() };
-    }
-    const stageProgress = this.progress.data[stage];
-    if (!stageProgress) {
-        return;
-    }
-    const size = aggregate?.size?.(data) ?? JSON.stringify(data).length;
-    const key = aggregate?.key?.(data);
-    stageProgress.count += 1;
-    stageProgress.bytes += size;
-    // Handle aggregate updates if necessary
-    if (key) {
-        if (!stageProgress.aggregates) {
-            stageProgress.aggregates = {};
-        }
-        const { aggregates } = stageProgress;
-        if (!aggregates[key]) {
-            aggregates[key] = { count: 0, bytes: 0 };
-        }
-        aggregates[key].count += 1;
-        aggregates[key].bytes += size;
-    }
-}, _TransferEngine_progressTracker = function _TransferEngine_progressTracker(stage, aggregate) {
-    return new stream_1.PassThrough({
-        objectMode: true,
-        transform: (data, _encoding, callback) => {
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_updateTransferProgress).call(this, stage, data, aggregate);
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'progress', stage);
-            callback(null, data);
-        },
-    });
-}, _TransferEngine_emitTransferUpdate = function _TransferEngine_emitTransferUpdate(type, payload) {
-    this.progress.stream.emit(`transfer::${type}`, payload);
-}, _TransferEngine_emitStageUpdate = function _TransferEngine_emitStageUpdate(type, transferStage) {
-    this.progress.stream.emit(`stage::${type}`, {
-        data: this.progress.data,
-        stage: transferStage,
-    });
-}, _TransferEngine_assertStrapiVersionIntegrity = function _TransferEngine_assertStrapiVersionIntegrity(sourceVersion, destinationVersion) {
-    const strategy = this.options.versionStrategy || exports.DEFAULT_VERSION_STRATEGY;
-    const reject = () => {
-        throw new errors_1.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}`, {
-            check: 'strapi.version',
-            strategy,
-            versions: { source: sourceVersion, destination: destinationVersion },
-        });
-    };
-    if (!sourceVersion ||
-        !destinationVersion ||
-        strategy === 'ignore' ||
-        destinationVersion === sourceVersion) {
-        return;
-    }
-    let diff;
-    try {
-        diff = (0, semver_1.diff)(sourceVersion, destinationVersion);
-    }
-    catch {
-        reject();
-    }
-    if (!diff) {
-        return;
-    }
-    const validPatch = ['prelease', 'build'];
-    const validMinor = [...validPatch, 'patch', 'prepatch'];
-    const validMajor = [...validMinor, 'minor', 'preminor'];
-    if (strategy === 'patch' && validPatch.includes(diff)) {
-        return;
-    }
-    if (strategy === 'minor' && validMinor.includes(diff)) {
-        return;
-    }
-    if (strategy === 'major' && validMajor.includes(diff)) {
-        return;
-    }
-    reject();
-}, _TransferEngine_assertSchemasMatching = function _TransferEngine_assertSchemasMatching(sourceSchemas, destinationSchemas) {
-    const strategy = this.options.schemaStrategy || exports.DEFAULT_SCHEMA_STRATEGY;
-    if (strategy === 'ignore') {
-        return;
-    }
-    const keys = (0, fp_1.uniq)(Object.keys(sourceSchemas).concat(Object.keys(destinationSchemas)));
-    const diffs = {};
-    keys.forEach((key) => {
-        const sourceSchema = sourceSchemas[key];
-        const destinationSchema = destinationSchemas[key];
-        const schemaDiffs = (0, validation_1.compareSchemas)(sourceSchema, destinationSchema, strategy);
-        if (schemaDiffs.length) {
-            diffs[key] = schemaDiffs;
-        }
-    });
-    if (!(0, fp_1.isEmpty)(diffs)) {
-        const formattedDiffs = Object.entries(diffs)
-            .map(([uid, ctDiffs]) => {
-            let msg = `- ${uid}:${os_1.EOL}`;
-            msg += ctDiffs
-                .sort((a, b) => (a.kind > b.kind ? -1 : 1))
-                .map((diff) => {
-                const path = diff.path.join('.');
-                if (diff.kind === 'added') {
-                    return `${path} exists in destination schema but not in source schema and the data will not be transferred.`;
-                }
-                if (diff.kind === 'deleted') {
-                    return `${path} exists in source schema but not in destination schema and the data will not be transferred.`;
-                }
-                if (diff.kind === 'modified') {
-                    if (diff.types[0] === diff.types[1]) {
-                        return `Schema value changed at "${path}": "${diff.values[0]}" (${diff.types[0]}) => "${diff.values[1]}" (${diff.types[1]})`;
-                    }
-                    return `Schema has differing data types at "${path}": "${diff.values[0]}" (${diff.types[0]}) => "${diff.values[1]}" (${diff.types[1]})`;
-                }
-                throw new errors_1.TransferEngineValidationError(`Invalid diff found for "${uid}"`, {
-                    check: `schema on ${uid}`,
-                });
-            })
-                .map((line) => `  - ${line}`)
-                .join(os_1.EOL);
-            return msg;
-        })
-            .join(os_1.EOL);
-        throw new errors_1.TransferEngineValidationError(`Invalid schema changes detected during integrity checks (using the ${strategy} strategy). Please find a summary of the changes below:\n${formattedDiffs}`, {
-            check: 'schema.changes',
-            strategy,
-            diffs,
-        });
-    }
-}, _TransferEngine_transferStage = async function _TransferEngine_transferStage(options) {
-    const { stage, source, destination, transform, tracker } = options;
-    const updateEndTime = () => {
-        const stageData = this.progress.data[stage];
-        if (stageData) {
-            stageData.endTime = Date.now();
-        }
-    };
-    if (!source || !destination || this.shouldSkipStage(stage)) {
-        // Wait until source and destination are closed
-        const results = await Promise.allSettled([source, destination].map((stream) => {
-            // if stream is undefined or already closed, resolve immediately
-            if (!stream || stream.destroyed) {
-                return Promise.resolve();
-            }
-            // Wait until the close event is produced and then destroy the stream and resolve
-            return new Promise((resolve, reject) => {
-                stream.on('close', resolve).on('error', reject).destroy();
-            });
-        }));
-        results.forEach((state) => {
-            if (state.status === 'rejected') {
-                this.reportWarning(state.reason, `transfer(${stage})`);
-            }
-        });
-        __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'skip', stage);
-        return;
-    }
-    __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'start', stage);
-    await new Promise((resolve, reject) => {
-        let stream = source;
-        if (transform) {
-            stream = stream.pipe(transform);
-        }
-        if (tracker) {
-            stream = stream.pipe(tracker);
-        }
-        __classPrivateFieldSet(this, _TransferEngine_currentStream, stream
-            .pipe(destination)
-            .on('error', (e) => {
-            updateEndTime();
-            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'error', stage);
-            this.reportError(e, 'error');
-            destination.destroy(e);
-            reject(e);
-        })
-            .on('close', () => {
-            __classPrivateFieldSet(this, _TransferEngine_currentStream, undefined, "f");
-            updateEndTime();
-            resolve();
-        }), "f");
-    });
-    __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'finish', stage);
-}, _TransferEngine_resolveProviderResource = async function _TransferEngine_resolveProviderResource() {
-    const sourceMetadata = await this.sourceProvider.getMetadata();
-    const destinationMetadata = await this.destinationProvider.getMetadata();
-    if (sourceMetadata) {
-        __classPrivateFieldGet(this, _TransferEngine_metadata, "f").source = sourceMetadata;
-    }
-    if (destinationMetadata) {
-        __classPrivateFieldGet(this, _TransferEngine_metadata, "f").destination = destinationMetadata;
-    }
-}, _TransferEngine_getSchemas = async function _TransferEngine_getSchemas() {
-    if (!__classPrivateFieldGet(this, _TransferEngine_schema, "f").source) {
-        __classPrivateFieldGet(this, _TransferEngine_schema, "f").source = (await this.sourceProvider.getSchemas?.());
-    }
-    if (!__classPrivateFieldGet(this, _TransferEngine_schema, "f").destination) {
-        __classPrivateFieldGet(this, _TransferEngine_schema, "f").destination = (await this.destinationProvider.getSchemas?.());
-    }
-    return {
-        sourceSchemas: __classPrivateFieldGet(this, _TransferEngine_schema, "f").source,
-        destinationSchemas: __classPrivateFieldGet(this, _TransferEngine_schema, "f").destination,
-    };
-};
 const createTransferEngine = (sourceProvider, destinationProvider, options) => {
     return new TransferEngine(sourceProvider, destinationProvider, options);
 };