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

package/lib/engine/index.d.ts

@@ -22,6 +22,7 @@ declare class TransferEngine<S extends ISourceProvider = ISourceProvider, D exte
     diagnostics: IDiagnosticReporter;
     constructor(sourceProvider: S, destinationProvider: D, options: ITransferEngineOptions);
     shouldSkipStage(stage: TransferStage): boolean;
+    abortTransfer(): Promise<void>;
     init(): Promise<void>;
     /**
      * Run the bootstrap method in both source and destination providers
@@ -41,4 +42,4 @@ declare class TransferEngine<S extends ISourceProvider = ISourceProvider, D exte
     transferConfiguration(): Promise<void>;
 }
 export declare const createTransferEngine: <S extends ISourceProvider, D extends IDestinationProvider>(sourceProvider: S, destinationProvider: D, options: ITransferEngineOptions) => TransferEngine<S, D>;
-export {};
+export * as errors from './errors';

package/lib/engine/index.js

@@ -1,12 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 _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;
+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_currentStream, _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.TransferGroupPresets = exports.TRANSFER_STAGES = void 0;
+exports.errors = 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");
@@ -54,6 +83,8 @@ class TransferEngine {
     constructor(sourceProvider, destinationProvider, options) {
         _TransferEngine_instances.add(this);
         _TransferEngine_metadata.set(this, {});
+        // 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);
@@ -84,6 +115,10 @@ class TransferEngine {
         }
         return !included;
     }
+    // Cause an ongoing transfer to abort gracefully
+    async abortTransfer() {
+        __classPrivateFieldGet(this, _TransferEngine_currentStream, "f")?.destroy(new errors_1.TransferEngineError('fatal', 'Transfer aborted.'));
+    }
     async init() {
         // Resolve providers' resource and store
         // them in the engine's internal state
@@ -230,7 +265,7 @@ class TransferEngine {
         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) ?? 'NA',
+            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 });
     }
@@ -243,7 +278,7 @@ class TransferEngine {
         await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_transferStage).call(this, { stage, source, destination, transform, tracker });
     }
 }
-_TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_panic = function _TransferEngine_panic(error) {
+_TransferEngine_metadata = new WeakMap(), _TransferEngine_currentStream = 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) {
@@ -269,6 +304,7 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     });
 }, _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 = []) => {
@@ -284,11 +320,22 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     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 };
+        this.progress.data[stage] = { count: 0, bytes: 0, startTime: Date.now() };
     }
     const stageProgress = this.progress.data[stage];
     if (!stageProgress) {
@@ -416,6 +463,12 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     }
 }, _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) => {
@@ -445,14 +498,20 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
         if (tracker) {
             stream = stream.pipe(tracker);
         }
-        stream
+        __classPrivateFieldSet(this, _TransferEngine_currentStream, stream
             .pipe(destination)
             .on('error', (e) => {
+            updateEndTime();
+            __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'error', stage);
             __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_reportError).call(this, e, 'error');
             destination.destroy(e);
             reject(e);
         })
-            .on('close', resolve);
+            .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() {
@@ -469,4 +528,5 @@ const createTransferEngine = (sourceProvider, destinationProvider, options) => {
     return new TransferEngine(sourceProvider, destinationProvider, options);
 };
 exports.createTransferEngine = createTransferEngine;
+exports.errors = __importStar(require("./errors"));
 //# sourceMappingURL=index.js.map

package/lib/errors/constants.d.ts

@@ -1,3 +1,3 @@
 import { ErrorDiagnosticSeverity } from '../engine/diagnostic';
 export declare const SeverityKind: Record<string, ErrorDiagnosticSeverity>;
-export declare type Severity = typeof SeverityKind[keyof typeof SeverityKind];
+export declare type Severity = (typeof SeverityKind)[keyof typeof SeverityKind];

package/lib/file/providers/destination/index.js

@@ -19,6 +19,7 @@ const stream_chain_1 = require("stream-chain");
 const stream_1 = require("stream");
 const encryption_1 = require("../../../utils/encryption");
 const utils_1 = require("./utils");
+const providers_1 = require("../../../errors/providers");
 const createLocalFileDestinationProvider = (options) => {
     return new LocalFileDestinationProvider(options);
 };
@@ -47,6 +48,12 @@ class LocalFileDestinationProvider {
         }
         __classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream = tar_stream_1.default.pack();
         const outStream = (0, fs_extra_1.createWriteStream)(__classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "a", _LocalFileDestinationProvider_archivePath_get));
+        outStream.on('error', (err) => {
+            if (err.code === 'ENOSPC') {
+                throw new providers_1.ProviderTransferError("Your server doesn't have space to proceed with the import.");
+            }
+            throw err;
+        });
         const archiveTransforms = [];
         if (compression.enabled) {
             archiveTransforms.push(this.createGzip());

package/lib/strapi/index.d.ts

@@ -1,4 +1,3 @@
 export * as providers from './providers';
 export * as queries from './queries';
 export * as remote from './remote';
-export { default as register } from './register';

package/lib/strapi/index.js

@@ -22,14 +22,9 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.register = exports.remote = exports.queries = exports.providers = void 0;
+exports.remote = exports.queries = exports.providers = void 0;
 exports.providers = __importStar(require("./providers"));
 exports.queries = __importStar(require("./queries"));
 exports.remote = __importStar(require("./remote"));
-var register_1 = require("./register");
-Object.defineProperty(exports, "register", { enumerable: true, get: function () { return __importDefault(register_1).default; } });
 //# sourceMappingURL=index.js.map

package/lib/strapi/providers/index.d.ts

@@ -1,3 +1,4 @@
 export * from './local-destination';
 export * from './local-source';
 export * from './remote-destination';
+export * from './remote-source';

package/lib/strapi/providers/index.js

@@ -19,4 +19,5 @@ __exportStar(require("./local-destination"), exports);
 __exportStar(require("./local-source"), exports);
 // Remote
 __exportStar(require("./remote-destination"), exports);
+__exportStar(require("./remote-source"), exports);
 //# sourceMappingURL=index.js.map

package/lib/strapi/providers/local-destination/index.d.ts

@@ -21,7 +21,7 @@ declare class LocalStrapiDestinationProvider implements IDestinationProvider {
     constructor(options: ILocalStrapiDestinationProviderOptions);
     bootstrap(): Promise<void>;
     close(): Promise<void>;
-    rollback(): void;
+    rollback(): Promise<void>;
     beforeTransfer(): Promise<void>;
     getMetadata(): IMetadata;
     getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;

package/lib/strapi/providers/local-destination/index.js

@@ -73,8 +73,8 @@ class LocalStrapiDestinationProvider {
             await this.strapi?.destroy();
         }
     }
-    rollback() {
-        this.transaction?.rollback();
+    async rollback() {
+        await this.transaction?.rollback();
     }
     async beforeTransfer() {
         if (!this.strapi) {
@@ -151,12 +151,17 @@ class LocalStrapiDestinationProvider {
                 const writableStream = fse.createWriteStream(entryPath);
                 chunk.stream
                     .pipe(writableStream)
-                    .on('close', callback)
+                    .on('close', () => {
+                    callback(null);
+                })
                     .on('error', async (error) => {
+                    const errorMessage = error.code === 'ENOSPC'
+                        ? " Your server doesn't have space to proceed with the import. "
+                        : ' ';
                     try {
                         await fse.rm(assetsDirectory, { recursive: true, force: true });
                         await fse.move(backupDirectory, assetsDirectory);
-                        this.destroy(new providers_1.ProviderTransferError(`There was an error during the transfer process. The original files have been restored to ${assetsDirectory}`));
+                        this.destroy(new providers_1.ProviderTransferError(`There was an error during the transfer process.${errorMessage}The original files have been restored to ${assetsDirectory}`));
                     }
                     catch (err) {
                         throw new providers_1.ProviderTransferError(`There was an error doing the rollback process. The original files are in ${backupDirectory}, but we failed to restore them to ${assetsDirectory}`);

package/lib/strapi/providers/remote-destination/index.d.ts

@@ -1,21 +1,16 @@
 /// <reference types="node" />
 import { WebSocket } from 'ws';
 import { Writable } from 'stream';
-import { createDispatcher } from './utils';
+import { createDispatcher } from '../utils';
 import type { IDestinationProvider, IMetadata, ProviderType } from '../../../../types';
 import type { ILocalStrapiDestinationProviderOptions } from '../local-destination';
-interface ITokenAuth {
+interface ITransferTokenAuth {
     type: 'token';
     token: string;
 }
-interface ICredentialsAuth {
-    type: 'credentials';
-    email: string;
-    password: string;
-}
 export interface IRemoteStrapiDestinationProviderOptions extends Pick<ILocalStrapiDestinationProviderOptions, 'restore' | 'strategy'> {
     url: URL;
-    auth?: ITokenAuth | ICredentialsAuth;
+    auth?: ITransferTokenAuth;
 }
 declare class RemoteStrapiDestinationProvider implements IDestinationProvider {
     #private;
@@ -24,12 +19,14 @@ declare class RemoteStrapiDestinationProvider implements IDestinationProvider {
     options: IRemoteStrapiDestinationProviderOptions;
     ws: WebSocket | null;
     dispatcher: ReturnType<typeof createDispatcher> | null;
+    transferID: string | null;
     constructor(options: IRemoteStrapiDestinationProviderOptions);
     initTransfer(): Promise<string>;
     bootstrap(): Promise<void>;
     close(): Promise<void>;
     getMetadata(): Promise<IMetadata | null> | null;
     beforeTransfer(): Promise<void>;
+    rollback(): Promise<void>;
     getSchemas(): Promise<Strapi.Schemas | null>;
     createEntitiesWriteStream(): Writable;
     createLinksWriteStream(): Writable;

package/lib/strapi/providers/remote-destination/index.js

@@ -4,15 +4,17 @@ 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 _RemoteStrapiDestinationProvider_instances, _RemoteStrapiDestinationProvider_streamStep;
+var _RemoteStrapiDestinationProvider_instances, _RemoteStrapiDestinationProvider_startStepOnce, _RemoteStrapiDestinationProvider_startStep, _RemoteStrapiDestinationProvider_endStep, _RemoteStrapiDestinationProvider_streamStep, _RemoteStrapiDestinationProvider_writeStream;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRemoteStrapiDestinationProvider = void 0;
 const ws_1 = require("ws");
 const uuid_1 = require("uuid");
 const stream_1 = require("stream");
-const utils_1 = require("./utils");
+const fp_1 = require("lodash/fp");
+const utils_1 = require("../utils");
 const constants_1 = require("../../remote/constants");
 const providers_1 = require("../../../errors/providers");
+const jsonLength = (obj) => Buffer.byteLength(JSON.stringify(obj));
 class RemoteStrapiDestinationProvider {
     constructor(options) {
         _RemoteStrapiDestinationProvider_instances.add(this);
@@ -21,6 +23,7 @@ class RemoteStrapiDestinationProvider {
         this.options = options;
         this.ws = null;
         this.dispatcher = null;
+        this.transferID = null;
     }
     async initTransfer() {
         const { strategy, restore } = this.options;
@@ -28,17 +31,24 @@ class RemoteStrapiDestinationProvider {
         return new Promise((resolve, reject) => {
             this.ws
                 ?.once('open', async () => {
-                const query = this.dispatcher?.dispatchCommand({
-                    command: 'init',
-                    params: { options: { strategy, restore }, transfer: 'push' },
-                });
-                const res = (await query);
-                if (!res?.transferID) {
-                    return reject(new providers_1.ProviderTransferError('Init failed, invalid response from the server'));
+                try {
+                    const query = this.dispatcher?.dispatchCommand({
+                        command: 'init',
+                        params: { strategy, restore },
+                    });
+                    const res = (await query);
+                    if (!res?.transferID) {
+                        throw new providers_1.ProviderTransferError('Init failed, invalid response from the server');
+                    }
+                    resolve(res.transferID);
+                }
+                catch (e) {
+                    reject(e);
                 }
-                resolve(res.transferID);
             })
-                .once('error', reject);
+                .once('error', (message) => {
+                reject(message);
+            });
         });
     }
     async bootstrap() {
@@ -55,8 +65,7 @@ class RemoteStrapiDestinationProvider {
             });
         }
         const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
-        const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}`;
-        const validAuthMethods = ['token'];
+        const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}/push`;
         // No auth defined, trying public access for transfer
         if (!auth) {
             ws = new ws_1.WebSocket(wsUrl);
@@ -68,22 +77,28 @@ class RemoteStrapiDestinationProvider {
         }
         // Invalid auth method provided
         else {
-            throw new providers_1.ProviderValidationError('Auth method not implemented', {
+            throw new providers_1.ProviderValidationError('Auth method not available', {
                 check: 'auth.type',
                 details: {
                     auth: auth.type,
-                    validAuthMethods,
                 },
             });
         }
         this.ws = ws;
         this.dispatcher = (0, utils_1.createDispatcher)(this.ws);
-        const transferID = await this.initTransfer();
-        this.dispatcher.setTransferProperties({ id: transferID, kind: 'push' });
+        this.transferID = await this.initTransfer();
+        this.dispatcher.setTransferProperties({ id: this.transferID, kind: 'push' });
         await this.dispatcher.dispatchTransferAction('bootstrap');
     }
     async close() {
-        await this.dispatcher?.dispatchTransferAction('close');
+        // Gracefully close the remote transfer process
+        if (this.transferID && this.dispatcher) {
+            await this.dispatcher.dispatchTransferAction('close');
+            await this.dispatcher.dispatchCommand({
+                command: 'end',
+                params: { transferID: this.transferID },
+            });
+        }
         await new Promise((resolve) => {
             const { ws } = this;
             if (!ws || ws.CLOSED) {
@@ -99,6 +114,9 @@ class RemoteStrapiDestinationProvider {
     async beforeTransfer() {
         await this.dispatcher?.dispatchTransferAction('beforeTransfer');
     }
+    async rollback() {
+        await this.dispatcher?.dispatchTransferAction('rollback');
+    }
     getSchemas() {
         if (!this.dispatcher) {
             return Promise.resolve(null);
@@ -106,65 +124,111 @@ class RemoteStrapiDestinationProvider {
         return this.dispatcher.dispatchTransferAction('getSchemas');
     }
     createEntitiesWriteStream() {
-        return new stream_1.Writable({
-            objectMode: true,
-            write: async (entity, _encoding, callback) => {
-                const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'entities', entity);
-                callback(e);
-            },
-        });
+        return __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_writeStream).call(this, 'entities');
     }
     createLinksWriteStream() {
-        return new stream_1.Writable({
-            objectMode: true,
-            write: async (link, _encoding, callback) => {
-                const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'links', link);
-                callback(e);
-            },
-        });
+        return __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_writeStream).call(this, 'links');
     }
     createConfigurationWriteStream() {
-        return new stream_1.Writable({
-            objectMode: true,
-            write: async (configuration, _encoding, callback) => {
-                const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'configuration', configuration);
-                callback(e);
-            },
-        });
+        return __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_writeStream).call(this, 'configuration');
     }
     createAssetsWriteStream() {
+        let batch = [];
+        let hasStarted = false;
+        const batchSize = 1024 * 1024; // 1MB;
+        const batchLength = () => {
+            return batch.reduce((acc, chunk) => (chunk.action === 'stream' ? acc + chunk.data.byteLength : acc), 0);
+        };
+        const startAssetsTransferOnce = __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_startStepOnce).call(this, 'assets');
+        const flush = async () => {
+            const streamError = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', batch);
+            batch = [];
+            return streamError;
+        };
+        const safePush = async (chunk) => {
+            batch.push(chunk);
+            if (batchLength() >= batchSize) {
+                const streamError = await flush();
+                if (streamError) {
+                    throw streamError;
+                }
+            }
+        };
         return new stream_1.Writable({
             objectMode: true,
             final: async (callback) => {
-                // TODO: replace this stream call by an end call
-                const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', null);
-                callback(e);
+                if (batch.length > 0) {
+                    await flush();
+                }
+                if (hasStarted) {
+                    await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', null);
+                    const endStepError = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_endStep).call(this, 'assets');
+                    if (endStepError) {
+                        return callback(endStepError);
+                    }
+                }
+                return callback(null);
             },
-            write: async (asset, _encoding, callback) => {
-                const { filename, filepath, stats, stream } = asset;
+            async write(asset, _encoding, callback) {
+                const startError = await startAssetsTransferOnce();
+                if (startError) {
+                    return callback(startError);
+                }
+                hasStarted = true;
                 const assetID = (0, uuid_1.v4)();
-                await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', {
-                    action: 'start',
-                    assetID,
-                    data: { filename, filepath, stats },
-                });
-                for await (const chunk of stream) {
-                    await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', {
-                        action: 'stream',
+                const { filename, filepath, stats, stream } = asset;
+                try {
+                    await safePush({
+                        action: 'start',
                         assetID,
-                        data: chunk,
+                        data: { filename, filepath, stats },
                     });
+                    for await (const chunk of stream) {
+                        await safePush({ action: 'stream', assetID, data: chunk });
+                    }
+                    await safePush({ action: 'end', assetID });
+                    callback();
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        callback(error);
+                    }
                 }
-                await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', {
-                    action: 'end',
-                    assetID,
-                });
-                callback();
             },
         });
     }
 }
-_RemoteStrapiDestinationProvider_instances = new WeakSet(), _RemoteStrapiDestinationProvider_streamStep = async function _RemoteStrapiDestinationProvider_streamStep(step, data) {
+_RemoteStrapiDestinationProvider_instances = new WeakSet(), _RemoteStrapiDestinationProvider_startStepOnce = function _RemoteStrapiDestinationProvider_startStepOnce(stage) {
+    return (0, fp_1.once)(() => __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_startStep).call(this, stage));
+}, _RemoteStrapiDestinationProvider_startStep = async function _RemoteStrapiDestinationProvider_startStep(step) {
+    try {
+        await this.dispatcher?.dispatchTransferStep({ action: 'start', step });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return e;
+        }
+        if (typeof e === 'string') {
+            return new providers_1.ProviderTransferError(e);
+        }
+        return new providers_1.ProviderTransferError('Unexpected error');
+    }
+    return null;
+}, _RemoteStrapiDestinationProvider_endStep = async function _RemoteStrapiDestinationProvider_endStep(step) {
+    try {
+        await this.dispatcher?.dispatchTransferStep({ action: 'end', step });
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            return e;
+        }
+        if (typeof e === 'string') {
+            return new providers_1.ProviderTransferError(e);
+        }
+        return new providers_1.ProviderTransferError('Unexpected error');
+    }
+    return null;
+}, _RemoteStrapiDestinationProvider_streamStep = async function _RemoteStrapiDestinationProvider_streamStep(step, data) {
     try {
         await this.dispatcher?.dispatchTransferStep({ action: 'stream', step, data });
     }
@@ -178,6 +242,40 @@ _RemoteStrapiDestinationProvider_instances = new WeakSet(), _RemoteStrapiDestina
         return new providers_1.ProviderTransferError('Unexpected error');
     }
     return null;
+}, _RemoteStrapiDestinationProvider_writeStream = function _RemoteStrapiDestinationProvider_writeStream(step) {
+    const batchSize = 1024 * 1024; // 1MB;
+    const startTransferOnce = __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_startStepOnce).call(this, step);
+    let batch = [];
+    const batchLength = () => jsonLength(batch);
+    return new stream_1.Writable({
+        objectMode: true,
+        final: async (callback) => {
+            if (batch.length > 0) {
+                const streamError = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, step, batch);
+                batch = [];
+                if (streamError) {
+                    return callback(streamError);
+                }
+            }
+            const e = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_endStep).call(this, step);
+            callback(e);
+        },
+        write: async (chunk, _encoding, callback) => {
+            const startError = await startTransferOnce();
+            if (startError) {
+                return callback(startError);
+            }
+            batch.push(chunk);
+            if (batchLength() >= batchSize) {
+                const streamError = await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, step, batch);
+                batch = [];
+                if (streamError) {
+                    return callback(streamError);
+                }
+            }
+            callback();
+        },
+    });
 };
 const createRemoteStrapiDestinationProvider = (options) => {
     return new RemoteStrapiDestinationProvider(options);