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

package/{dist/providers/local-file-destination-provider.js → lib/file/providers/destination/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 encryption_1 = require("../../../utils/encryption");
+const utils_1 = require("./utils");
 const createLocalFileDestinationProvider = (options) => {
     return new LocalFileDestinationProvider(options);
 };
@@ -36,19 +37,22 @@ 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));
+            archiveTransforms.push((0, encryption_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) };
@@ -68,62 +72,82 @@ 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;
     }
-    getSchemasStream() {
+    createSchemasWriteStream() {
         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() {
+    createEntitiesWriteStream() {
         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() {
+    createLinksWriteStream() {
         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() {
+    createConfigurationWriteStream() {
         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]);
     }
+    createAssetsWriteStream() {
+        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/lib/file/providers/destination/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/lib/file/providers/destination/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/lib/file/providers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './source';
+export * from './destination';

package/{dist → lib/file}/providers/index.js

@@ -14,10 +14,6 @@ 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);
+__exportStar(require("./source"), exports);
+__exportStar(require("./destination"), exports);
 //# sourceMappingURL=index.js.map

package/lib/file/providers/source/index.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="lodash" />
+/// <reference types="node" />
+import type { Readable } from 'stream';
+import type { Schema } from '@strapi/strapi';
+import type { IMetadata, ISourceProvider, ProviderType } from '../../../../types';
+/**
+ * Provider options
+ */
+export interface ILocalFileSourceProviderOptions {
+    file: {
+        path: string;
+    };
+    encryption: {
+        enabled: boolean;
+        key?: string;
+    };
+    compression: {
+        enabled: 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 file can be opened (decrypted, decompressed), etc.
+     */
+    bootstrap(): Promise<void>;
+    getMetadata(): Promise<IMetadata>;
+    getSchemas(): Promise<import("lodash").Dictionary<Schema>>;
+    createEntitiesReadStream(): Readable;
+    createSchemasReadStream(): Readable;
+    createLinksReadStream(): Readable;
+    createConfigurationReadStream(): Readable;
+    createAssetsReadStream(): Readable | Promise<Readable>;
+}
+export {};

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

@@ -1,4 +1,10 @@
 "use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
@@ -7,18 +13,19 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _LocalFileSourceProvider_instances, _LocalFileSourceProvider_getBackupStream, _LocalFileSourceProvider_streamJsonlDirectory, _LocalFileSourceProvider_parseJSONFile;
+var _LocalFileSourceProvider_instances, _LocalFileSourceProvider_metadata, _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("../../../utils/encryption");
+const stream_2 = require("../../../utils/stream");
 /**
  * Constant for the metadata file path
  */
@@ -32,20 +39,24 @@ class LocalFileSourceProvider {
         _LocalFileSourceProvider_instances.add(this);
         this.type = 'source';
         this.name = 'source::local-file';
+        _LocalFileSourceProvider_metadata.set(this, void 0);
         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...)
+     * Pre flight checks regarding the provided options, making sure that the file can be opened (decrypted, decompressed), 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 {
+            // Read the metadata to ensure the file can be parsed
+            __classPrivateFieldSet(this, _LocalFileSourceProvider_metadata, await this.getMetadata(), "f");
+        }
+        catch (e) {
+            throw new Error(`Can't read file "${filePath}".`);
         }
     }
     getMetadata() {
@@ -55,62 +66,90 @@ 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 (0, stream_2.collect)(this.createSchemasReadStream());
         return (0, fp_1.keyBy)('uid', schemas);
     }
-    streamEntities() {
+    createEntitiesReadStream() {
         return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'entities');
     }
-    streamSchemas() {
+    createSchemasReadStream() {
         return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'schemas');
     }
-    streamLinks() {
+    createLinksReadStream() {
         return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'links');
     }
-    streamConfiguration() {
+    createConfigurationReadStream() {
         // NOTE: TBD
         return __classPrivateFieldGet(this, _LocalFileSourceProvider_instances, "m", _LocalFileSourceProvider_streamJsonlDirectory).call(this, 'configuration');
     }
+    createAssetsReadStream() {
+        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_metadata = new WeakMap(), _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,28 +174,32 @@ _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
-                 */
                 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();
+                    try {
+                        // Parse from buffer to string to JSON
+                        const parsedContent = JSON.parse(content.toString());
+                        // Resolve the Promise with the parsed content
+                        resolve(parsedContent);
+                    }
+                    catch (e) {
+                        reject(e);
+                    }
+                    finally {
+                        // 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`);
+            reject(new Error(`File "${filePath}" not found`));
         });
     });
 };
-//# sourceMappingURL=local-file-source-provider.js.map
+//# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * as engine from './engine';
+export * as strapi from './strapi';
+export * as file from './file';
+export * as utils from './utils';

package/lib/index.js

@@ -0,0 +1,31 @@
+"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.utils = exports.file = exports.strapi = exports.engine = void 0;
+exports.engine = __importStar(require("./engine"));
+exports.strapi = __importStar(require("./strapi"));
+exports.file = __importStar(require("./file"));
+exports.utils = __importStar(require("./utils"));
+//# sourceMappingURL=index.js.map

package/lib/strapi/index.d.ts

@@ -0,0 +1,4 @@
+export * as providers from './providers';
+export * as queries from './queries';
+export * as remote from './remote';
+export { default as register } from './register';