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

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

@@ -7,17 +7,18 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 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;
+var _LocalFileDestinationProvider_instances, _LocalFileDestinationProvider_providersMetadata, _LocalFileDestinationProvider_archive, _LocalFileDestinationProvider_archivePath_get, _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 fs_extra_1 = require("fs-extra");
 const tar_stream_1 = __importDefault(require("tar-stream"));
+const path_1 = __importDefault(require("path"));
 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 stream_1 = require("stream");
+const encrypt_1 = require("../../encryption/encrypt");
+const utils_1 = require("./utils");
 const createLocalFileDestinationProvider = (options) => {
     return new LocalFileDestinationProvider(options);
 };
@@ -36,16 +37,19 @@ class LocalFileDestinationProvider {
         __classPrivateFieldGet(this, _LocalFileDestinationProvider_providersMetadata, "f")[target] = metadata;
         return this;
     }
+    createGzip() {
+        return zlib_1.default.createGzip();
+    }
     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 outStream = (0, fs_extra_1.createWriteStream)(__classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "a", _LocalFileDestinationProvider_archivePath_get));
         const archiveTransforms = [];
         if (compression.enabled) {
-            archiveTransforms.push(zlib_1.default.createGzip());
+            archiveTransforms.push(this.createGzip());
         }
         if (encryption.enabled && encryption.key) {
             archiveTransforms.push((0, encrypt_1.createEncryptionCipher)(encryption.key));
@@ -68,7 +72,7 @@ class LocalFileDestinationProvider {
     }
     async rollback() {
         await this.close();
-        fs_extra_1.default.rmSync(__classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "a", _LocalFileDestinationProvider_archivePath_get), { force: true });
+        await (0, fs_extra_1.rm)(__classPrivateFieldGet(this, _LocalFileDestinationProvider_instances, "a", _LocalFileDestinationProvider_archivePath_get), { force: true });
     }
     getMetadata() {
         return null;
@@ -77,53 +81,73 @@ class LocalFileDestinationProvider {
         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);
+        const filePathFactory = (0, utils_1.createFilePathFactory)('schemas');
+        const entryStream = (0, utils_1.createTarEntryStream)(__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, filePathFactory, this.options.file.maxSizeJsonl);
         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);
+        const filePathFactory = (0, utils_1.createFilePathFactory)('entities');
+        const entryStream = (0, utils_1.createTarEntryStream)(__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, filePathFactory, this.options.file.maxSizeJsonl);
         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);
+        const filePathFactory = (0, utils_1.createFilePathFactory)('links');
+        const entryStream = (0, utils_1.createTarEntryStream)(__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, filePathFactory, this.options.file.maxSizeJsonl);
         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);
+        const filePathFactory = (0, utils_1.createFilePathFactory)('configuration');
+        const entryStream = (0, utils_1.createTarEntryStream)(__classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f").stream, filePathFactory, this.options.file.maxSizeJsonl);
         return (0, stream_chain_1.chain)([(0, Stringer_1.stringer)(), entryStream]);
     }
+    getAssetsStream() {
+        const { stream: archiveStream } = __classPrivateFieldGet(this, _LocalFileDestinationProvider_archive, "f");
+        if (!archiveStream) {
+            throw new Error('Archive stream is unavailable');
+        }
+        return new stream_1.Writable({
+            objectMode: true,
+            write(data, _encoding, callback) {
+                const entryPath = path_1.default.join('assets', 'uploads', data.filename);
+                const entry = archiveStream.entry({
+                    name: entryPath,
+                    size: data.stats.size,
+                });
+                if (!entry) {
+                    callback(new Error(`Failed to created a tar entry for ${entryPath}`));
+                    return;
+                }
+                data.stream.pipe(entry);
+                entry
+                    .on('finish', () => {
+                    callback(null);
+                })
+                    .on('error', (error) => {
+                    callback(error);
+                });
+            },
+        });
+    }
 }
 _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`;
+    let filePath = `${file.path}.tar`;
     if (compression.enabled) {
-        path += '.gz';
+        filePath += '.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)());
+        filePath += '.enc';
     }
-    return transforms;
+    return filePath;
 }, _LocalFileDestinationProvider_writeMetadata = async function _LocalFileDestinationProvider_writeMetadata() {
     const metadata = __classPrivateFieldGet(this, _LocalFileDestinationProvider_providersMetadata, "f").source;
     if (metadata) {
@@ -138,58 +162,6 @@ _LocalFileDestinationProvider_providersMetadata = new WeakMap(), _LocalFileDesti
     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);
-        },
-    });
+    return (0, utils_1.createTarEntryStream)(stream, () => 'metadata.json');
 };
-//# sourceMappingURL=local-file-destination-provider.js.map
+//# sourceMappingURL=index.js.map

package/dist/providers/local-file-destination-provider/utils.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Writable } from 'stream';
+import tar from 'tar-stream';
+/**
+ * Create a file path factory for a given path & prefix.
+ * Upon being called, the factory will return a file path for a given index
+ */
+export declare const createFilePathFactory: (type: string) => (fileIndex?: number) => string;
+export declare const createTarEntryStream: (archive: tar.Pack, pathFactory: (index?: number | undefined) => string, maxSize?: number) => Writable;

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

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTarEntryStream = exports.createFilePathFactory = void 0;
+const stream_1 = require("stream");
+const path_1 = require("path");
+/**
+ * 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 (0, path_1.join)(
+    // "{type}" directory
+    type, 
+    // "${type}_XXXXX.jsonl" file
+    `${type}_${String(fileIndex).padStart(5, '0')}.jsonl`);
+};
+exports.createFilePathFactory = createFilePathFactory;
+const createTarEntryStream = (archive, pathFactory, maxSize = 2.56e8) => {
+    let fileIndex = 0;
+    let buffer = '';
+    const flush = async () => {
+        if (!buffer) {
+            return;
+        }
+        fileIndex += 1;
+        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);
+        },
+    });
+};
+exports.createTarEntryStream = createTarEntryStream;
+//# sourceMappingURL=utils.js.map

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

@@ -1,26 +1,21 @@
 /// <reference types="lodash" />
 /// <reference types="node" />
-import type { IMetadata, ISourceProvider, ProviderType } from '../../types';
+import type { Readable } from 'stream';
+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;
+    file: {
+        path: string;
+    };
+    encryption: {
+        enabled: boolean;
+        key?: string;
+    };
+    compression: {
+        enabled: boolean;
+    };
 }
 export declare const createLocalFileSourceProvider: (options: ILocalFileSourceProviderOptions) => LocalFileSourceProvider;
 declare class LocalFileSourceProvider implements ISourceProvider {
@@ -32,12 +27,13 @@ declare class LocalFileSourceProvider implements ISourceProvider {
     /**
      * Pre flight checks regarding the provided options (making sure that the provided path is correct, etc...)
      */
-    bootstrap(): void;
+    bootstrap(): Promise<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;
+    streamEntities(): Readable;
+    streamSchemas(): Readable;
+    streamLinks(): Readable;
+    streamConfiguration(): Readable;
+    streamAssets(): Readable | Promise<Readable>;
 }
 export {};

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

@@ -1,4 +1,27 @@
 "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 __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");
@@ -10,15 +33,16 @@ var __importDefault = (this && this.__importDefault) || function (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 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("../encryption");
-const utils_1 = require("../utils");
+const encryption_1 = require("../../encryption");
+const utils = __importStar(require("../../utils"));
 /**
  * Constant for the metadata file path
  */
@@ -33,19 +57,22 @@ class LocalFileSourceProvider {
         this.type = 'source';
         this.name = 'source::local-file';
         this.options = options;
-        if (this.options.encrypted && this.options.encryptionKey === undefined) {
+        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 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.`);
+    async bootstrap() {
+        const { path: filePath } = this.options.file;
+        try {
+            // This is only to show a nicer error, it doesn't ensure the file will still exist when we try to open it later
+            await fs_extra_1.default.access(filePath, fs_extra_1.default.constants.R_OK);
+        }
+        catch (e) {
+            throw new Error(`Can't access file "${filePath}".`);
         }
     }
     getMetadata() {
@@ -55,7 +82,7 @@ class LocalFileSourceProvider {
         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());
+        const schemas = await utils.stream.collect(this.streamSchemas());
         return (0, fp_1.keyBy)('uid', schemas);
     }
     streamEntities() {
@@ -71,46 +98,74 @@ class LocalFileSourceProvider {
         // NOTE: TBD
         return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'configuration');
     }
+    streamAssets() {
+        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_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) {
+_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 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) {
+            filter(filePath, entry) {
                 if (entry.type !== 'File') {
                     return false;
                 }
-                const parts = path.split('/');
+                const parts = filePath.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);
+                const transforms = [
+                    // 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))
@@ -135,8 +190,8 @@ _LocalFileSourceProvider_instances = new WeakSet(), _LocalFileSourceProvider_get
                 /**
                  * Filter the parsed entries to only keep the one that matches the given filepath
                  */
-                filter(path, entry) {
-                    return path === filePath && entry.type === 'File';
+                filter(entryPath, entry) {
+                    return entryPath === filePath && entry.type === 'File';
                 },
                 /**
                  * Whenever an entry passes the filter method, process it
@@ -155,8 +210,8 @@ _LocalFileSourceProvider_instances = new WeakSet(), _LocalFileSourceProvider_get
         ], () => {
             // 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`);
+            reject(new Error(`File "${filePath}" not found`));
         });
     });
 };
-//# sourceMappingURL=local-file-source-provider.js.map
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,31 @@
+/// <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";
+interface ILocalStrapiDestinationProviderOptions {
+    getStrapi(): Strapi.Strapi | Promise<Strapi.Strapi>;
+    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 | Promise<IMetadata>;
+    getSchemas(): import("lodash").Dictionary<Partial<import("@strapi/strapi").Schema>>;
+    getEntitiesStream(): Writable;
+    getAssetsStream(): Promise<Writable>;
+    getConfigurationStream(): Promise<Writable>;
+    getLinksStream(): Promise<Writable>;
+}
+export declare const createLocalStrapiDestinationProvider: (options: ILocalStrapiDestinationProviderOptions) => LocalStrapiDestinationProvider;
+export {};