@strapi/data-transfer 4.9.0 → 4.10.0-beta.0

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

@@ -0,0 +1,220 @@
+"use strict";
+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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _LocalFileSourceProvider_instances, _LocalFileSourceProvider_metadata, _LocalFileSourceProvider_getBackupStream, _LocalFileSourceProvider_streamJsonlDirectory, _LocalFileSourceProvider_parseJSONFile;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalFileSourceProvider = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const zlib_1 = __importDefault(require("zlib"));
+const tar_1 = __importDefault(require("tar"));
+const path_1 = __importDefault(require("path"));
+const fp_1 = require("lodash/fp");
+const stream_chain_1 = require("stream-chain");
+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
+ */
+const METADATA_FILE_PATH = 'metadata.json';
+const createLocalFileSourceProvider = (options) => {
+    return new LocalFileSourceProvider(options);
+};
+exports.createLocalFileSourceProvider = createLocalFileSourceProvider;
+class LocalFileSourceProvider {
+    constructor(options) {
+        _LocalFileSourceProvider_instances.add(this);
+        this.type = 'source';
+        this.name = 'source::local-file';
+        _LocalFileSourceProvider_metadata.set(this, void 0);
+        this.options = options;
+        const { encryption } = this.options;
+        if (encryption.enabled && encryption.key === undefined) {
+            throw new Error('Missing encryption key');
+        }
+    }
+    /**
+     * Pre flight checks regarding the provided options, making sure that the file can be opened (decrypted, decompressed), etc.
+     */
+    async bootstrap() {
+        const { path: filePath } = this.options.file;
+        try {
+            // Read the metadata to ensure the file can be parsed
+            __classPrivateFieldSet(this, _LocalFileSourceProvider_metadata, await this.getMetadata(), "f");
+        }
+        catch (e) {
+            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() {
+        // TODO: need to read the file & extract the metadata json file
+        // => we might also need to read the schema.jsonl files & implements a custom stream-check
+        const backupStream = __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_getBackupStream).call(this);
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_parseJSONFile).call(this, backupStream, METADATA_FILE_PATH);
+    }
+    async getSchemas() {
+        const schemas = await (0, stream_2.collect)(this.createSchemasReadStream());
+        return (0, fp_1.keyBy)('uid', schemas);
+    }
+    createEntitiesReadStream() {
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'entities');
+    }
+    createSchemasReadStream() {
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'schemas');
+    }
+    createLinksReadStream() {
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'links');
+    }
+    createConfigurationReadStream() {
+        // NOTE: TBD
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'configuration');
+    }
+    createAssetsReadStream() {
+        const inStream = __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_getBackupStream).call(this);
+        const outStream = new stream_1.PassThrough({ objectMode: true });
+        (0, stream_1.pipeline)([
+            inStream,
+            new tar_1.default.Parse({
+                filter(filePath, entry) {
+                    if (entry.type !== 'File') {
+                        return false;
+                    }
+                    const parts = filePath.split('/');
+                    return parts[0] === 'assets' && parts[1] === 'uploads';
+                },
+                onentry(entry) {
+                    const { path: filePath, size = 0 } = entry;
+                    const file = path_1.default.basename(filePath);
+                    const asset = {
+                        filename: file,
+                        filepath: filePath,
+                        stats: { size },
+                        stream: entry,
+                    };
+                    outStream.write(asset);
+                },
+            }),
+        ], () => outStream.end());
+        return outStream;
+    }
+}
+_LocalFileSourceProvider_metadata = new WeakMap(), _LocalFileSourceProvider_instances = new WeakSet(), _LocalFileSourceProvider_getBackupStream = function _LocalFileSourceProvider_getBackupStream() {
+    const { file, encryption, compression } = this.options;
+    const streams = [];
+    try {
+        streams.push(fs_extra_1.default.createReadStream(file.path));
+    }
+    catch (e) {
+        throw new Error(`Could not read backup file path provided at "${this.options.file.path}"`);
+    }
+    if (encryption.enabled && encryption.key) {
+        streams.push((0, encryption_1.createDecryptionCipher)(encryption.key));
+    }
+    if (compression.enabled) {
+        streams.push(zlib_1.default.createGunzip());
+    }
+    return (0, stream_chain_1.chain)(streams);
+}, _LocalFileSourceProvider_streamJsonlDirectory = function _LocalFileSourceProvider_streamJsonlDirectory(directory) {
+    const inStream = __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_getBackupStream).call(this);
+    const outStream = new stream_1.PassThrough({ objectMode: true });
+    (0, stream_1.pipeline)([
+        inStream,
+        new tar_1.default.Parse({
+            filter(filePath, entry) {
+                if (entry.type !== 'File') {
+                    return false;
+                }
+                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;
+            },
+            async onentry(entry) {
+                const transforms = [
+                    // JSONL parser to read the data chunks one by one (line by line)
+                    (0, Parser_1.parser)({
+                        checkErrors: true,
+                    }),
+                    // The JSONL parser returns each line as key/value
+                    (line) => line.value,
+                ];
+                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 = 
+// 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,
+            // Custom backup archive parsing
+            new tar_1.default.Parse({
+                /**
+                 * Filter the parsed entries to only keep the one that matches the given filepath
+                 */
+                filter(entryPath, entry) {
+                    return !path_1.default.relative(filePath, entryPath).length && entry.type === 'File';
+                },
+                async onentry(entry) {
+                    // Collect all the content of the entry file
+                    const content = await entry.collect();
+                    try {
+                        // Parse from buffer to string to JSON
+                        const parsedContent = JSON.parse(content.toString());
+                        // Resolve the Promise with the parsed content
+                        resolve(parsedContent);
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                    finally {
+                        // Cleanup (close the stream associated to the entry)
+                        entry.destroy();
+                    }
+                },
+            }),
+        ], () => {
+            // If the promise hasn't been resolved and we've parsed all
+            // the archive entries, then the file doesn't exist
+            reject(new Error(`File "${filePath}" not found`));
+        });
+    });
+};
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * as engine from './engine';
+export * as strapi from './strapi';
+export * as file from './file';
+export * as utils from './utils';

package/lib/index.js

@@ -0,0 +1,31 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = exports.file = exports.strapi = exports.engine = void 0;
+exports.engine = __importStar(require("./engine"));
+exports.strapi = __importStar(require("./strapi"));
+exports.file = __importStar(require("./file"));
+exports.utils = __importStar(require("./utils"));
+//# sourceMappingURL=index.js.map

package/lib/strapi/index.d.ts

@@ -0,0 +1,3 @@
+export * as providers from './providers';
+export * as queries from './queries';
+export * as remote from './remote';

package/lib/strapi/index.js

@@ -0,0 +1,30 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remote = exports.queries = exports.providers = void 0;
+exports.providers = __importStar(require("./providers"));
+exports.queries = __importStar(require("./queries"));
+exports.remote = __importStar(require("./remote"));
+//# sourceMappingURL=index.js.map

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

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

package/lib/strapi/providers/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Local
+__exportStar(require("./local-destination"), exports);
+__exportStar(require("./local-source"), exports);
+// Remote
+__exportStar(require("./remote-destination"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,34 @@
+/// <reference types="lodash" />
+/// <reference types="node" />
+import { Writable } from 'stream';
+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";
+export interface ILocalStrapiDestinationProviderOptions {
+    getStrapi(): Strapi.Strapi | Promise<Strapi.Strapi>;
+    autoDestroy?: boolean;
+    restore?: restore.IRestoreOptions;
+    strategy: 'restore' | 'merge';
+}
+declare class LocalStrapiDestinationProvider implements IDestinationProvider {
+    #private;
+    name: string;
+    type: ProviderType;
+    options: ILocalStrapiDestinationProviderOptions;
+    strapi?: Strapi.Strapi;
+    transaction?: Transaction;
+    constructor(options: ILocalStrapiDestinationProviderOptions);
+    bootstrap(): Promise<void>;
+    close(): Promise<void>;
+    rollback(): Promise<void>;
+    beforeTransfer(): Promise<void>;
+    getMetadata(): IMetadata;
+    getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;
+    createEntitiesWriteStream(): Writable;
+    createAssetsWriteStream(): Promise<Writable>;
+    createConfigurationWriteStream(): Promise<Writable>;
+    createLinksWriteStream(): Promise<Writable>;
+}
+export declare const createLocalStrapiDestinationProvider: (options: ILocalStrapiDestinationProviderOptions) => LocalStrapiDestinationProvider;
+export {};

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

@@ -0,0 +1,220 @@
+"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 __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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _LocalStrapiDestinationProvider_instances, _LocalStrapiDestinationProvider_entitiesMapper, _LocalStrapiDestinationProvider_validateOptions, _LocalStrapiDestinationProvider_deleteAll;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalStrapiDestinationProvider = exports.DEFAULT_CONFLICT_STRATEGY = exports.VALID_CONFLICT_STRATEGIES = void 0;
+const stream_1 = require("stream");
+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 {
+    constructor(options) {
+        _LocalStrapiDestinationProvider_instances.add(this);
+        this.name = 'destination::local-strapi';
+        this.type = 'destination';
+        /**
+         * The entities mapper is used to map old entities to their new IDs
+         */
+        _LocalStrapiDestinationProvider_entitiesMapper.set(this, void 0);
+        this.options = options;
+        __classPrivateFieldSet(this, _LocalStrapiDestinationProvider_entitiesMapper, {}, "f");
+    }
+    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();
+        }
+    }
+    async rollback() {
+        await this.transaction?.rollback();
+    }
+    async beforeTransfer() {
+        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();
+        return {
+            createdAt,
+            strapi: {
+                version: strapiVersion,
+            },
+        };
+    }
+    getSchemas() {
+        (0, providers_2.assertValidStrapi)(this.strapi, 'Not able to get Schemas');
+        const schemas = {
+            ...this.strapi.contentTypes,
+            ...this.strapi.components,
+        };
+        return utils.schema.mapSchemasValues(schemas);
+    }
+    createEntitiesWriteStream() {
+        (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]) {
+                __classPrivateFieldGet(this, _LocalStrapiDestinationProvider_entitiesMapper, "f")[type] = {};
+            }
+            Object.assign(__classPrivateFieldGet(this, _LocalStrapiDestinationProvider_entitiesMapper, "f")[type], { [oldID]: newID });
+        };
+        if (strategy === 'restore') {
+            return strategies_1.restore.createEntitiesWriteStream({
+                strapi: this.strapi,
+                updateMappingTable,
+                transaction: this.transaction,
+            });
+        }
+        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() {
+        (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.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) {
+                await fse.rm(backupDirectory, { recursive: true, force: true });
+                next();
+            },
+            async write(chunk, _encoding, callback) {
+                const entryPath = path_1.default.join(assetsDirectory, chunk.filename);
+                const writableStream = fse.createWriteStream(entryPath);
+                chunk.stream
+                    .pipe(writableStream)
+                    .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.${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}`);
+                    }
+                    finally {
+                        callback(error);
+                    }
+                });
+            },
+        });
+    }
+    async createConfigurationWriteStream() {
+        (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, this.transaction);
+        }
+        throw new providers_1.ProviderValidationError(`Invalid strategy ${strategy}`, {
+            check: 'strategy',
+            strategy,
+            validStrategies: exports.VALID_CONFLICT_STRATEGIES,
+        });
+    }
+    async createLinksWriteStream() {
+        if (!this.strapi) {
+            throw new Error('Not able to stream links. Strapi instance not found');
+        }
+        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, this.transaction);
+        }
+        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 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() {
+    (0, providers_2.assertValidStrapi)(this.strapi);
+    return strategies_1.restore.deleteRecords(this.strapi, this.options.restore);
+};
+const createLocalStrapiDestinationProvider = (options) => {
+    return new LocalStrapiDestinationProvider(options);
+};
+exports.createLocalStrapiDestinationProvider = createLocalStrapiDestinationProvider;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+export * as restore from './restore';

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

@@ -0,0 +1,28 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restore = void 0;
+exports.restore = __importStar(require("./restore"));
+//# sourceMappingURL=index.js.map

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

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