@strapi/data-transfer 4.6.0-alpha.0 → 4.6.0-beta.1

package/dist/encryption/decrypt.js

@@ -5,25 +5,25 @@ const crypto_1 = require("crypto");
 // different key values depending on algorithm chosen
 const getDecryptionStrategy = (algorithm) => {
     const strategies = {
-        'aes-128-ecb': (key) => {
+        'aes-128-ecb'(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 16);
             const initVector = null;
             const securityKey = hashedKey;
             return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
         },
-        aes128: (key) => {
+        aes128(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 32);
             const initVector = hashedKey.slice(16);
             const securityKey = hashedKey.slice(0, 16);
             return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
         },
-        aes192: (key) => {
+        aes192(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 40);
             const initVector = hashedKey.slice(24);
             const securityKey = hashedKey.slice(0, 24);
             return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
         },
-        aes256: (key) => {
+        aes256(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 48);
             const initVector = hashedKey.slice(32);
             const securityKey = hashedKey.slice(0, 32);

package/dist/encryption/encrypt.js

@@ -5,25 +5,25 @@ const crypto_1 = require("crypto");
 // different key values depending on algorithm chosen
 const getEncryptionStrategy = (algorithm) => {
     const strategies = {
-        'aes-128-ecb': (key) => {
+        'aes-128-ecb'(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 16);
             const initVector = null;
             const securityKey = hashedKey;
             return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
         },
-        aes128: (key) => {
+        aes128(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 32);
             const initVector = hashedKey.slice(16);
             const securityKey = hashedKey.slice(0, 16);
             return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
         },
-        aes192: (key) => {
+        aes192(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 40);
             const initVector = hashedKey.slice(24);
             const securityKey = hashedKey.slice(0, 24);
             return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
         },
-        aes256: (key) => {
+        aes256(key) {
             const hashedKey = (0, crypto_1.scryptSync)(key, '', 48);
             const initVector = hashedKey.slice(32);
             const securityKey = hashedKey.slice(0, 32);

package/dist/engine/index.d.ts

@@ -1,28 +1,29 @@
 /// <reference types="node" />
-import { PassThrough } from 'stream-chain';
-import type { IDestinationProvider, ISourceProvider, ITransferEngine, ITransferEngineOptions, ITransferResults } from '../../types';
-declare type TransferEngineProgress = {
-    data: any;
-    stream: PassThrough;
-};
-export declare const VALID_STRATEGIES: string[];
+import { PassThrough } from 'stream';
+import type { IDestinationProvider, ISourceProvider, ITransferEngine, ITransferEngineOptions, TransferProgress, ITransferResults, TransferStage } from '../../types';
+export declare const TRANSFER_STAGES: ReadonlyArray<TransferStage>;
+export declare const DEFAULT_VERSION_STRATEGY = "ignore";
+export declare const DEFAULT_SCHEMA_STRATEGY = "strict";
 declare class TransferEngine<S extends ISourceProvider = ISourceProvider, D extends IDestinationProvider = IDestinationProvider> implements ITransferEngine {
     #private;
     sourceProvider: ISourceProvider;
     destinationProvider: IDestinationProvider;
     options: ITransferEngineOptions;
-    get progress(): TransferEngineProgress;
+    progress: {
+        data: TransferProgress;
+        stream: PassThrough;
+    };
     constructor(sourceProvider: ISourceProvider, destinationProvider: IDestinationProvider, options: ITransferEngineOptions);
     init(): Promise<void>;
     bootstrap(): Promise<void>;
     close(): Promise<void>;
     integrityCheck(): Promise<boolean>;
-    validateTransferOptions(): void;
     transfer(): Promise<ITransferResults<S, D>>;
+    beforeTransfer(): Promise<void>;
     transferSchemas(): Promise<void>;
     transferEntities(): Promise<void>;
     transferLinks(): Promise<void>;
-    transferMedia(): Promise<void>;
+    transferAssets(): Promise<void>;
     transferConfiguration(): Promise<void>;
 }
 export declare const createTransferEngine: <S extends ISourceProvider = ISourceProvider, D extends IDestinationProvider = IDestinationProvider>(sourceProvider: S, destinationProvider: D, options: ITransferEngineOptions) => TransferEngine<S, D>;

package/dist/engine/index.js

@@ -7,37 +7,28 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _TransferEngine_instances, _TransferEngine_metadata, _TransferEngine_transferProgress, _TransferEngine_progressStream, _TransferEngine_increaseTransferProgress, _TransferEngine_countRecorder, _TransferEngine_updateStage, _TransferEngine_assertStrapiVersionIntegrity, _TransferEngine_assertSchemasMatching, _TransferEngine_resolveProviderResource;
+var _TransferEngine_instances, _TransferEngine_metadata, _TransferEngine_createStageTransformStream, _TransferEngine_updateTransferProgress, _TransferEngine_progressTracker, _TransferEngine_emitTransferUpdate, _TransferEngine_emitStageUpdate, _TransferEngine_assertStrapiVersionIntegrity, _TransferEngine_assertSchemasMatching, _TransferEngine_transferStage, _TransferEngine_resolveProviderResource;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTransferEngine = exports.VALID_STRATEGIES = void 0;
-const stream_chain_1 = require("stream-chain");
+exports.createTransferEngine = exports.DEFAULT_SCHEMA_STRATEGY = exports.DEFAULT_VERSION_STRATEGY = exports.TRANSFER_STAGES = void 0;
+const stream_1 = require("stream");
+const path_1 = require("path");
 const fp_1 = require("lodash/fp");
-const semverDiff = require('semver/functions/diff');
+const semver_1 = require("semver");
 const strategies_1 = __importDefault(require("../strategies"));
-exports.VALID_STRATEGIES = ['restore', 'merge'];
+const stream_2 = require("../utils/stream");
+exports.TRANSFER_STAGES = Object.freeze([
+    'entities',
+    'links',
+    'assets',
+    'schemas',
+    'configuration',
+]);
+exports.DEFAULT_VERSION_STRATEGY = 'ignore';
+exports.DEFAULT_SCHEMA_STRATEGY = 'strict';
 class TransferEngine {
     constructor(sourceProvider, destinationProvider, options) {
         _TransferEngine_instances.add(this);
         _TransferEngine_metadata.set(this, {});
-        _TransferEngine_transferProgress.set(this, {});
-        // TODO: Type the stream chunks. Doesn't seem trivial, especially since PassThrough doesn't provide a PassThroughOptions type
-        _TransferEngine_progressStream.set(this, new stream_chain_1.PassThrough({ objectMode: true }));
-        _TransferEngine_countRecorder.set(this, (transferStage, aggregateKey) => {
-            return new stream_chain_1.PassThrough({
-                objectMode: true,
-                transform: (data, _encoding, callback) => {
-                    __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_increaseTransferProgress).call(this, transferStage, data, aggregateKey);
-                    __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'progress', transferStage);
-                    callback(null, data);
-                },
-            });
-        });
-        _TransferEngine_updateStage.set(this, (type, transferStage) => {
-            __classPrivateFieldGet(this, _TransferEngine_progressStream, "f").emit(type, {
-                data: __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f"),
-                stage: transferStage,
-            });
-        });
         if (sourceProvider.type !== 'source') {
             throw new Error("SourceProvider does not have type 'source'");
         }
@@ -47,12 +38,7 @@ class TransferEngine {
         this.sourceProvider = sourceProvider;
         this.destinationProvider = destinationProvider;
         this.options = options;
-    }
-    get progress() {
-        return {
-            data: __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f"),
-            stream: __classPrivateFieldGet(this, _TransferEngine_progressStream, "f"),
-        };
+        this.progress = { data: {}, stream: new stream_1.PassThrough({ objectMode: true }) };
     }
     async init() {
         // Resolve providers' resource and store
@@ -77,8 +63,8 @@ class TransferEngine {
             if (sourceMetadata && destinationMetadata) {
                 __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_assertStrapiVersionIntegrity).call(this, sourceMetadata?.strapi?.version, destinationMetadata?.strapi?.version);
             }
-            const sourceSchemas = await this.sourceProvider.getSchemas?.();
-            const destinationSchemas = await this.destinationProvider.getSchemas?.();
+            const sourceSchemas = (await this.sourceProvider.getSchemas?.());
+            const destinationSchemas = (await this.destinationProvider.getSchemas?.());
             if (sourceSchemas && destinationSchemas) {
                 __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_assertSchemasMatching).call(this, sourceSchemas, destinationSchemas);
             }
@@ -88,30 +74,31 @@ class TransferEngine {
             return false;
         }
     }
-    validateTransferOptions() {
-        if (!exports.VALID_STRATEGIES.includes(this.options.strategy)) {
-            throw new Error('Invalid stategy ' + this.options.strategy);
-        }
-    }
     async transfer() {
+        // reset data between transfers
+        this.progress.data = {};
+        __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'start');
         try {
-            this.validateTransferOptions();
             await this.bootstrap();
             await this.init();
             const isValidTransfer = await this.integrityCheck();
             if (!isValidTransfer) {
+                // TODO: provide the log from the integrity check
                 throw new Error(`Unable to transfer the data between ${this.sourceProvider.name} and ${this.destinationProvider.name}.\nPlease refer to the log above for more information.`);
             }
+            await this.beforeTransfer();
             // Run the transfer stages
             await this.transferSchemas();
             await this.transferEntities();
-            await this.transferMedia();
+            await this.transferAssets();
             await this.transferLinks();
             await this.transferConfiguration();
             // Gracefully close the providers
             await this.close();
+            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'finish');
         }
         catch (e) {
+            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'error', { error: e });
             // Rollback the destination provider if an exception is thrown during the transfer
             // Note: This will be configurable in the future
             await this.destinationProvider.rollback?.(e);
@@ -120,147 +107,118 @@ class TransferEngine {
         return {
             source: this.sourceProvider.results,
             destination: this.destinationProvider.results,
+            engine: this.progress.data,
         };
     }
+    async beforeTransfer() {
+        await this.sourceProvider.beforeTransfer?.();
+        await this.destinationProvider.beforeTransfer?.();
+    }
     async transferSchemas() {
-        const stageName = 'schemas';
-        const inStream = await this.sourceProvider.streamSchemas?.();
-        if (!inStream) {
-            return;
-        }
-        const outStream = await this.destinationProvider.getSchemasStream?.();
-        if (!outStream) {
-            return;
-        }
-        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', stageName);
-        return new Promise((resolve, reject) => {
-            inStream
-                // Throw on error in the source
-                .on('error', reject);
-            outStream
-                // Throw on error in the destination
-                .on('error', reject)
-                // Resolve the promise when the destination has finished reading all the data from the source
-                .on('close', () => {
-                __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
-                resolve();
-            });
-            inStream.pipe(__classPrivateFieldGet(this, _TransferEngine_countRecorder, "f").call(this, stageName)).pipe(outStream);
-        });
+        const stage = 'schemas';
+        const source = await this.sourceProvider.streamSchemas?.();
+        const destination = await this.destinationProvider.getSchemasStream?.();
+        const transform = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_createStageTransformStream).call(this, stage);
+        const tracker = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_progressTracker).call(this, stage, { key: (value) => value.modelType });
+        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
     }
     async transferEntities() {
-        const stageName = 'entities';
-        const inStream = await this.sourceProvider.streamEntities?.();
-        if (!inStream) {
-            return;
-        }
-        const outStream = await this.destinationProvider.getEntitiesStream?.();
-        if (!outStream) {
-            return;
-        }
-        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', stageName);
-        return new Promise((resolve, reject) => {
-            inStream
-                // Throw on error in the source
-                .on('error', (e) => {
-                reject(e);
-            });
-            outStream
-                // Throw on error in the destination
-                .on('error', (e) => {
-                reject(e);
-            })
-                // Resolve the promise when the destination has finished reading all the data from the source
-                .on('close', () => {
-                __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
-                resolve();
-            });
-            inStream.pipe(__classPrivateFieldGet(this, _TransferEngine_countRecorder, "f").call(this, stageName, 'type')).pipe(outStream);
-        });
+        const stage = 'entities';
+        const source = await this.sourceProvider.streamEntities?.();
+        const destination = await this.destinationProvider.getEntitiesStream?.();
+        const transform = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_createStageTransformStream).call(this, stage);
+        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 });
     }
     async transferLinks() {
-        const stageName = 'links';
-        const inStream = await this.sourceProvider.streamLinks?.();
-        if (!inStream) {
-            return;
-        }
-        const outStream = await this.destinationProvider.getLinksStream?.();
-        if (!outStream) {
-            return;
-        }
-        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', 'links');
-        return new Promise((resolve, reject) => {
-            inStream
-                // Throw on error in the source
-                .on('error', reject);
-            outStream
-                // Throw on error in the destination
-                .on('error', reject)
-                // Resolve the promise when the destination has finished reading all the data from the source
-                .on('close', () => {
-                __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
-                resolve();
-            });
-            inStream.pipe(__classPrivateFieldGet(this, _TransferEngine_countRecorder, "f").call(this, stageName)).pipe(outStream);
-        });
+        const stage = 'links';
+        const source = await this.sourceProvider.streamLinks?.();
+        const destination = await this.destinationProvider.getLinksStream?.();
+        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 });
     }
-    async transferMedia() {
-        const stageName = 'media';
-        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', stageName);
-        console.warn('transferMedia not yet implemented');
-        return new Promise((resolve) => (() => {
-            __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
-            resolve();
-        })());
+    async transferAssets() {
+        const stage = 'assets';
+        const source = await this.sourceProvider.streamAssets?.();
+        const destination = await this.destinationProvider.getAssetsStream?.();
+        const transform = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_createStageTransformStream).call(this, stage);
+        const tracker = __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_progressTracker).call(this, stage, {
+            size: (value) => value.stats.size,
+            key: (value) => (0, path_1.extname)(value.filename),
+        });
+        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
     }
     async transferConfiguration() {
-        const stageName = 'configuration';
-        const inStream = await this.sourceProvider.streamConfiguration?.();
-        if (!inStream) {
-            return;
-        }
-        const outStream = await this.destinationProvider.getConfigurationStream?.();
-        if (!outStream) {
-            return;
-        }
-        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', stageName);
-        return new Promise((resolve, reject) => {
-            inStream
-                // Throw on error in the source
-                .on('error', reject);
-            outStream
-                // Throw on error in the destination
-                .on('error', reject)
-                // Resolve the promise when the destination has finished reading all the data from the source
-                .on('close', () => {
-                __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
-                resolve();
-            });
-            inStream.pipe(__classPrivateFieldGet(this, _TransferEngine_countRecorder, "f").call(this, stageName)).pipe(outStream);
-        });
+        const stage = 'configuration';
+        const source = await this.sourceProvider.streamConfiguration?.();
+        const destination = await this.destinationProvider.getConfigurationStream?.();
+        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 });
     }
 }
-_TransferEngine_metadata = new WeakMap(), _TransferEngine_transferProgress = new WeakMap(), _TransferEngine_progressStream = new WeakMap(), _TransferEngine_countRecorder = new WeakMap(), _TransferEngine_updateStage = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_increaseTransferProgress = function _TransferEngine_increaseTransferProgress(transferStage, data, aggregateKey) {
-    if (!__classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage]) {
-        __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage] = { count: 0, bytes: 0 };
+_TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_createStageTransformStream = function _TransferEngine_createStageTransformStream(key, options = {}) {
+    const { includeGlobal = true } = options;
+    const { global: globalTransforms, [key]: stageTransforms } = this.options?.transforms ?? {};
+    let stream = new stream_1.PassThrough({ objectMode: true });
+    const applyTransforms = (transforms = []) => {
+        for (const transform of transforms) {
+            if ('filter' in transform) {
+                stream = stream.pipe((0, stream_2.filter)(transform.filter));
+            }
+            if ('map' in transform) {
+                stream = stream.pipe((0, stream_2.map)(transform.map));
+            }
+        }
+    };
+    if (includeGlobal) {
+        applyTransforms(globalTransforms);
+    }
+    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 };
+    }
+    const stageProgress = this.progress.data[stage];
+    if (!stageProgress) {
+        return;
     }
-    __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].count += 1;
-    const size = JSON.stringify(data).length;
-    __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].bytes += size;
-    if (aggregateKey && data && data[aggregateKey]) {
-        const aggKeyValue = data[aggregateKey];
-        if (!__classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage]['aggregates']) {
-            __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates = {};
+    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 = {};
         }
-        if (!(__classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates &&
-            __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates[aggKeyValue])) {
-            __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates[aggKeyValue] = { count: 0, bytes: 0 };
+        const { aggregates } = stageProgress;
+        if (!aggregates[key]) {
+            aggregates[key] = { count: 0, bytes: 0 };
         }
-        __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates[aggKeyValue].count += 1;
-        __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates[aggKeyValue].bytes += size;
+        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.versionMatching;
+    const strategy = this.options.versionStrategy || exports.DEFAULT_VERSION_STRATEGY;
     if (!sourceVersion ||
         !destinationVersion ||
         strategy === 'ignore' ||
@@ -269,7 +227,7 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_transferProgress = new
     }
     let diff;
     try {
-        diff = semverDiff(sourceVersion, destinationVersion);
+        diff = (0, semver_1.diff)(sourceVersion, destinationVersion);
     }
     catch (e) {
         throw new Error(`Strapi versions doesn't match (${strategy} check): ${sourceVersion} does not match with ${destinationVersion}`);
@@ -291,7 +249,10 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_transferProgress = new
     }
     throw new Error(`Strapi versions doesn't match (${strategy} check): ${sourceVersion} does not match with ${destinationVersion}`);
 }, _TransferEngine_assertSchemasMatching = function _TransferEngine_assertSchemasMatching(sourceSchemas, destinationSchemas) {
-    const strategy = this.options.schemasMatching || 'strict';
+    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) => {
@@ -304,9 +265,27 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_transferProgress = new
     });
     if (!(0, fp_1.isEmpty)(diffs)) {
         throw new Error(`Import process failed because the project doesn't have a matching data structure 
-        ${JSON.stringify(diffs, null, 2)}        
+        ${JSON.stringify(diffs, null, 2)}
         `);
     }
+}, _TransferEngine_transferStage = async function _TransferEngine_transferStage(options) {
+    const { stage, source, destination, transform, tracker } = options;
+    if (!source || !destination) {
+        __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);
+        }
+        stream.pipe(destination).on('error', reject).on('close', resolve);
+    });
+    __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();

package/dist/providers/{local-file-destination-provider.d.ts → local-file-destination-provider/index.d.ts}

@@ -1,6 +1,8 @@
-/// <reference types="stream-chain" />
 /// <reference types="node" />
-import type { IDestinationProvider, IDestinationProviderTransferResults, IMetadata, ProviderType } from '../../types';
+/// <reference types="stream-chain" />
+import zlib from 'zlib';
+import { Writable } from 'stream';
+import type { IDestinationProvider, IDestinationProviderTransferResults, IMetadata, ProviderType } from '../../../types';
 export interface ILocalFileDestinationProviderOptions {
     encryption: {
         enabled: boolean;
@@ -29,13 +31,15 @@ declare class LocalFileDestinationProvider implements IDestinationProvider {
     results: ILocalFileDestinationProviderTransferResults;
     constructor(options: ILocalFileDestinationProviderOptions);
     setMetadata(target: ProviderType, metadata: IMetadata): IDestinationProvider;
+    createGzip(): zlib.Gzip;
     bootstrap(): void | Promise<void>;
     close(): Promise<void>;
     rollback(): Promise<void>;
     getMetadata(): null;
     getSchemasStream(): import("stream-chain");
-    getEntitiesStream(): NodeJS.WritableStream;
-    getLinksStream(): NodeJS.WritableStream;
-    getConfigurationStream(): NodeJS.WritableStream;
+    getEntitiesStream(): Writable;
+    getLinksStream(): Writable;
+    getConfigurationStream(): Writable;
+    getAssetsStream(): Writable;
 }
 export {};