@strapi/data-transfer 4.6.0-beta.1 → 4.6.0

package/{dist/providers/local-strapi-destination-provider → lib/strapi/providers/local-destination}/index.js

@@ -43,7 +43,9 @@ 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 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 {
@@ -51,6 +53,9 @@ class LocalStrapiDestinationProvider {
         _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");
@@ -58,45 +63,54 @@ 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() {
-        await this.strapi?.destroy?.();
+        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,
         };
         return utils.schema.mapSchemasValues(schemas);
     }
-    getEntitiesStream() {
-        if (!this.strapi) {
-            throw new Error('Not able to import entities. Strapi instance not found');
-        }
+    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]) {
@@ -108,18 +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,
+        });
     }
-    async getAssetsStream() {
-        if (!this.strapi) {
-            throw new Error('Not able to stream Assets. Strapi instance not found');
-        }
+    // 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.rename(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) {
@@ -136,10 +156,10 @@ class LocalStrapiDestinationProvider {
                     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}`));
+                        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);
@@ -148,36 +168,44 @@ class LocalStrapiDestinationProvider {
             },
         });
     }
-    async getConfigurationStream() {
-        if (!this.strapi) {
-            throw new Error('Not able to stream Configurations. Strapi instance not found');
-        }
+    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);
+            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 getLinksStream() {
+    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);
+            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/{dist/providers/local-strapi-destination-provider → 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/{dist/providers/local-strapi-destination-provider → 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/{dist/providers/local-strapi-destination-provider → 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

@@ -0,0 +1,103 @@
+"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 providers_1 = require("../../../../../errors/providers");
+const utils_1 = require("../../../../../utils");
+const queries = __importStar(require("../../../../queries"));
+const createEntitiesWriteStream = (options) => {
+    const { strapi, updateMappingTable, transaction } = options;
+    const query = queries.entity.createEntityQuery(strapi);
+    return new stream_1.Writable({
+        objectMode: true,
+        async write(entity, _encoding, callback) {
+            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 (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 providers_1.ProviderTransferError(`Failed to create "${type}" (${id})`));
+                }
+                return callback(null);
+            });
+        },
+    });
+};
+exports.createEntitiesWriteStream = createEntitiesWriteStream;
+//# sourceMappingURL=entities.js.map

package/{dist/providers/local-strapi-destination-provider → lib/strapi/providers/local-destination}/strategies/restore/index.js

@@ -27,7 +27,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteRecords = void 0;
-const shared = __importStar(require("../../../shared"));
+const providers_1 = require("../../../../../errors/providers");
+const queries = __importStar(require("../../../../queries"));
 const deleteRecords = async (strapi, options) => {
     const entities = await deleteEntitiesRecord(strapi, options);
     const configuration = await deleteConfigurationRecords(strapi, options);
@@ -40,7 +41,7 @@ const deleteRecords = async (strapi, options) => {
 exports.deleteRecords = deleteRecords;
 const deleteEntitiesRecord = async (strapi, options = {}) => {
     const { entities } = options;
-    const query = shared.strapi.entity.createEntityQuery(strapi);
+    const query = queries.entity.createEntityQuery(strapi);
     const contentTypes = Object.values(strapi.contentTypes);
     const contentTypesToClear = contentTypes.filter((contentType) => {
         let keep = true;
@@ -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

@@ -0,0 +1,4 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+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

@@ -0,0 +1,32 @@
+"use strict";
+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, transaction) => {
+    return new stream_1.Writable({
+        objectMode: true,
+        async write(link, _encoding, callback) {
+            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);
+                }
+                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);
+            });
+        },
+    });
+};
+exports.createLinksWriteStream = createLinksWriteStream;
+//# sourceMappingURL=links.js.map

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/configuration.js

@@ -8,20 +8,19 @@ const fp_1 = require("lodash/fp");
  * Create a readable stream that export the Strapi app configuration
  */
 const createConfigurationStream = (strapi) => {
-    // Core Store
-    const coreStoreStream = (0, stream_chain_1.chain)([
-        strapi.db.queryBuilder('strapi::core-store').stream(),
-        (data) => (0, fp_1.set)('value', JSON.parse(data.value), data),
-        wrapConfigurationItem('core-store'),
-    ]);
-    // Webhook
-    const webhooksStream = (0, stream_chain_1.chain)([
-        strapi.db.queryBuilder('webhook').stream(),
-        wrapConfigurationItem('webhook'),
-    ]);
-    const streams = [coreStoreStream, webhooksStream];
-    // Readable configuration stream
     return stream_1.Readable.from((async function* configurationGenerator() {
+        // Core Store
+        const coreStoreStream = (0, stream_chain_1.chain)([
+            strapi.db.queryBuilder('strapi::core-store').stream(),
+            (data) => (0, fp_1.set)('value', JSON.parse(data.value), data),
+            wrapConfigurationItem('core-store'),
+        ]);
+        // Webhook
+        const webhooksStream = (0, stream_chain_1.chain)([
+            strapi.db.queryBuilder('webhook').stream(),
+            wrapConfigurationItem('webhook'),
+        ]);
+        const streams = [coreStoreStream, webhooksStream];
         for (const stream of streams) {
             for await (const item of stream) {
                 yield item;

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/entities.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEntitiesTransformStream = exports.createEntitiesStream = void 0;
 const stream_1 = require("stream");
-const shared = __importStar(require("../shared/strapi"));
+const shared = __importStar(require("../../queries"));
 /**
  * Generate and consume content-types streams in order to stream each entity individually
  */
@@ -48,10 +48,17 @@ const createEntitiesStream = (strapi) => {
     }
     return stream_1.Readable.from((async function* entitiesGenerator() {
         for await (const { stream, contentType } of contentTypeStreamGenerator()) {
-            for await (const entity of stream) {
-                yield { entity, contentType };
+            try {
+                for await (const entity of stream) {
+                    yield { entity, contentType };
+                }
+            }
+            catch {
+                // ignore
+            }
+            finally {
+                stream.destroy();
             }
-            stream.destroy();
         }
     })());
 };

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/index.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 /// <reference types="lodash" />
 import { Readable } from 'stream';
-import type { IMetadata, ISourceProvider, ProviderType } from '../../../types';
+import type { IMetadata, ISourceProvider, ProviderType } from '../../../../types';
 export interface ILocalStrapiSourceProviderOptions {
     getStrapi(): Strapi.Strapi | Promise<Strapi.Strapi>;
     autoDestroy?: boolean;
@@ -16,12 +16,12 @@ declare class LocalStrapiSourceProvider implements ISourceProvider {
     bootstrap(): Promise<void>;
     close(): Promise<void>;
     getMetadata(): IMetadata;
-    streamEntities(): Promise<Readable>;
-    streamLinks(): Readable;
-    streamConfiguration(): Readable;
+    createEntitiesReadStream(): Promise<Readable>;
+    createLinksReadStream(): Readable;
+    createConfigurationReadStream(): Readable;
     getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;
-    streamSchemas(): Readable;
-    streamAssets(): Readable;
+    createSchemasReadStream(): Readable;
+    createAssetsReadStream(): Readable;
 }
 export declare type ILocalStrapiSourceProvider = InstanceType<typeof LocalStrapiSourceProvider>;
 export {};

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/index.js

@@ -30,7 +30,8 @@ const entities_1 = require("./entities");
 const links_1 = require("./links");
 const configuration_1 = require("./configuration");
 const assets_1 = require("./assets");
-const utils = __importStar(require("../../utils"));
+const utils = __importStar(require("../../../utils"));
+const providers_1 = require("../../../utils/providers");
 const createLocalStrapiSourceProvider = (options) => {
     return new LocalStrapiSourceProvider(options);
 };
@@ -54,23 +55,15 @@ class LocalStrapiSourceProvider {
     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,
-                })),
             },
         };
     }
-    async streamEntities() {
-        if (!this.strapi) {
-            throw new Error('Not able to stream entities. Strapi instance not found');
-        }
+    async createEntitiesReadStream() {
+        (0, providers_1.assertValidStrapi)(this.strapi, 'Not able to stream entities');
         return (0, stream_chain_1.chain)([
             // Entities stream
             (0, entities_1.createEntitiesStream)(this.strapi),
@@ -78,35 +71,27 @@ class LocalStrapiSourceProvider {
             (0, entities_1.createEntitiesTransformStream)(),
         ]);
     }
-    streamLinks() {
-        if (!this.strapi) {
-            throw new Error('Not able to stream links. Strapi instance not found');
-        }
+    createLinksReadStream() {
+        (0, providers_1.assertValidStrapi)(this.strapi, 'Not able to stream links');
         return (0, links_1.createLinksStream)(this.strapi);
     }
-    streamConfiguration() {
-        if (!this.strapi) {
-            throw new Error('Not able to stream configuration. Strapi instance not found');
-        }
+    createConfigurationReadStream() {
+        (0, providers_1.assertValidStrapi)(this.strapi, 'Not able to stream configuration');
         return (0, configuration_1.createConfigurationStream)(strapi);
     }
     getSchemas() {
-        if (!this.strapi) {
-            throw new Error('Not able to get Schemas. Strapi instance not found');
-        }
+        (0, providers_1.assertValidStrapi)(this.strapi, 'Not able to get Schemas');
         const schemas = {
             ...this.strapi.contentTypes,
             ...this.strapi.components,
         };
         return utils.schema.mapSchemasValues(schemas);
     }
-    streamSchemas() {
+    createSchemasReadStream() {
         return stream_1.Readable.from(Object.values(this.getSchemas()));
     }
-    streamAssets() {
-        if (!this.strapi) {
-            throw new Error('Not able to stream assets. Strapi instance not found');
-        }
+    createAssetsReadStream() {
+        (0, providers_1.assertValidStrapi)(this.strapi, 'Not able to stream assets');
         return (0, assets_1.createAssetsStream)(this.strapi);
     }
 }

package/{dist/providers/local-strapi-source-provider → lib/strapi/providers/local-source}/links.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinksStream = void 0;
 const stream_1 = require("stream");
-const link_1 = require("../shared/strapi/link");
+const link_1 = require("../../queries/link");
 /**
  * Create a Readable which will stream all the links from a Strapi instance
  */