@strapi/data-transfer 4.6.0-alpha.0 → 4.6.0-beta.2

package/lib/strapi/index.js

@@ -0,0 +1,35 @@
+"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 __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.providers = __importStar(require("./providers"));
+exports.queries = __importStar(require("./queries"));
+exports.remote = __importStar(require("./remote"));
+var register_1 = require("./register");
+Object.defineProperty(exports, "register", { enumerable: true, get: function () { return __importDefault(register_1).default; } });
+//# sourceMappingURL=index.js.map

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

@@ -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,32 @@
+/// <reference types="lodash" />
+/// <reference types="node" />
+import { Writable } from 'stream';
+import type { IDestinationProvider, IMetadata, ProviderType } 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;
+    constructor(options: ILocalStrapiDestinationProviderOptions);
+    bootstrap(): Promise<void>;
+    close(): 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,195 @@
+"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"));
+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();
+    }
+    async close() {
+        const { autoDestroy } = this.options;
+        // Basically `!== false` but more deterministic
+        if (autoDestroy === undefined || autoDestroy === true) {
+            await this.strapi?.destroy();
+        }
+    }
+    async beforeTransfer() {
+        if (this.options.strategy === 'restore') {
+            await __classPrivateFieldGet(this, _LocalStrapiDestinationProvider_instances, "m", _LocalStrapiDestinationProvider_deleteAll).call(this);
+        }
+    }
+    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');
+        }
+        const schemas = {
+            ...this.strapi.contentTypes,
+            ...this.strapi.components,
+        };
+        return utils.schema.mapSchemasValues(schemas);
+    }
+    createEntitiesWriteStream() {
+        if (!this.strapi) {
+            throw new Error('Not able to import entities. Strapi instance not found');
+        }
+        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,
+            });
+        }
+        throw new Error(`Invalid strategy supplied: "${strategy}"`);
+    }
+    // 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');
+        }
+        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.mkdir(assetsDirectory);
+        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)
+                    .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}`));
+                    }
+                    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}`);
+                    }
+                    finally {
+                        callback(error);
+                    }
+                });
+            },
+        });
+    }
+    async createConfigurationWriteStream() {
+        if (!this.strapi) {
+            throw new Error('Not able to stream Configurations. Strapi instance not found');
+        }
+        const { strategy } = this.options;
+        if (strategy === 'restore') {
+            return strategies_1.restore.createConfigurationWriteStream(this.strapi);
+        }
+        throw new Error(`Invalid strategy supplied: "${strategy}"`);
+    }
+    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);
+        }
+        throw new Error(`Invalid strategy supplied: "${strategy}"`);
+    }
+}
+_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}`);
+    }
+}, _LocalStrapiDestinationProvider_deleteAll = async function _LocalStrapiDestinationProvider_deleteAll() {
+    if (!this.strapi) {
+        throw new Error('Strapi instance not found');
+    }
+    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 } from '../../../../../../types';
+export declare const restoreConfigs: (strapi: Strapi.Strapi, config: IConfiguration) => Promise<any>;
+export declare const createConfigurationWriteStream: (strapi: Strapi.Strapi) => Promise<Writable>;

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

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigurationWriteStream = exports.restoreConfigs = void 0;
+const stream_1 = require("stream");
+const chalk_1 = __importDefault(require("chalk"));
+const restoreCoreStore = async (strapi, data) => {
+    return strapi.db.query('strapi::core-store').create({
+        data: {
+            ...data,
+            value: JSON.stringify(data.value),
+        },
+    });
+};
+const restoreWebhooks = async (strapi, data) => {
+    return strapi.db.query('webhook').create({ data });
+};
+const restoreConfigs = async (strapi, config) => {
+    if (config.type === 'core-store') {
+        return restoreCoreStore(strapi, config.value);
+    }
+    if (config.type === 'webhook') {
+        return restoreWebhooks(strapi, config.value);
+    }
+};
+exports.restoreConfigs = restoreConfigs;
+const createConfigurationWriteStream = async (strapi) => {
+    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();
+        },
+    });
+};
+exports.createConfigurationWriteStream = createConfigurationWriteStream;
+//# sourceMappingURL=configuration.js.map

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

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

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

@@ -0,0 +1,100 @@
+"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.createEntitiesWriteStream = void 0;
+const fp_1 = require("lodash/fp");
+const stream_1 = require("stream");
+const utils_1 = require("../../../../../utils");
+const queries = __importStar(require("../../../../queries"));
+const createEntitiesWriteStream = (options) => {
+    const { strapi, updateMappingTable } = 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);
+                        }
+                        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;
+                        }
+                        const [oldID, newID] = diff.values;
+                        updateMappingTable(target, oldID, newID);
+                    }
+                });
+            }
+            catch (e) {
+                if (e instanceof Error) {
+                    return callback(e);
+                }
+                return callback(new Error(`Failed to create "${type}" (${id})`));
+            }
+            return callback(null);
+        },
+    });
+};
+exports.createEntitiesWriteStream = createEntitiesWriteStream;
+//# sourceMappingURL=entities.js.map

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

@@ -0,0 +1,32 @@
+import type { ContentTypeSchema } from '@strapi/strapi';
+export interface IRestoreOptions {
+    assets?: boolean;
+    configuration?: {
+        webhook?: boolean;
+        coreStore?: boolean;
+    };
+    entities?: {
+        include?: string[];
+        exclude?: string[];
+        filters?: ((contentType: ContentTypeSchema) => boolean)[];
+        params?: {
+            [uid: string]: unknown;
+        };
+    };
+}
+interface IDeleteResults {
+    count: number;
+    aggregate: {
+        [uid: string]: {
+            count: number;
+        };
+    };
+}
+export declare const deleteRecords: (strapi: Strapi.Strapi, options?: IRestoreOptions | undefined) => Promise<{
+    count: number;
+    entities: IDeleteResults;
+    configuration: IDeleteResults;
+}>;
+export * from './entities';
+export * from './configuration';
+export * from './links';

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

@@ -0,0 +1,106 @@
+"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 __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 });
+exports.deleteRecords = void 0;
+const queries = __importStar(require("../../../../queries"));
+const deleteRecords = async (strapi, options) => {
+    const entities = await deleteEntitiesRecord(strapi, options);
+    const configuration = await deleteConfigurationRecords(strapi, options);
+    return {
+        count: entities.count + configuration.count,
+        entities,
+        configuration,
+    };
+};
+exports.deleteRecords = deleteRecords;
+const deleteEntitiesRecord = async (strapi, options = {}) => {
+    const { entities } = options;
+    const query = queries.entity.createEntityQuery(strapi);
+    const contentTypes = Object.values(strapi.contentTypes);
+    const contentTypesToClear = contentTypes.filter((contentType) => {
+        let keep = true;
+        if (entities?.include) {
+            keep = entities.include.includes(contentType.uid);
+        }
+        if (entities?.exclude) {
+            keep = !entities.exclude.includes(contentType.uid);
+        }
+        if (entities?.filters) {
+            keep = entities.filters.every((filter) => filter(contentType));
+        }
+        return keep;
+    });
+    const [results, updateResults] = useResults(contentTypesToClear.map((contentType) => contentType.uid));
+    const deletePromises = contentTypesToClear.map(async (contentType) => {
+        const result = await query(contentType.uid).deleteMany(entities?.params);
+        if (result) {
+            updateResults(result.count || 0, contentType.uid);
+        }
+    });
+    await Promise.all(deletePromises);
+    return results;
+};
+const deleteConfigurationRecords = async (strapi, options = {}) => {
+    const { coreStore = true, webhook = true } = options?.configuration ?? {};
+    const models = [];
+    if (coreStore) {
+        models.push('strapi::core-store');
+    }
+    if (webhook) {
+        models.push('webhook');
+    }
+    const [results, updateResults] = useResults(models);
+    const deletePromises = models.map(async (uid) => {
+        const result = await strapi.db.query(uid).deleteMany({});
+        if (result) {
+            updateResults(result.count, uid);
+        }
+    });
+    await Promise.all(deletePromises);
+    return results;
+};
+const useResults = (keys) => {
+    const results = {
+        count: 0,
+        aggregate: keys.reduce((acc, key) => ({ ...acc, [key]: { count: 0 } }), {}),
+    };
+    const update = (count, key) => {
+        if (key) {
+            if (!(key in results.aggregate)) {
+                throw new Error(`Unknown key "${key}" provided in results update`);
+            }
+            results.aggregate[key].count += count;
+        }
+        results.count += count;
+    };
+    return [results, update];
+};
+__exportStar(require("./entities"), exports);
+__exportStar(require("./configuration"), exports);
+__exportStar(require("./links"), exports);
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinksWriteStream = void 0;
+const stream_1 = require("stream");
+const link_1 = require("../../../../queries/link");
+const createLinksWriteStream = (mapID, strapi) => {
+    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);
+                }
+                return callback(new Error(`An error happened while trying to import a ${left.type} link. ${e}`));
+            }
+            callback(null);
+        },
+    });
+};
+exports.createLinksWriteStream = createLinksWriteStream;
+//# sourceMappingURL=links.js.map

package/lib/strapi/providers/local-source/assets.d.ts

@@ -0,0 +1,5 @@
+import { Duplex } from 'stream';
+/**
+ * Generate and consume assets streams in order to stream each file individually
+ */
+export declare const createAssetsStream: (strapi: Strapi.Strapi) => Duplex;