@strapi/data-transfer 4.6.2 → 4.7.0-exp.117579f4c13806c2cd518e7d7d2f9d0c8a20107d

package/lib/engine/index.js

@@ -230,7 +230,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 });
     }
@@ -288,7 +288,7 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
     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 +416,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) => {
@@ -448,11 +454,15 @@ _TransferEngine_metadata = new WeakMap(), _TransferEngine_instances = new WeakSe
         stream
             .pipe(destination)
             .on('error', (e) => {
+            updateEndTime();
             __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_reportError).call(this, e, 'error');
             destination.destroy(e);
             reject(e);
         })
-            .on('close', resolve);
+            .on('close', () => {
+            updateEndTime();
+            resolve();
+        });
     });
     __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_emitStageUpdate).call(this, 'finish', stage);
 }, _TransferEngine_resolveProviderResource = async function _TransferEngine_resolveProviderResource() {

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/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

@@ -4,18 +4,13 @@ import { Writable } from 'stream';
 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 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: { options: { strategy, restore }, transfer: 'push' },
+                    });
+                    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() {
@@ -56,7 +66,6 @@ class RemoteStrapiDestinationProvider {
         }
         const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
         const wsUrl = `${wsProtocol}//${url.host}${url.pathname}${constants_1.TRANSFER_PATH}`;
-        const validAuthMethods = ['token'];
         // 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,96 @@ 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 () => {
+            await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', batch);
+            batch = [];
+        };
+        const safePush = async (chunk) => {
+            batch.push(chunk);
+            if (batchLength() >= batchSize) {
+                await flush();
+            }
+        };
         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 },
-                });
+                const { filename, filepath, stats, stream } = asset;
+                await safePush({ 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',
-                        assetID,
-                        data: chunk,
-                    });
+                    await safePush({ action: 'stream', assetID, data: chunk });
                 }
-                await __classPrivateFieldGet(this, _RemoteStrapiDestinationProvider_instances, "m", _RemoteStrapiDestinationProvider_streamStep).call(this, 'assets', {
-                    action: 'end',
-                    assetID,
-                });
+                await safePush({ 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 +227,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);

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDispatcher = void 0;
 const uuid_1 = require("uuid");
+const providers_1 = require("../../../errors/providers");
 const createDispatcher = (ws) => {
     const state = {};
     const dispatch = async (message, options = {}) => {
@@ -24,7 +25,7 @@ const createDispatcher = (ws) => {
                 const response = JSON.parse(raw.toString());
                 if (response.uuid === uuid) {
                     if (response.error) {
-                        return reject(new Error(response.error.message));
+                        return reject(new providers_1.ProviderError('error', response.error.message));
                     }
                     resolve(response.data ?? null);
                 }
@@ -32,7 +33,6 @@ const createDispatcher = (ws) => {
                     ws.once('message', onResponse);
                 }
             };
-            // TODO: What happens if the server sends another message (not a response to this message)
             ws.once('message', onResponse);
         });
     };

package/lib/strapi/remote/constants.d.ts

@@ -1,2 +1,2 @@
-export declare const TRANSFER_PATH = "/transfer";
-export declare const TRANSFER_METHODS: string[];
+export declare const TRANSFER_PATH: "/transfer/runner/connect";
+export declare const TRANSFER_METHODS: readonly ["push", "pull"];

package/lib/strapi/remote/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TRANSFER_METHODS = exports.TRANSFER_PATH = void 0;
-exports.TRANSFER_PATH = '/transfer';
+exports.TRANSFER_PATH = '/transfer/runner/connect';
 exports.TRANSFER_METHODS = ['push', 'pull'];
 //# sourceMappingURL=constants.js.map

package/lib/strapi/remote/controllers/push.d.ts

@@ -13,6 +13,7 @@ export interface IPushController {
         bootstrap(): Promise<void>;
         close(): Promise<void>;
         beforeTransfer(): Promise<void>;
+        rollback(): Promise<void>;
     };
     transfer: {
         [key in TransferPushStep]: <T extends TransferPushMessage>(value: T extends {

package/lib/strapi/remote/controllers/push.js

@@ -34,58 +34,79 @@ const createPushController = (options) => {
             async beforeTransfer() {
                 return provider.beforeTransfer();
             },
+            async rollback() {
+                await provider.rollback();
+            },
         },
         transfer: {
-            async entities(entity) {
+            async entities(entities) {
                 if (!streams.entities) {
                     streams.entities = provider.createEntitiesWriteStream();
                 }
-                await writeAsync(streams.entities, entity);
+                for (const entity of entities) {
+                    if (streams.entities) {
+                        await writeAsync(streams.entities, entity);
+                    }
+                }
             },
-            async links(link) {
+            async links(links) {
                 if (!streams.links) {
                     streams.links = await provider.createLinksWriteStream();
                 }
-                await writeAsync(streams.links, link);
+                for (const link of links) {
+                    if (streams.links) {
+                        await writeAsync(streams.links, link);
+                    }
+                }
             },
-            async configuration(config) {
+            async configuration(configs) {
                 if (!streams.configuration) {
                     streams.configuration = await provider.createConfigurationWriteStream();
                 }
-                await writeAsync(streams.configuration, config);
+                for (const config of configs) {
+                    if (streams.configuration) {
+                        await writeAsync(streams.configuration, config);
+                    }
+                }
             },
-            async assets(payload) {
-                // TODO: close the stream upong receiving an 'end' event instead
-                if (payload === null) {
+            async assets(payloads) {
+                if (payloads === null) {
                     streams.assets?.end();
                     return;
                 }
-                const { action, assetID } = payload;
                 if (!streams.assets) {
                     streams.assets = await provider.createAssetsWriteStream();
                 }
-                if (action === 'start') {
-                    assets[assetID] = { ...payload.data, stream: new stream_chain_1.PassThrough() };
-                    writeAsync(streams.assets, assets[assetID]);
-                }
-                if (action === 'stream') {
-                    // The buffer has gone through JSON operations and is now of shape { type: "Buffer"; data: UInt8Array }
-                    // We need to transform it back into a Buffer instance
-                    const rawBuffer = payload.data;
-                    const chunk = Buffer.from(rawBuffer.data);
-                    await writeAsync(assets[assetID].stream, chunk);
-                }
-                if (action === 'end') {
-                    await new Promise((resolve, reject) => {
-                        const { stream } = assets[assetID];
-                        stream
-                            .on('close', () => {
-                            delete assets[assetID];
-                            resolve();
-                        })
-                            .on('error', reject)
-                            .end();
-                    });
+                for (const payload of payloads) {
+                    if (streams.assets.closed) {
+                        return;
+                    }
+                    const { action, assetID } = payload;
+                    if (action === 'start' && streams.assets) {
+                        assets[assetID] = { ...payload.data, stream: new stream_chain_1.PassThrough() };
+                        writeAsync(streams.assets, assets[assetID]);
+                    }
+                    if (action === 'stream') {
+                        // The buffer has gone through JSON operations and is now of shape { type: "Buffer"; data: UInt8Array }
+                        // We need to transform it back into a Buffer instance
+                        const rawBuffer = payload.data;
+                        const chunk = Buffer.from(rawBuffer.data);
+                        await writeAsync(assets[assetID].stream, chunk);
+                    }
+                    if (action === 'end') {
+                        await new Promise((resolve, reject) => {
+                            const { stream } = assets[assetID];
+                            stream
+                                .on('close', () => {
+                                delete assets[assetID];
+                                resolve();
+                            })
+                                .on('error', (e) => {
+                                reject(e);
+                            })
+                                .end();
+                        });
+                    }
                 }
             },
         },

package/lib/strapi/remote/flows/default.d.ts

@@ -0,0 +1,3 @@
+import type { Step } from '.';
+declare const _default: readonly Step[];
+export default _default;