@strapi/data-transfer 4.7.0 → 4.7.1

package/dist/encryption/decrypt.d.ts

@@ -0,0 +1,3 @@
+import { Cipher } from 'crypto';
+import { Algorithm } from '../../types';
+export declare const createDecryptionCipher: (key: string, algorithm?: Algorithm) => Cipher;

package/dist/encryption/decrypt.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecryptionCipher = void 0;
+const crypto_1 = require("crypto");
+// different key values depending on algorithm chosen
+const getDecryptionStrategy = (algorithm) => {
+    const strategies = {
+        'aes-128-ecb': (key) => {
+            const hashedKey = (0, crypto_1.scryptSync)(key, '', 16);
+            const initVector = null;
+            const securityKey = hashedKey;
+            return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
+        },
+        aes128: (key) => {
+            const hashedKey = (0, crypto_1.scryptSync)(key, '', 32);
+            const initVector = hashedKey.slice(16);
+            const securityKey = hashedKey.slice(0, 16);
+            return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
+        },
+        aes192: (key) => {
+            const hashedKey = (0, crypto_1.scryptSync)(key, '', 40);
+            const initVector = hashedKey.slice(24);
+            const securityKey = hashedKey.slice(0, 24);
+            return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
+        },
+        aes256: (key) => {
+            const hashedKey = (0, crypto_1.scryptSync)(key, '', 48);
+            const initVector = hashedKey.slice(32);
+            const securityKey = hashedKey.slice(0, 32);
+            return (0, crypto_1.createDecipheriv)(algorithm, securityKey, initVector);
+        },
+    };
+    return strategies[algorithm];
+};
+const createDecryptionCipher = (key, algorithm = 'aes-128-ecb') => {
+    return getDecryptionStrategy(algorithm)(key);
+};
+exports.createDecryptionCipher = createDecryptionCipher;
+//# sourceMappingURL=decrypt.js.map

package/dist/encryption/encrypt.d.ts

@@ -0,0 +1,3 @@
+import { Cipher } from 'crypto';
+import { Algorithm } from '../../types';
+export declare const createEncryptionCipher: (key: string, algorithm?: Algorithm) => Cipher;

package/dist/encryption/encrypt.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEncryptionCipher = void 0;
+const crypto_1 = require("crypto");
+// different key values depending on algorithm chosen
+const getEncryptionStrategy = (algorithm) => {
+    const strategies = {
+        'aes-128-ecb': (key) => {
+            const hashedKey = (0, crypto_1.scryptSync)(key, '', 16);
+            const initVector = null;
+            const securityKey = hashedKey;
+            return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
+        },
+        aes128: (key) => {
+            const hashedKey = (0, crypto_1.scryptSync)(key, '', 32);
+            const initVector = hashedKey.slice(16);
+            const securityKey = hashedKey.slice(0, 16);
+            return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
+        },
+        aes192: (key) => {
+            const hashedKey = (0, crypto_1.scryptSync)(key, '', 40);
+            const initVector = hashedKey.slice(24);
+            const securityKey = hashedKey.slice(0, 24);
+            return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
+        },
+        aes256: (key) => {
+            const hashedKey = (0, crypto_1.scryptSync)(key, '', 48);
+            const initVector = hashedKey.slice(32);
+            const securityKey = hashedKey.slice(0, 32);
+            return (0, crypto_1.createCipheriv)(algorithm, securityKey, initVector);
+        },
+    };
+    return strategies[algorithm];
+};
+const createEncryptionCipher = (key, algorithm = 'aes-128-ecb') => {
+    return getEncryptionStrategy(algorithm)(key);
+};
+exports.createEncryptionCipher = createEncryptionCipher;
+//# sourceMappingURL=encrypt.js.map

package/dist/encryption/index.d.ts

@@ -0,0 +1,2 @@
+export * from './encrypt';
+export * from './decrypt';

package/dist/encryption/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./encrypt"), exports);
+__exportStar(require("./decrypt"), exports);
+//# sourceMappingURL=index.js.map

package/dist/engine/index.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { PassThrough } from 'stream-chain';
+import type { IDestinationProvider, ISourceProvider, ITransferEngine, ITransferEngineOptions, ITransferResults } from '../../types';
+declare type TransferEngineProgress = {
+    data: any;
+    stream: PassThrough;
+};
+export declare const VALID_STRATEGIES: string[];
+declare class TransferEngine<S extends ISourceProvider = ISourceProvider, D extends IDestinationProvider = IDestinationProvider> implements ITransferEngine {
+    #private;
+    sourceProvider: ISourceProvider;
+    destinationProvider: IDestinationProvider;
+    options: ITransferEngineOptions;
+    get progress(): TransferEngineProgress;
+    constructor(sourceProvider: ISourceProvider, destinationProvider: IDestinationProvider, options: ITransferEngineOptions);
+    init(): Promise<void>;
+    bootstrap(): Promise<void>;
+    close(): Promise<void>;
+    integrityCheck(): Promise<boolean>;
+    validateTransferOptions(): void;
+    transfer(): Promise<ITransferResults<S, D>>;
+    transferSchemas(): Promise<void>;
+    transferEntities(): Promise<void>;
+    transferLinks(): Promise<void>;
+    transferMedia(): Promise<void>;
+    transferConfiguration(): Promise<void>;
+}
+export declare const createTransferEngine: <S extends ISourceProvider = ISourceProvider, D extends IDestinationProvider = IDestinationProvider>(sourceProvider: S, destinationProvider: D, options: ITransferEngineOptions) => TransferEngine<S, D>;
+export {};

package/dist/engine/index.js

@@ -0,0 +1,324 @@
+"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 _TransferEngine_instances, _TransferEngine_metadata, _TransferEngine_transferProgress, _TransferEngine_progressStream, _TransferEngine_increaseTransferProgress, _TransferEngine_countRecorder, _TransferEngine_updateStage, _TransferEngine_assertStrapiVersionIntegrity, _TransferEngine_assertSchemasMatching, _TransferEngine_resolveProviderResource;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransferEngine = exports.VALID_STRATEGIES = void 0;
+const stream_chain_1 = require("stream-chain");
+const fp_1 = require("lodash/fp");
+const semverDiff = require('semver/functions/diff');
+const strategies_1 = __importDefault(require("../strategies"));
+exports.VALID_STRATEGIES = ['restore', 'merge'];
+class TransferEngine {
+    constructor(sourceProvider, destinationProvider, options) {
+        _TransferEngine_instances.add(this);
+        _TransferEngine_metadata.set(this, {});
+        _TransferEngine_transferProgress.set(this, {});
+        // TODO: Type the stream chunks. Doesn't seem trivial, especially since PassThrough doesn't provide a PassThroughOptions type
+        _TransferEngine_progressStream.set(this, new stream_chain_1.PassThrough({ objectMode: true }));
+        _TransferEngine_countRecorder.set(this, (transferStage, aggregateKey) => {
+            return new stream_chain_1.PassThrough({
+                objectMode: true,
+                transform: (data, _encoding, callback) => {
+                    __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_increaseTransferProgress).call(this, transferStage, data, aggregateKey);
+                    __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'progress', transferStage);
+                    callback(null, data);
+                },
+            });
+        });
+        _TransferEngine_updateStage.set(this, (type, transferStage) => {
+            __classPrivateFieldGet(this, _TransferEngine_progressStream, "f").emit(type, {
+                data: __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f"),
+                stage: transferStage,
+            });
+        });
+        if (sourceProvider.type !== 'source') {
+            throw new Error("SourceProvider does not have type 'source'");
+        }
+        if (destinationProvider.type !== 'destination') {
+            throw new Error("DestinationProvider does not have type 'destination'");
+        }
+        this.sourceProvider = sourceProvider;
+        this.destinationProvider = destinationProvider;
+        this.options = options;
+    }
+    get progress() {
+        return {
+            data: __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f"),
+            stream: __classPrivateFieldGet(this, _TransferEngine_progressStream, "f"),
+        };
+    }
+    async init() {
+        // Resolve providers' resource and store
+        // them in the engine's internal state
+        await __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_resolveProviderResource).call(this);
+        // Update the destination provider's source metadata
+        const { source: sourceMetadata } = __classPrivateFieldGet(this, _TransferEngine_metadata, "f");
+        if (sourceMetadata) {
+            this.destinationProvider.setMetadata?.('source', sourceMetadata);
+        }
+    }
+    async bootstrap() {
+        await Promise.all([this.sourceProvider.bootstrap?.(), this.destinationProvider.bootstrap?.()]);
+    }
+    async close() {
+        await Promise.all([this.sourceProvider.close?.(), this.destinationProvider.close?.()]);
+    }
+    async integrityCheck() {
+        try {
+            const sourceMetadata = await this.sourceProvider.getMetadata();
+            const destinationMetadata = await this.destinationProvider.getMetadata();
+            if (sourceMetadata && destinationMetadata) {
+                __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_assertStrapiVersionIntegrity).call(this, sourceMetadata?.strapi?.version, destinationMetadata?.strapi?.version);
+            }
+            const sourceSchemas = await this.sourceProvider.getSchemas?.();
+            const destinationSchemas = await this.destinationProvider.getSchemas?.();
+            if (sourceSchemas && destinationSchemas) {
+                __classPrivateFieldGet(this, _TransferEngine_instances, "m", _TransferEngine_assertSchemasMatching).call(this, sourceSchemas, destinationSchemas);
+            }
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    validateTransferOptions() {
+        if (!exports.VALID_STRATEGIES.includes(this.options.strategy)) {
+            throw new Error('Invalid stategy ' + this.options.strategy);
+        }
+    }
+    async transfer() {
+        try {
+            this.validateTransferOptions();
+            await this.bootstrap();
+            await this.init();
+            const isValidTransfer = await this.integrityCheck();
+            if (!isValidTransfer) {
+                throw new Error(`Unable to transfer the data between ${this.sourceProvider.name} and ${this.destinationProvider.name}.\nPlease refer to the log above for more information.`);
+            }
+            // Run the transfer stages
+            await this.transferSchemas();
+            await this.transferEntities();
+            await this.transferMedia();
+            await this.transferLinks();
+            await this.transferConfiguration();
+            // Gracefully close the providers
+            await this.close();
+        }
+        catch (e) {
+            // Rollback the destination provider if an exception is thrown during the transfer
+            // Note: This will be configurable in the future
+            await this.destinationProvider.rollback?.(e);
+            throw e;
+        }
+        return {
+            source: this.sourceProvider.results,
+            destination: this.destinationProvider.results,
+        };
+    }
+    async transferSchemas() {
+        const stageName = 'schemas';
+        const inStream = await this.sourceProvider.streamSchemas?.();
+        if (!inStream) {
+            return;
+        }
+        const outStream = await this.destinationProvider.getSchemasStream?.();
+        if (!outStream) {
+            return;
+        }
+        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', stageName);
+        return new Promise((resolve, reject) => {
+            inStream
+                // Throw on error in the source
+                .on('error', reject);
+            outStream
+                // Throw on error in the destination
+                .on('error', reject)
+                // Resolve the promise when the destination has finished reading all the data from the source
+                .on('close', () => {
+                __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
+                resolve();
+            });
+            inStream.pipe(__classPrivateFieldGet(this, _TransferEngine_countRecorder, "f").call(this, stageName)).pipe(outStream);
+        });
+    }
+    async transferEntities() {
+        const stageName = 'entities';
+        const inStream = await this.sourceProvider.streamEntities?.();
+        if (!inStream) {
+            return;
+        }
+        const outStream = await this.destinationProvider.getEntitiesStream?.();
+        if (!outStream) {
+            return;
+        }
+        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', stageName);
+        return new Promise((resolve, reject) => {
+            inStream
+                // Throw on error in the source
+                .on('error', (e) => {
+                reject(e);
+            });
+            outStream
+                // Throw on error in the destination
+                .on('error', (e) => {
+                reject(e);
+            })
+                // Resolve the promise when the destination has finished reading all the data from the source
+                .on('close', () => {
+                __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
+                resolve();
+            });
+            inStream.pipe(__classPrivateFieldGet(this, _TransferEngine_countRecorder, "f").call(this, stageName, 'type')).pipe(outStream);
+        });
+    }
+    async transferLinks() {
+        const stageName = 'links';
+        const inStream = await this.sourceProvider.streamLinks?.();
+        if (!inStream) {
+            return;
+        }
+        const outStream = await this.destinationProvider.getLinksStream?.();
+        if (!outStream) {
+            return;
+        }
+        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', 'links');
+        return new Promise((resolve, reject) => {
+            inStream
+                // Throw on error in the source
+                .on('error', reject);
+            outStream
+                // Throw on error in the destination
+                .on('error', reject)
+                // Resolve the promise when the destination has finished reading all the data from the source
+                .on('close', () => {
+                __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
+                resolve();
+            });
+            inStream.pipe(__classPrivateFieldGet(this, _TransferEngine_countRecorder, "f").call(this, stageName)).pipe(outStream);
+        });
+    }
+    async transferMedia() {
+        const stageName = 'media';
+        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', stageName);
+        console.warn('transferMedia not yet implemented');
+        return new Promise((resolve) => (() => {
+            __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
+            resolve();
+        })());
+    }
+    async transferConfiguration() {
+        const stageName = 'configuration';
+        const inStream = await this.sourceProvider.streamConfiguration?.();
+        if (!inStream) {
+            return;
+        }
+        const outStream = await this.destinationProvider.getConfigurationStream?.();
+        if (!outStream) {
+            return;
+        }
+        __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'start', stageName);
+        return new Promise((resolve, reject) => {
+            inStream
+                // Throw on error in the source
+                .on('error', reject);
+            outStream
+                // Throw on error in the destination
+                .on('error', reject)
+                // Resolve the promise when the destination has finished reading all the data from the source
+                .on('close', () => {
+                __classPrivateFieldGet(this, _TransferEngine_updateStage, "f").call(this, 'complete', stageName);
+                resolve();
+            });
+            inStream.pipe(__classPrivateFieldGet(this, _TransferEngine_countRecorder, "f").call(this, stageName)).pipe(outStream);
+        });
+    }
+}
+_TransferEngine_metadata = new WeakMap(), _TransferEngine_transferProgress = new WeakMap(), _TransferEngine_progressStream = new WeakMap(), _TransferEngine_countRecorder = new WeakMap(), _TransferEngine_updateStage = new WeakMap(), _TransferEngine_instances = new WeakSet(), _TransferEngine_increaseTransferProgress = function _TransferEngine_increaseTransferProgress(transferStage, data, aggregateKey) {
+    if (!__classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage]) {
+        __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage] = { count: 0, bytes: 0 };
+    }
+    __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].count += 1;
+    const size = JSON.stringify(data).length;
+    __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].bytes += size;
+    if (aggregateKey && data && data[aggregateKey]) {
+        const aggKeyValue = data[aggregateKey];
+        if (!__classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage]['aggregates']) {
+            __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates = {};
+        }
+        if (!(__classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates &&
+            __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates[aggKeyValue])) {
+            __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates[aggKeyValue] = { count: 0, bytes: 0 };
+        }
+        __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates[aggKeyValue].count += 1;
+        __classPrivateFieldGet(this, _TransferEngine_transferProgress, "f")[transferStage].aggregates[aggKeyValue].bytes += size;
+    }
+}, _TransferEngine_assertStrapiVersionIntegrity = function _TransferEngine_assertStrapiVersionIntegrity(sourceVersion, destinationVersion) {
+    const strategy = this.options.versionMatching;
+    if (!sourceVersion ||
+        !destinationVersion ||
+        strategy === 'ignore' ||
+        destinationVersion === sourceVersion) {
+        return;
+    }
+    let diff;
+    try {
+        diff = semverDiff(sourceVersion, destinationVersion);
+    }
+    catch (e) {
+        throw new Error(`Strapi versions doesn't match (${strategy} check): ${sourceVersion} does not match with ${destinationVersion}`);
+    }
+    if (!diff) {
+        return;
+    }
+    const validPatch = ['prelease', 'build'];
+    const validMinor = [...validPatch, 'patch', 'prepatch'];
+    const validMajor = [...validMinor, 'minor', 'preminor'];
+    if (strategy === 'patch' && validPatch.includes(diff)) {
+        return;
+    }
+    if (strategy === 'minor' && validMinor.includes(diff)) {
+        return;
+    }
+    if (strategy === 'major' && validMajor.includes(diff)) {
+        return;
+    }
+    throw new Error(`Strapi versions doesn't match (${strategy} check): ${sourceVersion} does not match with ${destinationVersion}`);
+}, _TransferEngine_assertSchemasMatching = function _TransferEngine_assertSchemasMatching(sourceSchemas, destinationSchemas) {
+    const strategy = this.options.schemasMatching || 'strict';
+    const keys = (0, fp_1.uniq)(Object.keys(sourceSchemas).concat(Object.keys(destinationSchemas)));
+    const diffs = {};
+    keys.forEach((key) => {
+        const sourceSchema = sourceSchemas[key];
+        const destinationSchema = destinationSchemas[key];
+        const schemaDiffs = (0, strategies_1.default)(sourceSchema, destinationSchema, strategy);
+        if (schemaDiffs.length) {
+            diffs[key] = schemaDiffs;
+        }
+    });
+    if (!(0, fp_1.isEmpty)(diffs)) {
+        throw new Error(`Import process failed because the project doesn't have a matching data structure 
+        ${JSON.stringify(diffs, null, 2)}        
+        `);
+    }
+}, _TransferEngine_resolveProviderResource = async function _TransferEngine_resolveProviderResource() {
+    const sourceMetadata = await this.sourceProvider.getMetadata();
+    const destinationMetadata = await this.destinationProvider.getMetadata();
+    if (sourceMetadata) {
+        __classPrivateFieldGet(this, _TransferEngine_metadata, "f").source = sourceMetadata;
+    }
+    if (destinationMetadata) {
+        __classPrivateFieldGet(this, _TransferEngine_metadata, "f").destination = destinationMetadata;
+    }
+};
+const createTransferEngine = (sourceProvider, destinationProvider, options) => {
+    return new TransferEngine(sourceProvider, destinationProvider, options);
+};
+exports.createTransferEngine = createTransferEngine;
+//# sourceMappingURL=index.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './engine';
+export * from './providers';

package/dist/index.js

@@ -0,0 +1,19 @@
+"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 });
+__exportStar(require("./engine"), exports);
+__exportStar(require("./providers"), exports);
+//# sourceMappingURL=index.js.map

package/dist/providers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './local-file-source-provider';
+export * from './local-strapi-source-provider';
+export * from './local-file-destination-provider';
+export * from './local-strapi-destination-provider';

package/dist/providers/index.js

@@ -0,0 +1,23 @@
+"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 });
+// source providers
+__exportStar(require("./local-file-source-provider"), exports);
+__exportStar(require("./local-strapi-source-provider"), exports);
+// destination providers
+__exportStar(require("./local-file-destination-provider"), exports);
+__exportStar(require("./local-strapi-destination-provider"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,41 @@
+/// <reference types="stream-chain" />
+/// <reference types="node" />
+import type { IDestinationProvider, IDestinationProviderTransferResults, IMetadata, ProviderType } from '../../types';
+export interface ILocalFileDestinationProviderOptions {
+    encryption: {
+        enabled: boolean;
+        key?: string;
+    };
+    compression: {
+        enabled: boolean;
+    };
+    file: {
+        path: string;
+        maxSize?: number;
+        maxSizeJsonl?: number;
+    };
+}
+export interface ILocalFileDestinationProviderTransferResults extends IDestinationProviderTransferResults {
+    file?: {
+        path?: string;
+    };
+}
+export declare const createLocalFileDestinationProvider: (options: ILocalFileDestinationProviderOptions) => LocalFileDestinationProvider;
+declare class LocalFileDestinationProvider implements IDestinationProvider {
+    #private;
+    name: string;
+    type: ProviderType;
+    options: ILocalFileDestinationProviderOptions;
+    results: ILocalFileDestinationProviderTransferResults;
+    constructor(options: ILocalFileDestinationProviderOptions);
+    setMetadata(target: ProviderType, metadata: IMetadata): IDestinationProvider;
+    bootstrap(): void | Promise<void>;
+    close(): Promise<void>;
+    rollback(): Promise<void>;
+    getMetadata(): null;
+    getSchemasStream(): import("stream-chain");
+    getEntitiesStream(): NodeJS.WritableStream;
+    getLinksStream(): NodeJS.WritableStream;
+    getConfigurationStream(): NodeJS.WritableStream;
+}
+export {};