@strapi/data-transfer 4.6.0-beta.2 → 4.6.1

package/lib/errors/providers.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProviderTransferError = exports.ProviderValidationError = exports.ProviderInitializationError = exports.ProviderError = void 0;
+const base_1 = require("./base");
+const constants_1 = require("./constants");
+class ProviderError extends base_1.DataTransferError {
+    constructor(severity, message, details) {
+        super('provider', severity, message, details);
+    }
+}
+exports.ProviderError = ProviderError;
+class ProviderInitializationError extends ProviderError {
+    constructor(message) {
+        super(constants_1.SeverityKind.FATAL, message, { step: 'initialization' });
+    }
+}
+exports.ProviderInitializationError = ProviderInitializationError;
+// TODO: these types are not working correctly, ProviderTransferError() is accepting any details object rather than requiring T
+class ProviderValidationError extends ProviderError {
+    constructor(message, details) {
+        super(constants_1.SeverityKind.SILLY, message, { step: 'validation', details });
+    }
+}
+exports.ProviderValidationError = ProviderValidationError;
+// TODO: these types are not working correctly, ProviderTransferError() is accepting any details object rather than requiring T
+class ProviderTransferError extends ProviderError {
+    constructor(message, details) {
+        super(constants_1.SeverityKind.FATAL, message, { step: 'transfer', details });
+    }
+}
+exports.ProviderTransferError = ProviderTransferError;
+//# sourceMappingURL=providers.js.map

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

@@ -26,6 +26,7 @@ const stream_1 = require("stream");
 const Parser_1 = require("stream-json/jsonl/Parser");
 const encryption_1 = require("../../../utils/encryption");
 const stream_2 = require("../../../utils/stream");
+const providers_1 = require("../../../errors/providers");
 /**
  * Constant for the metadata file path
  */
@@ -56,7 +57,10 @@ class LocalFileSourceProvider {
             __classPrivateFieldSet(this, _LocalFileSourceProvider_metadata, await this.getMetadata(), "f");
         }
         catch (e) {
-            throw new Error(`Can't read file "${filePath}".`);
+            if (this.options?.encryption?.enabled) {
+                throw new providers_1.ProviderInitializationError(`Key is incorrect or the file '${filePath}' is not a valid Strapi data file.`);
+            }
+            throw new providers_1.ProviderInitializationError(`File '${filePath}' is not a valid Strapi data file.`);
         }
     }
     getMetadata() {
@@ -137,35 +141,46 @@ _LocalFileSourceProvider_metadata = new WeakMap(), _LocalFileSourceProvider_inst
                 if (entry.type !== 'File') {
                     return false;
                 }
-                const parts = filePath.split('/');
+                const parts = path_1.default.relative('.', filePath).split('/');
+                // TODO: this method is limiting us from having additional subdirectories and is requiring us to remove any "./" prefixes (the path.relative line above)
                 if (parts.length !== 2) {
                     return false;
                 }
                 return parts[0] === directory;
             },
-            onentry(entry) {
+            async onentry(entry) {
                 const transforms = [
                     // JSONL parser to read the data chunks one by one (line by line)
-                    (0, Parser_1.parser)(),
+                    (0, Parser_1.parser)({
+                        checkErrors: true,
+                    }),
                     // The JSONL parser returns each line as key/value
                     (line) => line.value,
                 ];
-                entry
-                    // Pipe transforms
-                    .pipe((0, stream_chain_1.chain)(transforms))
-                    // Pipe the out stream to the whole pipeline
-                    // DO NOT send the 'end' event when this entry has finished
-                    // emitting data, so that it doesn't close the out stream
-                    .pipe(outStream, { end: false });
+                const stream = entry.pipe((0, stream_chain_1.chain)(transforms));
+                try {
+                    for await (const chunk of stream) {
+                        outStream.write(chunk);
+                    }
+                }
+                catch (e) {
+                    outStream.destroy(new providers_1.ProviderTransferError(`Error parsing backup files from backup file ${entry.path}: ${e.message}`, {
+                        details: {
+                            error: e,
+                        },
+                    }));
+                }
             },
         }),
-    ], () => {
+    ], async () => {
         // Manually send the 'end' event to the out stream
         // once every entry has finished streaming its content
         outStream.end();
     });
     return outStream;
-}, _LocalFileSourceProvider_parseJSONFile = async function _LocalFileSourceProvider_parseJSONFile(fileStream, filePath) {
+}, _LocalFileSourceProvider_parseJSONFile = 
+// For collecting an entire JSON file then parsing it, not for streaming JSONL
+async function _LocalFileSourceProvider_parseJSONFile(fileStream, filePath) {
     return new Promise((resolve, reject) => {
         (0, stream_1.pipeline)([
             fileStream,
@@ -175,7 +190,7 @@ _LocalFileSourceProvider_metadata = new WeakMap(), _LocalFileSourceProvider_inst
                  * Filter the parsed entries to only keep the one that matches the given filepath
                  */
                 filter(entryPath, entry) {
-                    return entryPath === filePath && entry.type === 'File';
+                    return !path_1.default.relative(filePath, entryPath).length && entry.type === 'File';
                 },
                 async onentry(entry) {
                     // Collect all the content of the entry file

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

@@ -1,7 +1,7 @@
 /// <reference types="lodash" />
 /// <reference types="node" />
 import { Writable } from 'stream';
-import type { IDestinationProvider, IMetadata, ProviderType } from '../../../../types';
+import type { IDestinationProvider, IMetadata, ProviderType, Transaction } from '../../../../types';
 import { restore } from './strategies';
 export declare const VALID_CONFLICT_STRATEGIES: string[];
 export declare const DEFAULT_CONFLICT_STRATEGY = "restore";
@@ -17,9 +17,11 @@ declare class LocalStrapiDestinationProvider implements IDestinationProvider {
     type: ProviderType;
     options: ILocalStrapiDestinationProviderOptions;
     strapi?: Strapi.Strapi;
+    transaction?: Transaction;
     constructor(options: ILocalStrapiDestinationProviderOptions);
     bootstrap(): Promise<void>;
     close(): Promise<void>;
+    rollback(): void;
     beforeTransfer(): Promise<void>;
     getMetadata(): IMetadata;
     getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;

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

@@ -44,6 +44,8 @@ const path_1 = __importDefault(require("path"));
 const fse = __importStar(require("fs-extra"));
 const strategies_1 = require("./strategies");
 const utils = __importStar(require("../../../utils"));
+const providers_1 = require("../../../errors/providers");
+const providers_2 = require("../../../utils/providers");
 exports.VALID_CONFLICT_STRATEGIES = ['restore', 'merge'];
 exports.DEFAULT_CONFLICT_STRATEGY = 'restore';
 class LocalStrapiDestinationProvider {
@@ -61,39 +63,46 @@ class LocalStrapiDestinationProvider {
     async bootstrap() {
         __classPrivateFieldGet(this, _LocalStrapiDestinationProvider_instances, "m", _LocalStrapiDestinationProvider_validateOptions).call(this);
         this.strapi = await this.options.getStrapi();
+        this.transaction = utils.transaction.createTransaction(this.strapi);
     }
     async close() {
         const { autoDestroy } = this.options;
+        this.transaction?.end();
         // Basically `!== false` but more deterministic
         if (autoDestroy === undefined || autoDestroy === true) {
             await this.strapi?.destroy();
         }
     }
+    rollback() {
+        this.transaction?.rollback();
+    }
     async beforeTransfer() {
-        if (this.options.strategy === 'restore') {
-            await __classPrivateFieldGet(this, _LocalStrapiDestinationProvider_instances, "m", _LocalStrapiDestinationProvider_deleteAll).call(this);
+        if (!this.strapi) {
+            throw new Error('Strapi instance not found');
         }
+        await this.transaction?.attach(async () => {
+            try {
+                if (this.options.strategy === 'restore') {
+                    await __classPrivateFieldGet(this, _LocalStrapiDestinationProvider_instances, "m", _LocalStrapiDestinationProvider_deleteAll).call(this);
+                }
+            }
+            catch (error) {
+                throw new Error(`restore failed ${error}`);
+            }
+        });
     }
     getMetadata() {
         const strapiVersion = strapi.config.get('info.strapi');
         const createdAt = new Date().toISOString();
-        const plugins = Object.keys(strapi.plugins);
         return {
             createdAt,
             strapi: {
                 version: strapiVersion,
-                plugins: plugins.map((name) => ({
-                    name,
-                    // TODO: Get the plugin actual version when it'll be available
-                    version: strapiVersion,
-                })),
             },
         };
     }
     getSchemas() {
-        if (!this.strapi) {
-            throw new Error('Not able to get Schemas. Strapi instance not found');
-        }
+        (0, providers_2.assertValidStrapi)(this.strapi, 'Not able to get Schemas');
         const schemas = {
             ...this.strapi.contentTypes,
             ...this.strapi.components,
@@ -101,9 +110,7 @@ class LocalStrapiDestinationProvider {
         return utils.schema.mapSchemasValues(schemas);
     }
     createEntitiesWriteStream() {
-        if (!this.strapi) {
-            throw new Error('Not able to import entities. Strapi instance not found');
-        }
+        (0, providers_2.assertValidStrapi)(this.strapi, 'Not able to import entities');
         const { strategy } = this.options;
         const updateMappingTable = (type, oldID, newID) => {
             if (!__classPrivateFieldGet(this, _LocalStrapiDestinationProvider_entitiesMapper, "f")[type]) {
@@ -115,19 +122,24 @@ class LocalStrapiDestinationProvider {
             return strategies_1.restore.createEntitiesWriteStream({
                 strapi: this.strapi,
                 updateMappingTable,
+                transaction: this.transaction,
             });
         }
-        throw new Error(`Invalid strategy supplied: "${strategy}"`);
+        throw new providers_1.ProviderValidationError(`Invalid strategy ${this.options.strategy}`, {
+            check: 'strategy',
+            strategy: this.options.strategy,
+            validStrategies: exports.VALID_CONFLICT_STRATEGIES,
+        });
     }
     // TODO: Move this logic to the restore strategy
     async createAssetsWriteStream() {
-        if (!this.strapi) {
-            throw new Error('Not able to stream Assets. Strapi instance not found');
-        }
+        (0, providers_2.assertValidStrapi)(this.strapi, 'Not able to stream Assets');
         const assetsDirectory = path_1.default.join(this.strapi.dirs.static.public, 'uploads');
         const backupDirectory = path_1.default.join(this.strapi.dirs.static.public, `uploads_backup_${Date.now()}`);
-        await fse.rename(assetsDirectory, backupDirectory);
+        await fse.move(assetsDirectory, backupDirectory);
         await fse.mkdir(assetsDirectory);
+        // Create a .gitkeep file to ensure the directory is not empty
+        await fse.outputFile(path_1.default.join(assetsDirectory, '.gitkeep'), '');
         return new stream_1.Writable({
             objectMode: true,
             async final(next) {
@@ -143,11 +155,11 @@ class LocalStrapiDestinationProvider {
                     .on('error', async (error) => {
                     try {
                         await fse.rm(assetsDirectory, { recursive: true, force: true });
-                        await fse.rename(backupDirectory, assetsDirectory);
-                        this.destroy(new Error(`There was an error during the transfer process. The original files have been restored to ${assetsDirectory}`));
+                        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}`));
                     }
                     catch (err) {
-                        throw new Error(`There was an error doing the rollback process. The original files are in ${backupDirectory}, but we failed to restore them to ${assetsDirectory}`);
+                        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}`);
                     }
                     finally {
                         callback(error);
@@ -157,14 +169,16 @@ class LocalStrapiDestinationProvider {
         });
     }
     async createConfigurationWriteStream() {
-        if (!this.strapi) {
-            throw new Error('Not able to stream Configurations. Strapi instance not found');
-        }
+        (0, providers_2.assertValidStrapi)(this.strapi, 'Not able to stream Configurations');
         const { strategy } = this.options;
         if (strategy === 'restore') {
-            return strategies_1.restore.createConfigurationWriteStream(this.strapi);
+            return strategies_1.restore.createConfigurationWriteStream(this.strapi, this.transaction);
         }
-        throw new Error(`Invalid strategy supplied: "${strategy}"`);
+        throw new providers_1.ProviderValidationError(`Invalid strategy ${strategy}`, {
+            check: 'strategy',
+            strategy,
+            validStrategies: exports.VALID_CONFLICT_STRATEGIES,
+        });
     }
     async createLinksWriteStream() {
         if (!this.strapi) {
@@ -173,19 +187,25 @@ class LocalStrapiDestinationProvider {
         const { strategy } = this.options;
         const mapID = (uid, id) => __classPrivateFieldGet(this, _LocalStrapiDestinationProvider_entitiesMapper, "f")[uid]?.[id];
         if (strategy === 'restore') {
-            return strategies_1.restore.createLinksWriteStream(mapID, this.strapi);
+            return strategies_1.restore.createLinksWriteStream(mapID, this.strapi, this.transaction);
         }
-        throw new Error(`Invalid strategy supplied: "${strategy}"`);
+        throw new providers_1.ProviderValidationError(`Invalid strategy ${strategy}`, {
+            check: 'strategy',
+            strategy,
+            validStrategies: exports.VALID_CONFLICT_STRATEGIES,
+        });
     }
 }
 _LocalStrapiDestinationProvider_entitiesMapper = new WeakMap(), _LocalStrapiDestinationProvider_instances = new WeakSet(), _LocalStrapiDestinationProvider_validateOptions = function _LocalStrapiDestinationProvider_validateOptions() {
     if (!exports.VALID_CONFLICT_STRATEGIES.includes(this.options.strategy)) {
-        throw new Error(`Invalid stategy ${this.options.strategy}`);
+        throw new providers_1.ProviderValidationError(`Invalid strategy ${this.options.strategy}`, {
+            check: 'strategy',
+            strategy: this.options.strategy,
+            validStrategies: exports.VALID_CONFLICT_STRATEGIES,
+        });
     }
 }, _LocalStrapiDestinationProvider_deleteAll = async function _LocalStrapiDestinationProvider_deleteAll() {
-    if (!this.strapi) {
-        throw new Error('Strapi instance not found');
-    }
+    (0, providers_2.assertValidStrapi)(this.strapi);
     return strategies_1.restore.deleteRecords(this.strapi, this.options.restore);
 };
 const createLocalStrapiDestinationProvider = (options) => {

package/lib/strapi/providers/local-destination/strategies/restore/configuration.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
 import { Writable } from 'stream';
-import { IConfiguration } from '../../../../../../types';
+import { IConfiguration, Transaction } from '../../../../../../types';
 export declare const restoreConfigs: (strapi: Strapi.Strapi, config: IConfiguration) => Promise<any>;
-export declare const createConfigurationWriteStream: (strapi: Strapi.Strapi) => Promise<Writable>;
+export declare const createConfigurationWriteStream: (strapi: Strapi.Strapi, transaction?: Transaction | undefined) => Promise<Writable>;

package/lib/strapi/providers/local-destination/strategies/restore/configuration.js

@@ -4,9 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createConfigurationWriteStream = exports.restoreConfigs = void 0;
+const fp_1 = require("lodash/fp");
 const stream_1 = require("stream");
 const chalk_1 = __importDefault(require("chalk"));
-const restoreCoreStore = async (strapi, data) => {
+const providers_1 = require("../../../../../errors/providers");
+const omitInvalidCreationAttributes = (0, fp_1.omit)(['id']);
+const restoreCoreStore = async (strapi, values) => {
+    const data = omitInvalidCreationAttributes(values);
     return strapi.db.query('strapi::core-store').create({
         data: {
             ...data,
@@ -14,7 +18,8 @@ const restoreCoreStore = async (strapi, data) => {
         },
     });
 };
-const restoreWebhooks = async (strapi, data) => {
+const restoreWebhooks = async (strapi, values) => {
+    const data = omitInvalidCreationAttributes(values);
     return strapi.db.query('webhook').create({ data });
 };
 const restoreConfigs = async (strapi, config) => {
@@ -26,17 +31,19 @@ const restoreConfigs = async (strapi, config) => {
     }
 };
 exports.restoreConfigs = restoreConfigs;
-const createConfigurationWriteStream = async (strapi) => {
+const createConfigurationWriteStream = async (strapi, transaction) => {
     return new stream_1.Writable({
         objectMode: true,
         async write(config, _encoding, callback) {
-            try {
-                await (0, exports.restoreConfigs)(strapi, config);
-            }
-            catch (error) {
-                return callback(new Error(`Failed to import ${chalk_1.default.yellowBright(config.type)} (${chalk_1.default.greenBright(config.value.id)}`));
-            }
-            callback();
+            await transaction?.attach(async () => {
+                try {
+                    await (0, exports.restoreConfigs)(strapi, config);
+                }
+                catch (error) {
+                    return callback(new providers_1.ProviderTransferError(`Failed to import ${chalk_1.default.yellowBright(config.type)} (${chalk_1.default.greenBright(config.value.id)}`));
+                }
+                callback();
+            });
         },
     });
 };

package/lib/strapi/providers/local-destination/strategies/restore/entities.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 import type { SchemaUID } from '@strapi/strapi/lib/types/utils';
 import { Writable } from 'stream';
+import type { Transaction } from '../../../../../../types';
 interface IEntitiesRestoreStreamOptions {
     strapi: Strapi.Strapi;
     updateMappingTable<T extends SchemaUID | string>(type: T, oldID: number, newID: number): void;
+    transaction?: Transaction;
 }
 declare const createEntitiesWriteStream: (options: IEntitiesRestoreStreamOptions) => Writable;
 export { createEntitiesWriteStream };

package/lib/strapi/providers/local-destination/strategies/restore/entities.js

@@ -26,73 +26,76 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEntitiesWriteStream = void 0;
 const fp_1 = require("lodash/fp");
 const stream_1 = require("stream");
+const providers_1 = require("../../../../../errors/providers");
 const utils_1 = require("../../../../../utils");
 const queries = __importStar(require("../../../../queries"));
 const createEntitiesWriteStream = (options) => {
-    const { strapi, updateMappingTable } = options;
+    const { strapi, updateMappingTable, transaction } = options;
     const query = queries.entity.createEntityQuery(strapi);
     return new stream_1.Writable({
         objectMode: true,
         async write(entity, _encoding, callback) {
-            const { type, id, data } = entity;
-            const { create, getDeepPopulateComponentLikeQuery } = query(type);
-            const contentType = strapi.getModel(type);
-            /**
-             * Resolve the component UID of an entity's attribute based
-             * on a given path (components & dynamic zones only)
-             */
-            const resolveType = (paths) => {
-                let cType = contentType;
-                let value = data;
-                for (const path of paths) {
-                    value = (0, fp_1.get)(path, value);
-                    // Needed when the value of cType should be computed
-                    // based on the next value (eg: dynamic zones)
-                    if (typeof cType === 'function') {
-                        cType = cType(value);
-                    }
-                    if (path in cType.attributes) {
-                        const attribute = cType.attributes[path];
-                        if (attribute.type === 'component') {
-                            cType = strapi.getModel(attribute.component);
+            await transaction?.attach(async () => {
+                const { type, id, data } = entity;
+                const { create, getDeepPopulateComponentLikeQuery } = query(type);
+                const contentType = strapi.getModel(type);
+                /**
+                 * Resolve the component UID of an entity's attribute based
+                 * on a given path (components & dynamic zones only)
+                 */
+                const resolveType = (paths) => {
+                    let cType = contentType;
+                    let value = data;
+                    for (const path of paths) {
+                        value = (0, fp_1.get)(path, value);
+                        // Needed when the value of cType should be computed
+                        // based on the next value (eg: dynamic zones)
+                        if (typeof cType === 'function') {
+                            cType = cType(value);
                         }
-                        if (attribute.type === 'dynamiczone') {
-                            cType = ({ __component }) => strapi.getModel(__component);
+                        if (path in cType.attributes) {
+                            const attribute = cType.attributes[path];
+                            if (attribute.type === 'component') {
+                                cType = strapi.getModel(attribute.component);
+                            }
+                            if (attribute.type === 'dynamiczone') {
+                                cType = ({ __component }) => strapi.getModel(__component);
+                            }
                         }
                     }
-                }
-                return cType?.uid;
-            };
-            try {
-                const created = await create({
-                    data,
-                    populate: getDeepPopulateComponentLikeQuery(contentType, { select: 'id' }),
-                    select: 'id',
-                });
-                // Compute differences between original & new entities
-                const diffs = utils_1.json.diff(data, created);
-                updateMappingTable(type, id, created.id);
-                // For each difference found on an ID attribute,
-                // update the mapping the table accordingly
-                diffs.forEach((diff) => {
-                    if (diff.kind === 'modified' && (0, fp_1.last)(diff.path) === 'id') {
-                        const target = resolveType(diff.path);
-                        // If no type is found for the given path, then ignore the diff
-                        if (!target) {
-                            return;
+                    return cType?.uid;
+                };
+                try {
+                    const created = await create({
+                        data,
+                        populate: getDeepPopulateComponentLikeQuery(contentType, { select: 'id' }),
+                        select: 'id',
+                    });
+                    // Compute differences between original & new entities
+                    const diffs = utils_1.json.diff(data, created);
+                    updateMappingTable(type, id, created.id);
+                    // For each difference found on an ID attribute,
+                    // update the mapping the table accordingly
+                    diffs.forEach((diff) => {
+                        if (diff.kind === 'modified' && (0, fp_1.last)(diff.path) === 'id') {
+                            const target = resolveType(diff.path);
+                            // If no type is found for the given path, then ignore the diff
+                            if (!target) {
+                                return;
+                            }
+                            const [oldID, newID] = diff.values;
+                            updateMappingTable(target, oldID, newID);
                         }
-                        const [oldID, newID] = diff.values;
-                        updateMappingTable(target, oldID, newID);
+                    });
+                }
+                catch (e) {
+                    if (e instanceof Error) {
+                        return callback(e);
                     }
-                });
-            }
-            catch (e) {
-                if (e instanceof Error) {
-                    return callback(e);
+                    return callback(new providers_1.ProviderTransferError(`Failed to create "${type}" (${id})`));
                 }
-                return callback(new Error(`Failed to create "${type}" (${id})`));
-            }
-            return callback(null);
+                return callback(null);
+            });
         },
     });
 };

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

@@ -27,6 +27,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteRecords = void 0;
+const providers_1 = require("../../../../../errors/providers");
 const queries = __importStar(require("../../../../queries"));
 const deleteRecords = async (strapi, options) => {
     const entities = await deleteEntitiesRecord(strapi, options);
@@ -92,7 +93,7 @@ const useResults = (keys) => {
     const update = (count, key) => {
         if (key) {
             if (!(key in results.aggregate)) {
-                throw new Error(`Unknown key "${key}" provided in results update`);
+                throw new providers_1.ProviderTransferError(`Unknown key "${key}" provided in results update`);
             }
             results.aggregate[key].count += count;
         }

package/lib/strapi/providers/local-destination/strategies/restore/links.d.ts

@@ -1,3 +1,4 @@
 /// <reference types="node" />
 import { Writable } from 'stream';
-export declare const createLinksWriteStream: (mapID: (uid: string, id: number) => number | undefined, strapi: Strapi.Strapi) => Writable;
+import { Transaction } from '../../../../../../types';
+export declare const createLinksWriteStream: (mapID: (uid: string, id: number) => number | undefined, strapi: Strapi.Strapi, transaction?: Transaction | undefined) => Writable;

package/lib/strapi/providers/local-destination/strategies/restore/links.js

@@ -2,26 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinksWriteStream = void 0;
 const stream_1 = require("stream");
+const providers_1 = require("../../../../../errors/providers");
 const link_1 = require("../../../../queries/link");
-const createLinksWriteStream = (mapID, strapi) => {
+const createLinksWriteStream = (mapID, strapi, transaction) => {
     return new stream_1.Writable({
         objectMode: true,
         async write(link, _encoding, callback) {
-            const { left, right } = link;
-            const query = (0, link_1.createLinkQuery)(strapi);
-            // Map IDs if needed
-            left.ref = mapID(left.type, left.ref) ?? left.ref;
-            right.ref = mapID(right.type, right.ref) ?? right.ref;
-            try {
-                await query().insert(link);
-            }
-            catch (e) {
-                if (e instanceof Error) {
-                    return callback(e);
+            await transaction?.attach(async (trx) => {
+                const { left, right } = link;
+                const query = (0, link_1.createLinkQuery)(strapi, trx);
+                // Map IDs if needed
+                left.ref = mapID(left.type, left.ref) ?? left.ref;
+                right.ref = mapID(right.type, right.ref) ?? right.ref;
+                try {
+                    await query().insert(link);
                 }
-                return callback(new Error(`An error happened while trying to import a ${left.type} link. ${e}`));
-            }
-            callback(null);
+                catch (e) {
+                    if (e instanceof Error) {
+                        return callback(e);
+                    }
+                    return callback(new providers_1.ProviderTransferError(`An error happened while trying to import a ${left.type} link.`));
+                }
+                callback(null);
+            });
         },
     });
 };