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

package/lib/engine/diagnostic.d.ts

@@ -0,0 +1,40 @@
+export interface IDiagnosticReporterOptions {
+    stackSize?: number;
+}
+export declare type GenericDiagnostic<K extends DiagnosticKind, T = unknown> = {
+    kind: K;
+    details: {
+        message: string;
+        createdAt: Date;
+    } & T;
+};
+export declare type DiagnosticKind = 'error' | 'warning' | 'info';
+export declare type DiagnosticListener<T extends DiagnosticKind = DiagnosticKind> = (diagnostic: {
+    kind: T;
+} & Diagnostic extends infer U ? U : 'foo') => void | Promise<void>;
+export declare type DiagnosticEvent = 'diagnostic' | `diagnostic.${DiagnosticKind}`;
+export declare type GetEventListener<E extends DiagnosticEvent> = E extends 'diagnostic' ? DiagnosticListener : E extends `diagnostic.${infer K}` ? K extends DiagnosticKind ? DiagnosticListener<K> : never : never;
+export declare type Diagnostic = ErrorDiagnostic | WarningDiagnostic | InfoDiagnostic;
+export declare type ErrorDiagnosticSeverity = 'fatal' | 'error' | 'silly';
+export declare type ErrorDiagnostic = GenericDiagnostic<'error', {
+    name: string;
+    severity: ErrorDiagnosticSeverity;
+    error: Error;
+}>;
+export declare type WarningDiagnostic = GenericDiagnostic<'warning', {
+    origin?: string;
+}>;
+export declare type InfoDiagnostic<T = unknown> = GenericDiagnostic<'info', {
+    params?: T;
+}>;
+export interface IDiagnosticReporter {
+    stack: {
+        readonly size: number;
+        readonly items: Diagnostic[];
+    };
+    report(diagnostic: Diagnostic): IDiagnosticReporter;
+    onDiagnostic(listener: DiagnosticListener): IDiagnosticReporter;
+    on<T extends DiagnosticKind>(kind: T, listener: DiagnosticListener<T>): IDiagnosticReporter;
+}
+declare const createDiagnosticReporter: (options?: IDiagnosticReporterOptions) => IDiagnosticReporter;
+export { createDiagnosticReporter };

package/lib/engine/diagnostic.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiagnosticReporter = void 0;
+const events_1 = require("events");
+const createDiagnosticReporter = (options = {}) => {
+    const { stackSize = -1 } = options;
+    const emitter = new events_1.EventEmitter();
+    const stack = [];
+    const addListener = (event, listener) => {
+        emitter.on(event, listener);
+    };
+    const isDiagnosticValid = (diagnostic) => {
+        if (!diagnostic.kind || !diagnostic.details || !diagnostic.details.message) {
+            return false;
+        }
+        return true;
+    };
+    return {
+        stack: {
+            get size() {
+                return stack.length;
+            },
+            get items() {
+                return stack;
+            },
+        },
+        report(diagnostic) {
+            if (!isDiagnosticValid(diagnostic)) {
+                return this;
+            }
+            emitter.emit('diagnostic', diagnostic);
+            emitter.emit(`diagnostic.${diagnostic.kind}`, diagnostic);
+            if (stackSize !== -1 && stack.length >= stackSize) {
+                stack.shift();
+            }
+            stack.push(diagnostic);
+            return this;
+        },
+        onDiagnostic(listener) {
+            addListener('diagnostic', listener);
+            return this;
+        },
+        on(kind, listener) {
+            addListener(`diagnostic.${kind}`, listener);
+            return this;
+        },
+    };
+};
+exports.createDiagnosticReporter = createDiagnosticReporter;
+//# sourceMappingURL=diagnostic.js.map

package/lib/engine/errors.d.ts

@@ -0,0 +1,28 @@
+import { DataTransferError, Severity } from '../errors';
+declare type TransferEngineStep = 'initialization' | 'validation' | 'transfer';
+declare type TransferEngineErrorDetails<P extends TransferEngineStep = TransferEngineStep, U = never> = {
+    step: P;
+} & ([U] extends [never] ? unknown : {
+    details?: U;
+});
+declare class TransferEngineError<P extends TransferEngineStep = TransferEngineStep, U = never, T extends TransferEngineErrorDetails<P, U> = TransferEngineErrorDetails<P, U>> extends DataTransferError<T> {
+    constructor(severity: Severity, message?: string, details?: T | null);
+}
+declare class TransferEngineInitializationError extends TransferEngineError<'initialization'> {
+    constructor(message?: string);
+}
+declare class TransferEngineValidationError<T extends {
+    check: string;
+} = {
+    check: string;
+}> extends TransferEngineError<'validation', T> {
+    constructor(message?: string, details?: T);
+}
+declare class TransferEngineTransferError<T extends {
+    check: string;
+} = {
+    check: string;
+}> extends TransferEngineError<'transfer', T> {
+    constructor(message?: string, details?: T);
+}
+export { TransferEngineError, TransferEngineInitializationError, TransferEngineValidationError, TransferEngineTransferError, };

package/lib/engine/errors.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransferEngineTransferError = exports.TransferEngineValidationError = exports.TransferEngineInitializationError = exports.TransferEngineError = void 0;
+const errors_1 = require("../errors");
+class TransferEngineError extends errors_1.DataTransferError {
+    constructor(severity, message, details) {
+        super('engine', severity, message, details);
+    }
+}
+exports.TransferEngineError = TransferEngineError;
+class TransferEngineInitializationError extends TransferEngineError {
+    constructor(message) {
+        super(errors_1.SeverityKind.FATAL, message, { step: 'initialization' });
+    }
+}
+exports.TransferEngineInitializationError = TransferEngineInitializationError;
+class TransferEngineValidationError extends TransferEngineError {
+    constructor(message, details) {
+        super(errors_1.SeverityKind.FATAL, message, { step: 'validation', details });
+    }
+}
+exports.TransferEngineValidationError = TransferEngineValidationError;
+class TransferEngineTransferError extends TransferEngineError {
+    constructor(message, details) {
+        super(errors_1.SeverityKind.FATAL, message, { step: 'transfer', details });
+    }
+}
+exports.TransferEngineTransferError = TransferEngineTransferError;
+//# sourceMappingURL=errors.js.map

package/{dist → lib}/engine/index.d.ts

@@ -1,7 +1,13 @@
 /// <reference types="node" />
 import { PassThrough } from 'stream';
-import type { IDestinationProvider, ISourceProvider, ITransferEngine, ITransferEngineOptions, TransferProgress, ITransferResults, TransferStage } from '../../types';
+import type { IDestinationProvider, ISourceProvider, ITransferEngine, ITransferEngineOptions, TransferProgress, ITransferResults, TransferStage, TransferFilters, TransferFilterPreset } from '../../types';
+import { IDiagnosticReporter } from './diagnostic';
 export declare const TRANSFER_STAGES: ReadonlyArray<TransferStage>;
+export declare type TransferGroupFilter = Record<TransferFilterPreset, TransferFilters>;
+/**
+ * Preset filters for only/exclude options
+ * */
+export declare const TransferGroupPresets: TransferGroupFilter;
 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 {
@@ -13,11 +19,19 @@ declare class TransferEngine<S extends ISourceProvider = ISourceProvider, D exte
         data: TransferProgress;
         stream: PassThrough;
     };
-    constructor(sourceProvider: ISourceProvider, destinationProvider: IDestinationProvider, options: ITransferEngineOptions);
+    diagnostics: IDiagnosticReporter;
+    constructor(sourceProvider: S, destinationProvider: D, options: ITransferEngineOptions);
+    shouldSkipStage(stage: TransferStage): boolean;
     init(): Promise<void>;
+    /**
+     * Run the bootstrap method in both source and destination providers
+     */
     bootstrap(): Promise<void>;
+    /**
+     * Run the close method in both source and destination providers
+     */
     close(): Promise<void>;
-    integrityCheck(): Promise<boolean>;
+    integrityCheck(): Promise<void>;
     transfer(): Promise<ITransferResults<S, D>>;
     beforeTransfer(): Promise<void>;
     transferSchemas(): Promise<void>;
@@ -26,5 +40,5 @@ declare class TransferEngine<S extends ISourceProvider = ISourceProvider, D exte
     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>;
+export declare const createTransferEngine: <S extends ISourceProvider, D extends IDestinationProvider>(sourceProvider: S, destinationProvider: D, options: ITransferEngineOptions) => TransferEngine<S, D>;
 export {};

package/{dist → lib}/engine/index.js

@@ -4,18 +4,18 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _TransferEngine_instances, _TransferEngine_metadata, _TransferEngine_createStageTransformStream, _TransferEngine_updateTransferProgress, _TransferEngine_progressTracker, _TransferEngine_emitTransferUpdate, _TransferEngine_emitStageUpdate, _TransferEngine_assertStrapiVersionIntegrity, _TransferEngine_assertSchemasMatching, _TransferEngine_transferStage, _TransferEngine_resolveProviderResource;
+var _TransferEngine_instances, _TransferEngine_metadata, _TransferEngine_panic, _TransferEngine_reportError, _TransferEngine_reportWarning, _TransferEngine_reportInfo, _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.DEFAULT_SCHEMA_STRATEGY = exports.DEFAULT_VERSION_STRATEGY = exports.TRANSFER_STAGES = void 0;
+exports.createTransferEngine = exports.DEFAULT_SCHEMA_STRATEGY = exports.DEFAULT_VERSION_STRATEGY = exports.TransferGroupPresets = exports.TRANSFER_STAGES = void 0;
 const stream_1 = require("stream");
 const path_1 = require("path");
+const os_1 = require("os");
 const fp_1 = require("lodash/fp");
 const semver_1 = require("semver");
-const strategies_1 = __importDefault(require("../strategies"));
+const validation_1 = require("./validation");
 const stream_2 = require("../utils/stream");
+const errors_1 = require("./errors");
+const diagnostic_1 = require("./diagnostic");
 exports.TRANSFER_STAGES = Object.freeze([
     'entities',
     'links',
@@ -23,23 +23,67 @@ exports.TRANSFER_STAGES = Object.freeze([
     'schemas',
     'configuration',
 ]);
+/**
+ * Preset filters for only/exclude options
+ * */
+exports.TransferGroupPresets = {
+    content: {
+        links: true,
+        entities: true,
+        // TODO: If we need to implement filtering on a running stage, it would be done like this, but we still need to implement it
+        // [
+        //   // Example: content processes the entities stage, but filters individual entities
+        //   {
+        //     filter(data) {
+        //       return shouldIncludeThisData(data);
+        //     },
+        //   },
+        // ],
+    },
+    files: {
+        assets: true,
+        links: true,
+    },
+    config: {
+        configuration: true,
+    },
+};
 exports.DEFAULT_VERSION_STRATEGY = 'ignore';
 exports.DEFAULT_SCHEMA_STRATEGY = 'strict';
 class TransferEngine {
     constructor(sourceProvider, destinationProvider, options) {
         _TransferEngine_instances.add(this);
         _TransferEngine_metadata.set(this, {});
-        if (sourceProvider.type !== 'source') {
-            throw new Error("SourceProvider does not have type 'source'");
-        }
-        if (destinationProvider.type !== 'destination') {
-            throw new Error("DestinationProvider does not have type 'destination'");
-        }
+        this.diagnostics = (0, diagnostic_1.createDiagnosticReporter)();
+        (0, validation_1.validateProvider)('source', sourceProvider);
+        (0, validation_1.validateProvider)('destination', destinationProvider);
         this.sourceProvider = sourceProvider;
         this.destinationProvider = destinationProvider;
         this.options = options;
         this.progress = { data: {}, stream: new stream_1.PassThrough({ objectMode: true }) };
     }
+    shouldSkipStage(stage) {
+        const { exclude, only } = this.options;
+        // schemas must always be included
+        if (stage === 'schemas') {
+            return false;
+        }
+        // everything is included by default unless 'only' has been set
+        let included = (0, fp_1.isEmpty)(only);
+        if (only?.length > 0) {
+            included = only.some((transferGroup) => {
+                return exports.TransferGroupPresets[transferGroup][stage];
+            });
+        }
+        if (exclude?.length > 0) {
+            if (included) {
+                included = !exclude.some((transferGroup) => {
+                    return exports.TransferGroupPresets[transferGroup][stage];
+                });
+            }
+        }
+        return !included;
+    }
     async init() {
         // Resolve providers' resource and store
         // them in the engine's internal state
@@ -50,11 +94,33 @@ class TransferEngine {
             this.destinationProvider.setMetadata?.('source', sourceMetadata);
         }
     }
+    /**
+     * Run the bootstrap method in both source and destination providers
+     */
     async bootstrap() {
-        await Promise.all([this.sourceProvider.bootstrap?.(), this.destinationProvider.bootstrap?.()]);
+        const results = await Promise.allSettled([
+            this.sourceProvider.bootstrap?.(),
+            this.destinationProvider.bootstrap?.(),
+        ]);
+        results.forEach((result) => {
+            if (result.status === 'rejected') {
+                __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_panic).call(this, result.reason);
+            }
+        });
     }
+    /**
+     * Run the close method in both source and destination providers
+     */
     async close() {
-        await Promise.all([this.sourceProvider.close?.(), this.destinationProvider.close?.()]);
+        const results = await Promise.allSettled([
+            this.sourceProvider.close?.(),
+            this.destinationProvider.close?.(),
+        ]);
+        results.forEach((result) => {
+            if (result.status === 'rejected') {
+                __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_panic).call(this, result.reason);
+            }
+        });
     }
     async integrityCheck() {
         try {
@@ -68,24 +134,23 @@ class TransferEngine {
             if (sourceSchemas && destinationSchemas) {
                 __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_assertSchemasMatching).call(this, sourceSchemas, destinationSchemas);
             }
-            return true;
         }
         catch (error) {
-            return false;
+            if (error instanceof Error) {
+                __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_panic).call(this, error);
+            }
+            throw error;
         }
     }
     async transfer() {
         // reset data between transfers
         this.progress.data = {};
-        __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'start');
         try {
+            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'init');
             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.integrityCheck();
+            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, 'start');
             await this.beforeTransfer();
             // Run the transfer stages
             await this.transferSchemas();
@@ -99,6 +164,12 @@ class TransferEngine {
         }
         catch (e) {
             __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitTransferUpdate).call(this, '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 &&
+                (!lastDiagnostic || lastDiagnostic.kind !== 'error' || lastDiagnostic.details.error !== e)) {
+                __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_reportError).call(this, e, e.severity || 'fatal');
+            }
             // 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);
@@ -111,54 +182,92 @@ class TransferEngine {
         };
     }
     async beforeTransfer() {
-        await this.sourceProvider.beforeTransfer?.();
-        await this.destinationProvider.beforeTransfer?.();
+        const runWithDiagnostic = async (provider) => {
+            try {
+                await provider.beforeTransfer?.();
+            }
+            catch (error) {
+                // Error happening during the before transfer step should be considered fatal errors
+                if (error instanceof Error) {
+                    __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_panic).call(this, error);
+                }
+                else {
+                    __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_panic).call(this, new Error(`Unknwon error when executing "beforeTransfer" on the ${origin} provider`));
+                }
+            }
+        };
+        await runWithDiagnostic(this.sourceProvider);
+        await runWithDiagnostic(this.destinationProvider);
     }
     async transferSchemas() {
         const stage = 'schemas';
-        const source = await this.sourceProvider.streamSchemas?.();
-        const destination = await this.destinationProvider.getSchemasStream?.();
+        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, { key: (value) => value.modelType });
         await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
     }
     async transferEntities() {
         const stage = 'entities';
-        const source = await this.sourceProvider.streamEntities?.();
-        const destination = await this.destinationProvider.getEntitiesStream?.();
+        const source = await this.sourceProvider.createEntitiesReadStream?.();
+        const destination = await this.destinationProvider.createEntitiesWriteStream?.();
         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 stage = 'links';
-        const source = await this.sourceProvider.streamLinks?.();
-        const destination = await this.destinationProvider.getLinksStream?.();
+        const source = await this.sourceProvider.createLinksReadStream?.();
+        const destination = await this.destinationProvider.createLinksWriteStream?.();
         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 transferAssets() {
         const stage = 'assets';
-        const source = await this.sourceProvider.streamAssets?.();
-        const destination = await this.destinationProvider.getAssetsStream?.();
+        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, {
             size: (value) => value.stats.size,
-            key: (value) => (0, path_1.extname)(value.filename),
+            key: (value) => (0, path_1.extname)(value.filename) ?? 'NA',
         });
         await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
     }
     async transferConfiguration() {
         const stage = 'configuration';
-        const source = await this.sourceProvider.streamConfiguration?.();
-        const destination = await this.destinationProvider.getConfigurationStream?.();
+        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 });
     }
 }
-_TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_createStageTransformStream = function _TransferEngine_createStageTransformStream(key, options = {}) {
+_TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_panic = function _TransferEngine_panic(error) {
+    __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_reportError).call(this, error, 'fatal');
+    throw error;
+}, _TransferEngine_reportError = function _TransferEngine_reportError(error, severity) {
+    this.diagnostics.report({
+        kind: 'error',
+        details: {
+            severity,
+            createdAt: new Date(),
+            name: error.name,
+            message: error.message,
+            error,
+        },
+    });
+}, _TransferEngine_reportWarning = function _TransferEngine_reportWarning(message, origin) {
+    this.diagnostics.report({
+        kind: 'warning',
+        details: { createdAt: new Date(), message, origin },
+    });
+}, _TransferEngine_reportInfo = function _TransferEngine_reportInfo(message, params) {
+    this.diagnostics.report({
+        kind: 'info',
+        details: { createdAt: new Date(), message, params },
+    });
+}, _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 });
@@ -219,6 +328,13 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     });
 }, _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' ||
@@ -229,8 +345,8 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     try {
         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}`);
+    catch {
+        reject();
     }
     if (!diff) {
         return;
@@ -247,7 +363,7 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     if (strategy === 'major' && validMajor.includes(diff)) {
         return;
     }
-    throw new Error(`Strapi versions doesn't match (${strategy} check): ${sourceVersion} does not match with ${destinationVersion}`);
+    reject();
 }, _TransferEngine_assertSchemasMatching = function _TransferEngine_assertSchemasMatching(sourceSchemas, destinationSchemas) {
     const strategy = this.options.schemaStrategy || exports.DEFAULT_SCHEMA_STRATEGY;
     if (strategy === 'ignore') {
@@ -258,19 +374,62 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     keys.forEach((key) => {
         const sourceSchema = sourceSchemas[key];
         const destinationSchema = destinationSchemas[key];
-        const schemaDiffs = (0, strategies_1.default)(sourceSchema, destinationSchema, strategy);
+        const schemaDiffs = (0, validation_1.compareSchemas)(destinationSchema, sourceSchema, strategy);
         if (schemaDiffs.length) {
             diffs[key] = schemaDiffs;
         }
     });
     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)}
-        `);
+        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 `Added "${path}": "${diff.value}" (${diff.type})`;
+                }
+                if (diff.kind === 'deleted') {
+                    return `Removed "${path}"`;
+                }
+                if (diff.kind === 'modified') {
+                    return `Modified "${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;
-    if (!source || !destination) {
+    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') {
+                __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_reportWarning).call(this, state.reason, `transfer(${stage})`);
+            }
+        });
         __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'skip', stage);
         return;
     }
@@ -283,7 +442,14 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
         if (tracker) {
             stream = stream.pipe(tracker);
         }
-        stream.pipe(destination).on('error', reject).on('close', resolve);
+        stream
+            .pipe(destination)
+            .on('error', (e) => {
+            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_reportError).call(this, e, 'error');
+            destination.destroy(e);
+            reject(e);
+        })
+            .on('close', resolve);
     });
     __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'finish', stage);
 }, _TransferEngine_resolveProviderResource = async function _TransferEngine_resolveProviderResource() {

package/lib/engine/validation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schemas';
+export * from './provider';

package/{dist → lib/engine/validation}/index.js

@@ -14,6 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./engine"), exports);
-__exportStar(require("./providers"), exports);
+__exportStar(require("./schemas"), exports);
+__exportStar(require("./provider"), exports);
 //# sourceMappingURL=index.js.map

package/lib/engine/validation/provider.d.ts

@@ -0,0 +1,3 @@
+import type { IDestinationProvider, ISourceProvider, ProviderType } from '../../../types';
+declare const validateProvider: <T extends ProviderType>(type: ProviderType, provider?: ([T] extends ["source"] ? ISourceProvider : IDestinationProvider) | null | undefined) => undefined;
+export { validateProvider };

package/lib/engine/validation/provider.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProvider = void 0;
+const fp_1 = require("lodash/fp");
+const errors_1 = require("../errors");
+const reject = (reason) => {
+    throw new errors_1.TransferEngineValidationError(`Invalid provider supplied. ${reason}`);
+};
+const validateProvider = (type, provider) => {
+    if (!provider) {
+        return reject(`Expected an instance of "${(0, fp_1.capitalize)(type)}Provider", but got "${typeof provider}" instead.`);
+    }
+    if (provider.type !== type) {
+        return reject(`Expected the provider to be of type "${type}" but got "${provider.type}" instead.`);
+    }
+};
+exports.validateProvider = validateProvider;
+//# sourceMappingURL=provider.js.map

package/{dist/strategies → lib/engine/validation/schemas}/index.d.ts

@@ -1,7 +1,7 @@
-import type { Diff } from '../utils/json';
+import type { Diff } from '../../../utils/json';
 declare const strategies: {
     exact(diffs: Diff[]): Diff[];
     strict(diffs: Diff[]): Diff[];
 };
 declare const compareSchemas: <T, P>(a: T, b: P, strategy: keyof typeof strategies) => Diff[];
-export default compareSchemas;
+export { compareSchemas };