@strapi/data-transfer 4.7.0 → 4.7.1

package/dist/providers/local-file-destination-provider.js

@@ -0,0 +1,195 @@
+"use strict";
+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 _LocalFileDestinationProvider_instances, _LocalFileDestinationProvider_providersMetadata, _LocalFileDestinationProvider_archive, _LocalFileDestinationProvider_archivePath_get, _LocalFileDestinationProvider_getDataTransformers, _LocalFileDestinationProvider_writeMetadata, _LocalFileDestinationProvider_getMetadataStream;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalFileDestinationProvider = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const tar_stream_1 = __importDefault(require("tar-stream"));
+const zlib_1 = __importDefault(require("zlib"));
+const stream_1 = require("stream");
+const Stringer_1 = require("stream-json/jsonl/Stringer");
+const stream_chain_1 = require("stream-chain");
+const encrypt_1 = require("../encryption/encrypt");
+const createLocalFileDestinationProvider = (options) => {
+    return new LocalFileDestinationProvider(options);
+};
+exports.createLocalFileDestinationProvider = createLocalFileDestinationProvider;
+class LocalFileDestinationProvider {
+    constructor(options) {
+        _LocalFileDestinationProvider_instances.add(this);
+        this.name = 'destination::local-file';
+        this.type = 'destination';
+        this.results = {};
+        _LocalFileDestinationProvider_providersMetadata.set(this, {});
+        _LocalFileDestinationProvider_archive.set(this, {});
+        this.options = options;
+    }
+    setMetadata(target, metadata) {
+        __classPrivateFieldGet(this, _LocalFileDestinationProvider_providersMetadata, "f")[target] = metadata;
+        return this;
+    }
+    bootstrap() {
+        const { compression, encryption } = this.options;
+        if (encryption.enabled && !encryption.key) {
+            throw new Error("Can't encrypt without a key");
+        }
+        __classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream = tar_stream_1.default.pack();
+        const outStream = fs_extra_1.default.createWriteStream(__classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "a", _LocalFileDestinationProvider_archivePath_get));
+        const archiveTransforms = [];
+        if (compression.enabled) {
+            archiveTransforms.push(zlib_1.default.createGzip());
+        }
+        if (encryption.enabled && encryption.key) {
+            archiveTransforms.push((0, encrypt_1.createEncryptionCipher)(encryption.key));
+        }
+        __classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").pipeline = (0, stream_chain_1.chain)([__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, ...archiveTransforms, outStream]);
+        this.results.file = { path: __classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "a", _LocalFileDestinationProvider_archivePath_get) };
+    }
+    async close() {
+        const { stream, pipeline } = __classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f");
+        if (!stream) {
+            return;
+        }
+        await __classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "m", _LocalFileDestinationProvider_writeMetadata).call(this);
+        stream.finalize();
+        if (pipeline && !pipeline.closed) {
+            await new Promise((resolve, reject) => {
+                pipeline.on('close', resolve).on('error', reject);
+            });
+        }
+    }
+    async rollback() {
+        await this.close();
+        fs_extra_1.default.rmSync(__classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "a", _LocalFileDestinationProvider_archivePath_get), { force: true });
+    }
+    getMetadata() {
+        return null;
+    }
+    getSchemasStream() {
+        if (!__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream) {
+            throw new Error('Archive stream is unavailable');
+        }
+        const filePathFactory = createFilePathFactory('schemas');
+        const entryStream = createTarEntryStream(__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, filePathFactory, this.options.file.maxSize);
+        return (0, stream_chain_1.chain)([(0, Stringer_1.stringer)(), entryStream]);
+    }
+    getEntitiesStream() {
+        if (!__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream) {
+            throw new Error('Archive stream is unavailable');
+        }
+        const filePathFactory = createFilePathFactory('entities');
+        const entryStream = createTarEntryStream(__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, filePathFactory, this.options.file.maxSize);
+        return (0, stream_chain_1.chain)([(0, Stringer_1.stringer)(), entryStream]);
+    }
+    getLinksStream() {
+        if (!__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream) {
+            throw new Error('Archive stream is unavailable');
+        }
+        const filePathFactory = createFilePathFactory('links');
+        const entryStream = createTarEntryStream(__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, filePathFactory, this.options.file.maxSize);
+        return (0, stream_chain_1.chain)([(0, Stringer_1.stringer)(), entryStream]);
+    }
+    getConfigurationStream() {
+        if (!__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream) {
+            throw new Error('Archive stream is unavailable');
+        }
+        const filePathFactory = createFilePathFactory('configuration');
+        const entryStream = createTarEntryStream(__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, filePathFactory, this.options.file.maxSize);
+        return (0, stream_chain_1.chain)([(0, Stringer_1.stringer)(), entryStream]);
+    }
+}
+_LocalFileDestinationProvider_providersMetadata = new WeakMap(), _LocalFileDestinationProvider_archive = new WeakMap(), _LocalFileDestinationProvider_instances = new WeakSet(), _LocalFileDestinationProvider_archivePath_get = function _LocalFileDestinationProvider_archivePath_get() {
+    const { encryption, compression, file } = this.options;
+    let path = `${file.path}.tar`;
+    if (compression.enabled) {
+        path += '.gz';
+    }
+    if (encryption.enabled) {
+        path += '.enc';
+    }
+    return path;
+}, _LocalFileDestinationProvider_getDataTransformers = function _LocalFileDestinationProvider_getDataTransformers(options = {}) {
+    const { jsonl = true } = options;
+    const transforms = [];
+    if (jsonl) {
+        // Convert to stringified JSON lines
+        transforms.push((0, Stringer_1.stringer)());
+    }
+    return transforms;
+}, _LocalFileDestinationProvider_writeMetadata = async function _LocalFileDestinationProvider_writeMetadata() {
+    const metadata = __classPrivateFieldGet(this, _LocalFileDestinationProvider_providersMetadata, "f").source;
+    if (metadata) {
+        await new Promise((resolve) => {
+            const outStream = __classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "m", _LocalFileDestinationProvider_getMetadataStream).call(this);
+            const data = JSON.stringify(metadata, null, 2);
+            stream_1.Readable.from(data).pipe(outStream).on('close', resolve);
+        });
+    }
+}, _LocalFileDestinationProvider_getMetadataStream = function _LocalFileDestinationProvider_getMetadataStream() {
+    const { stream } = __classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f");
+    if (!stream) {
+        throw new Error('Archive stream is unavailable');
+    }
+    return createTarEntryStream(stream, () => 'metadata.json');
+};
+/**
+ * Create a file path factory for a given path & prefix.
+ * Upon being called, the factory will return a file path for a given index
+ */
+const createFilePathFactory = (type) => (fileIndex = 0) => {
+    return path_1.default.join(
+    // "{type}" directory
+    type, 
+    // "${type}_XXXXX.jsonl" file
+    `${type}_${String(fileIndex).padStart(5, '0')}.jsonl`);
+};
+const createTarEntryStream = (archive, pathFactory, maxSize = 2.56e8) => {
+    let fileIndex = 0;
+    let buffer = '';
+    const flush = async () => {
+        if (!buffer) {
+            return;
+        }
+        const name = pathFactory(fileIndex++);
+        const size = buffer.length;
+        await new Promise((resolve, reject) => {
+            archive.entry({ name, size }, buffer, (err) => {
+                if (err) {
+                    reject(err);
+                }
+                resolve();
+            });
+        });
+        buffer = '';
+    };
+    const push = (chunk) => {
+        buffer += chunk;
+    };
+    return new stream_1.Writable({
+        async destroy(err, callback) {
+            await flush();
+            callback(err);
+        },
+        async write(chunk, _encoding, callback) {
+            const size = chunk.length;
+            if (chunk.length > maxSize) {
+                callback(new Error(`payload too large: ${chunk.length}>${maxSize}`));
+                return;
+            }
+            if (buffer.length + size > maxSize) {
+                await flush();
+            }
+            push(chunk);
+            callback(null);
+        },
+    });
+};
+//# sourceMappingURL=local-file-destination-provider.js.map

package/dist/providers/local-file-source-provider.d.ts

@@ -0,0 +1,43 @@
+/// <reference types="lodash" />
+/// <reference types="node" />
+import type { IMetadata, ISourceProvider, ProviderType } from '../../types';
+/**
+ * Provider options
+ */
+export interface ILocalFileSourceProviderOptions {
+    /**
+     * Path to the backup archive
+     */
+    backupFilePath: string;
+    /**
+     * Whether the backup data is encrypted or not
+     */
+    encrypted?: boolean;
+    /**
+     * Encryption key used to decrypt the encrypted data (if necessary)
+     */
+    encryptionKey?: string;
+    /**
+     * Whether the backup data is compressed or not
+     */
+    compressed?: boolean;
+}
+export declare const createLocalFileSourceProvider: (options: ILocalFileSourceProviderOptions) => LocalFileSourceProvider;
+declare class LocalFileSourceProvider implements ISourceProvider {
+    #private;
+    type: ProviderType;
+    name: string;
+    options: ILocalFileSourceProviderOptions;
+    constructor(options: ILocalFileSourceProviderOptions);
+    /**
+     * Pre flight checks regarding the provided options (making sure that the provided path is correct, etc...)
+     */
+    bootstrap(): void;
+    getMetadata(): Promise<IMetadata>;
+    getSchemas(): Promise<import("lodash").Dictionary<unknown>>;
+    streamEntities(): NodeJS.ReadableStream;
+    streamSchemas(): NodeJS.ReadableStream | Promise<NodeJS.ReadableStream>;
+    streamLinks(): NodeJS.ReadableStream;
+    streamConfiguration(): NodeJS.ReadableStream;
+}
+export {};

package/dist/providers/local-file-source-provider.js

@@ -0,0 +1,162 @@
+"use strict";
+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_getBackupStream, _LocalFileSourceProvider_streamJsonlDirectory, _LocalFileSourceProvider_parseJSONFile;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalFileSourceProvider = void 0;
+const fs_1 = __importDefault(require("fs"));
+const zlib_1 = __importDefault(require("zlib"));
+const tar_1 = __importDefault(require("tar"));
+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("../encryption");
+const utils_1 = require("../utils");
+/**
+ * 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';
+        this.options = options;
+        if (this.options.encrypted && this.options.encryptionKey === undefined) {
+            throw new Error('Missing encryption key');
+        }
+    }
+    /**
+     * Pre flight checks regarding the provided options (making sure that the provided path is correct, etc...)
+     */
+    bootstrap() {
+        const path = this.options.backupFilePath;
+        const isValidBackupPath = fs_1.default.existsSync(path);
+        // Check if the provided path exists
+        if (!isValidBackupPath) {
+            throw new Error(`Invalid backup file path provided. "${path}" does not exist on the filesystem.`);
+        }
+    }
+    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, utils_1.collect)(this.streamSchemas());
+        return (0, fp_1.keyBy)('uid', schemas);
+    }
+    streamEntities() {
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'entities');
+    }
+    streamSchemas() {
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'schemas');
+    }
+    streamLinks() {
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'links');
+    }
+    streamConfiguration() {
+        // NOTE: TBD
+        return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'configuration');
+    }
+}
+_LocalFileSourceProvider_instances = new WeakSet(), _LocalFileSourceProvider_getBackupStream = function _LocalFileSourceProvider_getBackupStream(decompress = true) {
+    const path = this.options.backupFilePath;
+    const readStream = fs_1.default.createReadStream(path);
+    const streams = [readStream];
+    // Handle decompression
+    if (decompress) {
+        streams.push(zlib_1.default.createGunzip());
+    }
+    return (0, stream_chain_1.chain)(streams);
+}, _LocalFileSourceProvider_streamJsonlDirectory = function _LocalFileSourceProvider_streamJsonlDirectory(directory) {
+    const options = this.options;
+    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(path, entry) {
+                if (entry.type !== 'File') {
+                    return false;
+                }
+                const parts = path.split('/');
+                if (parts.length !== 2) {
+                    return false;
+                }
+                return parts[0] === directory;
+            },
+            onentry(entry) {
+                const transforms = [];
+                if (options.encrypted) {
+                    transforms.push((0, encryption_1.createDecryptionCipher)(options.encryptionKey));
+                }
+                if (options.compressed) {
+                    transforms.push(zlib_1.default.createGunzip());
+                }
+                transforms.push(
+                // JSONL parser to read the data chunks one by one (line by line)
+                (0, Parser_1.parser)(), 
+                // 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 });
+            },
+        }),
+    ], () => {
+        // 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) {
+    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(path, entry) {
+                    return path === filePath && entry.type === 'File';
+                },
+                /**
+                 * Whenever an entry passes the filter method, process it
+                 */
+                async onentry(entry) {
+                    // Collect all the content of the entry file
+                    const content = await entry.collect();
+                    // Parse from buffer to string to JSON
+                    const parsedContent = JSON.parse(content.toString());
+                    // Resolve the Promise with the parsed content
+                    resolve(parsedContent);
+                    // 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(`${filePath} not found in the archive stream`);
+        });
+    });
+};
+//# sourceMappingURL=local-file-source-provider.js.map

package/dist/providers/local-strapi-destination-provider.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { IDestinationProvider, IMetadata, ProviderType } from '../../types';
+import { Duplex } from 'stream';
+interface ILocalStrapiDestinationProviderOptions {
+    getStrapi(): Promise<Strapi.Strapi>;
+}
+export declare const createLocalStrapiDestinationProvider: (options: ILocalStrapiDestinationProviderOptions) => LocalStrapiDestinationProvider;
+declare class LocalStrapiDestinationProvider implements IDestinationProvider {
+    name: string;
+    type: ProviderType;
+    options: ILocalStrapiDestinationProviderOptions;
+    strapi?: Strapi.Strapi;
+    constructor(options: ILocalStrapiDestinationProviderOptions);
+    bootstrap(): Promise<void>;
+    close(): Promise<void>;
+    getMetadata(): IMetadata | Promise<IMetadata>;
+    getSchemas(): {
+        [x: string]: Partial<any>;
+    };
+    getEntitiesStream(): Duplex;
+}
+export {};

package/dist/providers/local-strapi-destination-provider.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalStrapiDestinationProvider = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const stream_1 = require("stream");
+const utils_1 = require("../utils");
+// TODO: getting some type errors with @strapi/logger that need to be resolved first
+// const log = createLogger();
+const log = console;
+const createLocalStrapiDestinationProvider = (options) => {
+    return new LocalStrapiDestinationProvider(options);
+};
+exports.createLocalStrapiDestinationProvider = createLocalStrapiDestinationProvider;
+class LocalStrapiDestinationProvider {
+    constructor(options) {
+        this.name = 'destination::local-strapi';
+        this.type = 'destination';
+        this.options = options;
+    }
+    async bootstrap() {
+        this.strapi = await this.options.getStrapi();
+    }
+    async close() {
+        await this.strapi?.destroy?.();
+    }
+    // TODO
+    getMetadata() {
+        return {};
+    }
+    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 (0, utils_1.mapSchemasValues)(schemas);
+    }
+    getEntitiesStream() {
+        const self = this;
+        return new stream_1.Duplex({
+            objectMode: true,
+            async write(entity, _encoding, callback) {
+                if (!self.strapi) {
+                    callback(new Error('Strapi instance not found'));
+                }
+                const { type: uid, id, data } = entity;
+                try {
+                    await strapi.entityService.create(uid, { data });
+                }
+                catch (e) {
+                    // TODO: remove "any" cast
+                    log.warn(chalk_1.default.bold(`Failed to import ${chalk_1.default.yellowBright(uid)} (${chalk_1.default.greenBright(id)})`));
+                    e.details.errors
+                        .map((err, i) => {
+                        // TODO: add correct error type
+                        const info = {
+                            uid: chalk_1.default.yellowBright(`[${uid}]`),
+                            path: chalk_1.default.blueBright(`[${err.path.join('.')}]`),
+                            id: chalk_1.default.greenBright(`[${id}]`),
+                            message: err.message,
+                        };
+                        return `(${i}) ${info.uid}${info.id}${info.path}: ${info.message}`;
+                    })
+                        .forEach((message) => log.warn(message));
+                }
+                finally {
+                    callback();
+                }
+            },
+        });
+    }
+}
+//# sourceMappingURL=local-strapi-destination-provider.js.map

package/dist/providers/local-strapi-source-provider/configuration.d.ts

@@ -0,0 +1,5 @@
+import { Readable } from 'stream';
+/**
+ * Create a readable stream that export the Strapi app configuration
+ */
+export declare const createConfigurationStream: (strapi: Strapi.Strapi) => Readable;

package/dist/providers/local-strapi-source-provider/configuration.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigurationStream = void 0;
+const stream_chain_1 = require("stream-chain");
+const stream_1 = require("stream");
+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* () {
+        for (const stream of streams) {
+            for await (const item of stream) {
+                yield item;
+            }
+        }
+    })());
+};
+exports.createConfigurationStream = createConfigurationStream;
+const wrapConfigurationItem = (type) => (value) => ({
+    type,
+    value,
+});
+//# sourceMappingURL=configuration.js.map

package/dist/providers/local-strapi-source-provider/entities.d.ts

@@ -0,0 +1,10 @@
+import { Readable, PassThrough } from 'stream';
+/**
+ * Generate and consume content-types streams in order to stream each entity individually
+ */
+export declare const createEntitiesStream: (strapi: Strapi.Strapi) => Readable;
+/**
+ * Create an entity transform stream which convert the output of
+ * the multi-content-types stream to the transfer entity format
+ */
+export declare const createEntitiesTransformStream: () => PassThrough;

package/dist/providers/local-strapi-source-provider/entities.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEntitiesTransformStream = exports.createEntitiesStream = void 0;
+const stream_1 = require("stream");
+/**
+ * Generate and consume content-types streams in order to stream each entity individually
+ */
+const createEntitiesStream = (strapi) => {
+    const contentTypes = Object.values(strapi.contentTypes);
+    async function* contentTypeStreamGenerator() {
+        for (const contentType of contentTypes) {
+            const stream = strapi.db
+                // Create a query builder instance (default type is 'select')
+                .queryBuilder(contentType.uid)
+                // Apply the populate
+                .populate(getPopulateAttributes(contentType))
+                // Get a readable stream
+                .stream();
+            yield { contentType, stream };
+        }
+    }
+    return stream_1.Readable.from((async function* () {
+        for await (const { stream, contentType } of contentTypeStreamGenerator()) {
+            for await (const entity of stream) {
+                yield { entity, contentType };
+            }
+            stream.destroy();
+        }
+    })());
+};
+exports.createEntitiesStream = createEntitiesStream;
+/**
+ * Create an entity transform stream which convert the output of
+ * the multi-content-types stream to the transfer entity format
+ */
+const createEntitiesTransformStream = () => {
+    return new stream_1.PassThrough({
+        objectMode: true,
+        transform(data, _encoding, callback) {
+            const { entity, contentType } = data;
+            const { id, ...attributes } = entity;
+            callback(null, {
+                type: contentType.uid,
+                id,
+                data: attributes,
+            });
+        },
+    });
+};
+exports.createEntitiesTransformStream = createEntitiesTransformStream;
+/**
+ * Get the list of attributes that needs to be populated for the entities streaming
+ */
+const getPopulateAttributes = (contentType) => {
+    const { attributes } = contentType;
+    return Object.keys(attributes).filter((key) => ['component', 'dynamiczone'].includes(attributes[key].type));
+};
+//# sourceMappingURL=entities.js.map

package/dist/providers/local-strapi-source-provider/index.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import type { IMetadata, ISourceProvider, ProviderType } from '../../../types';
+export interface ILocalStrapiSourceProviderOptions {
+    getStrapi(): Strapi.Strapi | Promise<Strapi.Strapi>;
+    autoDestroy?: boolean;
+}
+export declare const createLocalStrapiSourceProvider: (options: ILocalStrapiSourceProviderOptions) => LocalStrapiSourceProvider;
+declare class LocalStrapiSourceProvider implements ISourceProvider {
+    name: string;
+    type: ProviderType;
+    options: ILocalStrapiSourceProviderOptions;
+    strapi?: Strapi.Strapi;
+    constructor(options: ILocalStrapiSourceProviderOptions);
+    bootstrap(): Promise<void>;
+    close(): Promise<void>;
+    getMetadata(): IMetadata;
+    streamEntities(): Promise<NodeJS.ReadableStream>;
+    streamLinks(): NodeJS.ReadableStream;
+    streamConfiguration(): NodeJS.ReadableStream;
+    getSchemas(): {
+        [x: string]: Partial<any>;
+    };
+    streamSchemas(): NodeJS.ReadableStream;
+}
+export declare type ILocalStrapiSourceProvider = InstanceType<typeof LocalStrapiSourceProvider>;
+export {};