@flystorage/file-storage 0.0.3 → 0.0.5

package/README.md

@@ -0,0 +1,128 @@
+<img src="https://avatars.githubusercontent.com/u/151840999" width="50px" height="50px" />
+
+# Flystorage
+Flystorage is a file storage abstraction for NodeJS and TypeScript. It is an 80/20 solution
+that is built around a set of goals:
+
+- Provide a straight-forward API that is easy to use.
+- Allow application code to be unaware WHERE files are stored.
+- Pragmatically smooth over underlying storage differences.
+- Expose an async/await based API, promises all the way.
+- Abstract over file permissions using "visibility".
+- Actually tested using real integrations, _mocks are not welcome_.
+- Stand on the shoulders of giants, use official vendor packages when possible.
+
+### What is Flystorage NOT:
+Flystorage is meant to be used in cases for generic file storage use-cases. It's not an API for
+any  specific filesystem. It's a generalised solution and will not implement feature only
+specific to one particular storage implementation. There will be use-cases that are not catered
+to, simply because they cannot be abstracted over in a reasonable manner.
+
+## Capabilities
+
+### Implemented
+- [x] Write files using string | buffer | readable/stream
+- [x] Read files as stream, string, or Uint8Array
+- [x] Set permissions using abstracted visibility
+- [x] List the contents of a directory/prefix, (shallow and deep).
+- [x] Delete files without failing when they don't exist.
+- [x] Delete directories (and any files it contains)
+- [x] Generate public URLs.
+- [x] Generate temporary (signed) URLs.
+- [x] Expose or calculate checksums for files.
+- [x] Mime-type resolving
+- [x] Last modified fetching
+- [x] File size
+
+### Planned
+- [ ] Moving files
+- [ ] Copying files
+
+## Implementations / Adapters
+
+### Implemented
+- [x] Local Filesystem
+- [x] AWS S3 (using the V3 SDK)
+
+### Planned
+
+#### Prio 1
+- [ ] Azure Blob Storage
+- [ ] Test implementation (in-memory, with staged errors)
+- [ ] Google Cloud Storage
+
+### Prio 2
+- [ ] FTP (using `basic-ftp`)
+- [ ] SFTP (?)
+
+## Usage
+Install the main package and any adapters you might need:
+
+```bash
+npm i -S @flystorage/file-storage
+
+# for using AWS S3
+npm i -S @flystorage/aws-s3
+
+# for using the local filesystem
+npm i -S @flystorage/local-fs
+```
+
+## Local Usage
+```typescript
+import {resolve} from 'node:path';
+import {createReadStream} from 'node:fs';
+import {FileStorage, Visibility} from '@flystorage/file-storage';
+import {LocalFileStorage} from '@flystorage/local-fs';
+
+/**
+ * SETUP
+ **/
+
+const rootDirectory = resolve(process.cwd(), 'my-files');
+const storage = new FileStorage(new LocalFileStorage(rootDirectory));
+
+/**
+ * USAGE
+ **/
+
+// Write using a string
+await storage.write('write-from-a-string.txt', 'file contents');
+
+// Write using a stream
+const stream = createReadStream(resolve(process.cwd(), 'test-files/picture.png'));
+await storage.write('picture.png', stream);
+
+// Write with visibility (permissions).
+await storage.write('public.txt', 'debug', {
+    visibility: Visibility.PUBLIC, // mode: 0o644
+});
+await storage.write('private.txt', 'debug', {
+    visibility: Visibility.PRIVATE, // mode: 0o600
+});
+
+// List directory contents
+const contentsAsAsyncGenerator = storage.list('', {deep: true});
+
+for await (const item of contentsAsAsyncGenerator) {
+    console.log(item.path);
+
+    if (item.isFile) {
+        // do something with the file
+    } else if (item.isDirectory) {
+        // do something with the directory
+    }
+}
+
+// Delete a file
+await storage.deleteFile('some-file.txt');
+
+// Delete a directory (with all contents)
+await storage.deleteDirectory('some-directory');
+```
+
+## Author
+Flystorage is built by the maintainer of [Flysystem](https://flysystem.thephpleague.com), a
+filesystem abstraction for PHP. This brings along more than
+a decade of smoothing over filesystem implementation differences
+and weighing trade-offs to make a usable API.

package/dist/cjs/file-storage.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readableToUint8Array = exports.readableToString = exports.closeReadable = exports.normalizeExpiryToMilliseconds = exports.normalizeExpiryToDate = exports.FileStorage = exports.isDirectory = exports.isFile = void 0;
+exports.readableToUint8Array = exports.readableToString = exports.closeReadable = exports.normalizeExpiryToMilliseconds = exports.normalizeExpiryToDate = exports.FileStorage = exports.DirectoryListing = exports.isDirectory = exports.isFile = void 0;
 const stream_1 = require("stream");
 const checksum_from_stream_js_1 = require("./checksum-from-stream.js");
 const errors = require("./errors.js");
@@ -14,6 +14,45 @@ function isDirectory(stat) {
     return stat.isDirectory;
 }
 exports.isDirectory = isDirectory;
+class DirectoryListing {
+    listing;
+    path;
+    deep;
+    constructor(listing, path, deep) {
+        this.listing = listing;
+        this.path = path;
+        this.deep = deep;
+    }
+    async toArray(sorted = true) {
+        const items = [];
+        for await (const item of this.listing) {
+            items.push(item);
+        }
+        return sorted ? items.sort((a, b) => naturalSorting.compare(a.path, b.path)) : items;
+    }
+    filter(filter) {
+        const listing = this.listing;
+        const filtered = (async function* () {
+            for await (const entry of listing) {
+                if (filter(entry)) {
+                    yield entry;
+                }
+            }
+        })();
+        return new DirectoryListing(filtered, this.path, this.deep);
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            for await (const item of this.listing) {
+                yield item;
+            }
+        }
+        catch (error) {
+            throw errors.UnableToListDirectory.because(errors.errorToMessage(error), { cause: error, context: { path: this.path, deep: this.deep } });
+        }
+    }
+}
+exports.DirectoryListing = DirectoryListing;
 function toReadable(contents) {
     if (contents instanceof stream_1.Readable) {
         return contents;
@@ -57,6 +96,9 @@ class FileStorage {
     async readToUint8Array(path) {
         return await readableToUint8Array(await this.read(path));
     }
+    async readToBuffer(path) {
+        return Buffer.from(await this.readToUint8Array(path));
+    }
     async deleteFile(path) {
         try {
             await this.adapter.deleteFile(this.pathNormalizer.normalizePath(path));
@@ -114,26 +156,7 @@ class FileStorage {
         }
     }
     list(path, { deep = false } = {}) {
-        const listing = this.adapter.list(this.pathNormalizer.normalizePath(path), { deep });
-        return {
-            async toArray(sorted = true) {
-                const items = [];
-                for await (const item of listing) {
-                    items.push(item);
-                }
-                return sorted ? items.sort((a, b) => naturalSorting.compare(a.path, b.path)) : items;
-            },
-            async *[Symbol.asyncIterator]() {
-                try {
-                    for await (const item of listing) {
-                        yield item;
-                    }
-                }
-                catch (error) {
-                    throw errors.UnableToListDirectory.because(errors.errorToMessage(error), { cause: error, context: { path, deep } });
-                }
-            }
-        };
+        return new DirectoryListing(this.adapter.list(this.pathNormalizer.normalizePath(path), { deep }), path, deep);
     }
     async statFile(path) {
         const stat = await this.stat(path);

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/esm/checksum-from-stream.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checksumFromStream = void 0;
-const crypto_1 = require("crypto");
-async function checksumFromStream(stream, options) {
+import { createHash } from 'crypto';
+export async function checksumFromStream(stream, options) {
     return new Promise(async (resolve, reject) => {
-        const hash = (0, crypto_1.createHash)(options.algo ?? 'md5');
+        const hash = createHash(options.algo ?? 'md5');
         stream.on('error', reject);
         stream.pipe(hash, { end: false });
         stream.on('end', () => {
@@ -13,4 +10,3 @@ async function checksumFromStream(stream, options) {
         });
     });
 }
-exports.checksumFromStream = checksumFromStream;

package/dist/esm/errors.js

@@ -1,11 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnableToListDirectory = exports.UnableToCheckDirectoryExistence = exports.UnableToCheckFileExistence = exports.UnableToDeleteFile = exports.UnableToDeleteDirectory = exports.UnableToCreateDirectory = exports.UnableToGetStat = exports.UnableToGetTemporaryUrl = exports.UnableToGetPublicUrl = exports.UnableToGetVisibility = exports.UnableToSetVisibility = exports.UnableToReadFile = exports.UnableToWriteFile = exports.UnableToGetFileSize = exports.UnableToGetLastModified = exports.UnableToGetMimeType = exports.UnableToGetChecksum = exports.ChecksumIsNotAvailable = exports.FlystorageError = exports.errorToMessage = void 0;
-function errorToMessage(error) {
+export function errorToMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-exports.errorToMessage = errorToMessage;
-class FlystorageError extends Error {
+export class FlystorageError extends Error {
     context;
     code = 'unknown_error';
     constructor(message, context = {}, cause = undefined) {
@@ -15,12 +11,11 @@ class FlystorageError extends Error {
         this.context = context;
     }
 }
-exports.FlystorageError = FlystorageError;
 /**
  * Thrown when the checksum algo is not supported or not pre-computed. This error
  * is thrown with the intention of falling back to computing it based on a file read.
  */
-class ChecksumIsNotAvailable extends FlystorageError {
+export class ChecksumIsNotAvailable extends FlystorageError {
     algo;
     code = 'flystorage.checksum_not_supported';
     constructor(message, algo, context = {}, cause = undefined) {
@@ -29,90 +24,72 @@ class ChecksumIsNotAvailable extends FlystorageError {
     }
     static checksumNotSupported = (algo, { context = {}, cause = undefined } = {}) => new ChecksumIsNotAvailable(`Checksum algo "${algo}" is not supported`, algo, { ...context, algo }, cause);
 }
-exports.ChecksumIsNotAvailable = ChecksumIsNotAvailable;
-class UnableToGetChecksum extends FlystorageError {
+export class UnableToGetChecksum extends FlystorageError {
     code = 'flystorage.unable_to_get_checksum';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToGetChecksum(`Unable to write the file. Reason: ${reason}`, context, cause);
 }
-exports.UnableToGetChecksum = UnableToGetChecksum;
-class UnableToGetMimeType extends FlystorageError {
+export class UnableToGetMimeType extends FlystorageError {
     code = 'flystorage.unable_to_get_mimetype';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToGetMimeType(`Unable to get mime-type. Reason: ${reason}`, context, cause);
 }
-exports.UnableToGetMimeType = UnableToGetMimeType;
-class UnableToGetLastModified extends FlystorageError {
+export class UnableToGetLastModified extends FlystorageError {
     code = 'flystorage.unable_to_get_last_modified';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToGetLastModified(`Unable to get last modified. Reason: ${reason}`, context, cause);
 }
-exports.UnableToGetLastModified = UnableToGetLastModified;
-class UnableToGetFileSize extends FlystorageError {
+export class UnableToGetFileSize extends FlystorageError {
     code = 'flystorage.unable_to_get_file_size';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToGetFileSize(`Unable to get file size. Reason: ${reason}`, context, cause);
 }
-exports.UnableToGetFileSize = UnableToGetFileSize;
-class UnableToWriteFile extends FlystorageError {
+export class UnableToWriteFile extends FlystorageError {
     code = 'flystorage.unable_to_write_file';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToWriteFile(`Unable to write the file. Reason: ${reason}`, context, cause);
 }
-exports.UnableToWriteFile = UnableToWriteFile;
-class UnableToReadFile extends FlystorageError {
+export class UnableToReadFile extends FlystorageError {
     code = 'flystorage.unable_to_read_file';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToReadFile(`Unable to read the file. Reason: ${reason}`, context, cause);
 }
-exports.UnableToReadFile = UnableToReadFile;
-class UnableToSetVisibility extends FlystorageError {
+export class UnableToSetVisibility extends FlystorageError {
     code = 'flystorage.unable_to_set_visibility';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToSetVisibility(`Unable to set visibility. Reason: ${reason}`, context, cause);
 }
-exports.UnableToSetVisibility = UnableToSetVisibility;
-class UnableToGetVisibility extends FlystorageError {
+export class UnableToGetVisibility extends FlystorageError {
     code = 'flystorage.unable_to_get_visibility';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToGetVisibility(`Unable to get visibility. Reason: ${reason}`, context, cause);
 }
-exports.UnableToGetVisibility = UnableToGetVisibility;
-class UnableToGetPublicUrl extends FlystorageError {
+export class UnableToGetPublicUrl extends FlystorageError {
     code = 'flystorage.unable_to_get_public_url';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToGetPublicUrl(`Unable to get public URL. Reason: ${reason}`, context, cause);
 }
-exports.UnableToGetPublicUrl = UnableToGetPublicUrl;
-class UnableToGetTemporaryUrl extends FlystorageError {
+export class UnableToGetTemporaryUrl extends FlystorageError {
     code = 'flystorage.unable_to_get_temporary_url';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToGetTemporaryUrl(`Unable to get temporary URL. Reason: ${reason}`, context, cause);
 }
-exports.UnableToGetTemporaryUrl = UnableToGetTemporaryUrl;
-class UnableToGetStat extends FlystorageError {
+export class UnableToGetStat extends FlystorageError {
     code = 'flystorage.unable_to_get_stat';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToGetStat(`Unable to get stat. Reason: ${reason}`, context, cause);
     static noFileStatResolved = ({ context = {}, cause = undefined }) => new UnableToGetStat(`Stat was not a file.`, context, cause);
 }
-exports.UnableToGetStat = UnableToGetStat;
-class UnableToCreateDirectory extends FlystorageError {
+export class UnableToCreateDirectory extends FlystorageError {
     code = 'flystorage.unable_to_create_directory';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToCreateDirectory(`Unable to create directory. Reason: ${reason}`, context, cause);
 }
-exports.UnableToCreateDirectory = UnableToCreateDirectory;
-class UnableToDeleteDirectory extends FlystorageError {
+export class UnableToDeleteDirectory extends FlystorageError {
     code = 'flystorage.unable_to_delete_directory';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToDeleteDirectory(`Unable to delete directory. Reason: ${reason}`, context, cause);
 }
-exports.UnableToDeleteDirectory = UnableToDeleteDirectory;
-class UnableToDeleteFile extends FlystorageError {
+export class UnableToDeleteFile extends FlystorageError {
     code = 'flystorage.unable_to_delete_file';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToDeleteFile(`Unable to delete file. Reason: ${reason}`, context, cause);
 }
-exports.UnableToDeleteFile = UnableToDeleteFile;
-class UnableToCheckFileExistence extends FlystorageError {
+export class UnableToCheckFileExistence extends FlystorageError {
     code = 'flystorage.unable_to_check_file_existence';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToCheckFileExistence(`Unable to check file existence. Reason: ${reason}`, context, cause);
 }
-exports.UnableToCheckFileExistence = UnableToCheckFileExistence;
-class UnableToCheckDirectoryExistence extends FlystorageError {
+export class UnableToCheckDirectoryExistence extends FlystorageError {
     code = 'flystorage.unable_to_check_directory_existence';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToCheckDirectoryExistence(`Unable to check directory existence. Reason: ${reason}`, context, cause);
 }
-exports.UnableToCheckDirectoryExistence = UnableToCheckDirectoryExistence;
-class UnableToListDirectory extends FlystorageError {
+export class UnableToListDirectory extends FlystorageError {
     code = 'flystorage.unable_to_list_directory_contents';
     static because = (reason, { context = {}, cause = undefined }) => new UnableToListDirectory(`Unable to list directory contents. Reason: ${reason}`, context, cause);
 }
-exports.UnableToListDirectory = UnableToListDirectory;

package/dist/esm/file-storage.js

@@ -1,34 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readableToUint8Array = exports.readableToString = exports.closeReadable = exports.normalizeExpiryToMilliseconds = exports.normalizeExpiryToDate = exports.FileStorage = exports.isDirectory = exports.isFile = void 0;
-const stream_1 = require("stream");
-const checksum_from_stream_js_1 = require("./checksum-from-stream.js");
-const errors = require("./errors.js");
-const errors_js_1 = require("./errors.js");
-const path_normalizer_js_1 = require("./path-normalizer.js");
-function isFile(stat) {
+import { Readable } from 'stream';
+import { checksumFromStream } from './checksum-from-stream.js';
+import * as errors from './errors.js';
+import { ChecksumIsNotAvailable } from './errors.js';
+import { PathNormalizerV1 } from './path-normalizer.js';
+export function isFile(stat) {
     return stat.isFile;
 }
-exports.isFile = isFile;
-function isDirectory(stat) {
+export function isDirectory(stat) {
     return stat.isDirectory;
 }
-exports.isDirectory = isDirectory;
+export class DirectoryListing {
+    listing;
+    path;
+    deep;
+    constructor(listing, path, deep) {
+        this.listing = listing;
+        this.path = path;
+        this.deep = deep;
+    }
+    async toArray(sorted = true) {
+        const items = [];
+        for await (const item of this.listing) {
+            items.push(item);
+        }
+        return sorted ? items.sort((a, b) => naturalSorting.compare(a.path, b.path)) : items;
+    }
+    filter(filter) {
+        const listing = this.listing;
+        const filtered = (async function* () {
+            for await (const entry of listing) {
+                if (filter(entry)) {
+                    yield entry;
+                }
+            }
+        })();
+        return new DirectoryListing(filtered, this.path, this.deep);
+    }
+    async *[Symbol.asyncIterator]() {
+        try {
+            for await (const item of this.listing) {
+                yield item;
+            }
+        }
+        catch (error) {
+            throw errors.UnableToListDirectory.because(errors.errorToMessage(error), { cause: error, context: { path: this.path, deep: this.deep } });
+        }
+    }
+}
 function toReadable(contents) {
-    if (contents instanceof stream_1.Readable) {
+    if (contents instanceof Readable) {
         return contents;
     }
-    return stream_1.Readable.from(contents);
+    return Readable.from(contents);
 }
 const naturalSorting = new Intl.Collator(undefined, {
     numeric: true,
     sensitivity: 'base'
 });
-class FileStorage {
+export class FileStorage {
     adapter;
     pathNormalizer;
     options;
-    constructor(adapter, pathNormalizer = new path_normalizer_js_1.PathNormalizerV1(), options = {}) {
+    constructor(adapter, pathNormalizer = new PathNormalizerV1(), options = {}) {
         this.adapter = adapter;
         this.pathNormalizer = pathNormalizer;
         this.options = options;
@@ -45,7 +78,7 @@ class FileStorage {
     }
     async read(path) {
         try {
-            return stream_1.Readable.from(await this.adapter.read(this.pathNormalizer.normalizePath(path)));
+            return Readable.from(await this.adapter.read(this.pathNormalizer.normalizePath(path)));
         }
         catch (error) {
             throw errors.UnableToReadFile.because(errors.errorToMessage(error), { cause: error, context: { path } });
@@ -57,6 +90,9 @@ class FileStorage {
     async readToUint8Array(path) {
         return await readableToUint8Array(await this.read(path));
     }
+    async readToBuffer(path) {
+        return Buffer.from(await this.readToUint8Array(path));
+    }
     async deleteFile(path) {
         try {
             await this.adapter.deleteFile(this.pathNormalizer.normalizePath(path));
@@ -114,26 +150,7 @@ class FileStorage {
         }
     }
     list(path, { deep = false } = {}) {
-        const listing = this.adapter.list(this.pathNormalizer.normalizePath(path), { deep });
-        return {
-            async toArray(sorted = true) {
-                const items = [];
-                for await (const item of listing) {
-                    items.push(item);
-                }
-                return sorted ? items.sort((a, b) => naturalSorting.compare(a.path, b.path)) : items;
-            },
-            async *[Symbol.asyncIterator]() {
-                try {
-                    for await (const item of listing) {
-                        yield item;
-                    }
-                }
-                catch (error) {
-                    throw errors.UnableToListDirectory.because(errors.errorToMessage(error), { cause: error, context: { path, deep } });
-                }
-            }
-        };
+        return new DirectoryListing(this.adapter.list(this.pathNormalizer.normalizePath(path), { deep }), path, deep);
     }
     async statFile(path) {
         const stat = await this.stat(path);
@@ -171,7 +188,7 @@ class FileStorage {
             return await this.adapter.checksum(this.pathNormalizer.normalizePath(path), options);
         }
         catch (error) {
-            if (error instanceof errors_js_1.ChecksumIsNotAvailable) {
+            if (error instanceof ChecksumIsNotAvailable) {
                 return this.calculateChecksum(path, options);
             }
             throw errors.UnableToGetChecksum.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
@@ -203,23 +220,20 @@ class FileStorage {
     }
     async calculateChecksum(path, options) {
         try {
-            return await (0, checksum_from_stream_js_1.checksumFromStream)(await this.read(path), options);
+            return await checksumFromStream(await this.read(path), options);
         }
         catch (error) {
             throw errors.UnableToGetChecksum.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
         }
     }
 }
-exports.FileStorage = FileStorage;
-function normalizeExpiryToDate(expiresAt) {
+export function normalizeExpiryToDate(expiresAt) {
     return expiresAt instanceof Date ? expiresAt : new Date(expiresAt);
 }
-exports.normalizeExpiryToDate = normalizeExpiryToDate;
-function normalizeExpiryToMilliseconds(expiresAt) {
+export function normalizeExpiryToMilliseconds(expiresAt) {
     return expiresAt instanceof Date ? expiresAt.getTime() : expiresAt;
 }
-exports.normalizeExpiryToMilliseconds = normalizeExpiryToMilliseconds;
-async function closeReadable(body) {
+export async function closeReadable(body) {
     if (body.closed) {
         return;
     }
@@ -230,13 +244,11 @@ async function closeReadable(body) {
         body.destroy();
     });
 }
-exports.closeReadable = closeReadable;
 const decoder = new TextDecoder();
-async function readableToString(stream) {
+export async function readableToString(stream) {
     return decoder.decode(await readableToUint8Array(stream));
 }
-exports.readableToString = readableToString;
-function readableToUint8Array(stream) {
+export function readableToUint8Array(stream) {
     return new Promise((resolve, reject) => {
         const parts = [];
         stream.on('data', (chunk) => {
@@ -246,7 +258,6 @@ function readableToUint8Array(stream) {
         stream.on('end', () => resolve(concatUint8Arrays(parts)));
     });
 }
-exports.readableToUint8Array = readableToUint8Array;
 function concatUint8Arrays(input) {
     const length = input.reduce((l, a) => l + a.byteLength, 0);
     const output = new Uint8Array(length);

package/dist/esm/index.js

@@ -1,22 +1,6 @@
-"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("./checksum-from-stream.js"), exports);
-__exportStar(require("./file-storage.js"), exports);
-__exportStar(require("./errors.js"), exports);
-__exportStar(require("./path-normalizer.js"), exports);
-__exportStar(require("./path-prefixer.js"), exports);
-__exportStar(require("./portable-visibility.js"), exports);
+export * from './checksum-from-stream.js';
+export * from './file-storage.js';
+export * from './errors.js';
+export * from './path-normalizer.js';
+export * from './path-prefixer.js';
+export * from './portable-visibility.js';

package/dist/esm/path-normalizer.js

@@ -1,26 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathTraversalDetected = exports.CorruptedPathDetected = exports.PathNormalizerV1 = void 0;
-const node_path_1 = require("node:path");
+import { join } from 'node:path';
 const funkyWhiteSpaceRegex = new RegExp('\\p{C}+', 'u');
-class PathNormalizerV1 {
+export class PathNormalizerV1 {
     normalizePath(path) {
         if (funkyWhiteSpaceRegex.test(path)) {
             throw CorruptedPathDetected.unexpectedWhitespace(path);
         }
-        const normalized = (0, node_path_1.join)(...(path.split('/')));
+        const normalized = join(...(path.split('/')));
         if (normalized.indexOf('../') !== -1 || normalized == '..') {
             throw PathTraversalDetected.forPath(path);
         }
         return normalized === '.' ? '' : normalized;
     }
 }
-exports.PathNormalizerV1 = PathNormalizerV1;
-class CorruptedPathDetected extends Error {
+export class CorruptedPathDetected extends Error {
     static unexpectedWhitespace = (path) => new CorruptedPathDetected(`Corrupted path detected with unexpected whitespace: ${path}`);
 }
-exports.CorruptedPathDetected = CorruptedPathDetected;
-class PathTraversalDetected extends Error {
+export class PathTraversalDetected extends Error {
     static forPath = (path) => new PathTraversalDetected(`Path traversal detected for: ${path}`);
 }
-exports.PathTraversalDetected = PathTraversalDetected;

package/dist/esm/path-prefixer.js

@@ -1,19 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PathPrefixer = void 0;
-const node_path_1 = require("node:path");
-class PathPrefixer {
+import { join } from 'node:path';
+export class PathPrefixer {
     prefix = '';
     constructor(prefix = '') {
         if (prefix.length > 0) {
-            this.prefix = (0, node_path_1.join)(prefix, '/');
+            this.prefix = join(prefix, '/');
         }
     }
     prefixFilePath(path) {
-        return this.prefix.length > 0 ? (0, node_path_1.join)(this.prefix, path) : path;
+        return this.prefix.length > 0 ? join(this.prefix, path) : path;
     }
     prefixDirectoryPath(path) {
-        return this.prefix.length > 0 ? (0, node_path_1.join)(this.prefix, path, '/') : (0, node_path_1.join)(path, '/');
+        return this.prefix.length > 0 ? join(this.prefix, path, '/') : join(path, '/');
     }
     stripFilePath(path) {
         return path.substring(this.prefix.length);
@@ -22,4 +19,3 @@ class PathPrefixer {
         return this.stripFilePath(path).replace(/\/+$/g, '');
     }
 }
-exports.PathPrefixer = PathPrefixer;

package/dist/esm/portable-visibility.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Visibility = void 0;
-var Visibility;
+export var Visibility;
 (function (Visibility) {
     Visibility["PUBLIC"] = "public";
     Visibility["PRIVATE"] = "private";
-})(Visibility || (exports.Visibility = Visibility = {}));
+})(Visibility || (Visibility = {}));

package/dist/types/checksum-from-stream.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { BinaryToTextEncoding } from 'crypto';
 import { Readable } from 'node:stream';
 export declare function checksumFromStream(stream: Readable, options: {

package/dist/types/file-storage.d.ts

@@ -1,6 +1,7 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
 import { BinaryToTextEncoding } from 'crypto';
 import { Readable } from 'stream';
 import { PathNormalizer } from './path-normalizer.js';
@@ -45,8 +46,14 @@ export interface StorageAdapter {
     lastModified(path: string): Promise<number>;
     fileSize(path: string): Promise<number>;
 }
-export interface DirectoryListing extends AsyncIterable<StatEntry> {
+export declare class DirectoryListing implements AsyncIterable<StatEntry> {
+    private readonly listing;
+    private readonly path;
+    private readonly deep;
+    constructor(listing: AsyncGenerator<StatEntry>, path: string, deep: boolean);
     toArray(sorted?: boolean): Promise<StatEntry[]>;
+    filter(filter: (entry: StatEntry) => boolean): DirectoryListing;
+    [Symbol.asyncIterator](): AsyncGenerator<StatEntry, void, unknown>;
 }
 export type FileContents = Iterable<any> | AsyncIterable<any> | NodeJS.ReadableStream | Readable;
 export type MiscellaneousOptions = {
@@ -86,6 +93,7 @@ export declare class FileStorage {
     read(path: string): Promise<Readable>;
     readToString(path: string): Promise<string>;
     readToUint8Array(path: string): Promise<Uint8Array>;
+    readToBuffer(path: string): Promise<Buffer>;
     deleteFile(path: string): Promise<void>;
     createDirectory(path: string, options?: CreateDirectoryOptions): Promise<void>;
     deleteDirectory(path: string): Promise<void>;

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@flystorage/file-storage",
-  "version": "0.0.3",
+  "type": "module",
+  "version": "0.0.5",
   "description": "File-storage abstraction: multiple filesystems, one API.",
   "main": "./dist/cjs/index.js",
   "types": "./dist/types/index.d.ts",
@@ -17,13 +18,18 @@
     }
   },
   "scripts": {
-    "compile": "concurrently npm:compile:*",
+    "compile": "concurrently npm:compile:* && echo '{\"type\": \"commonjs\"}' > ./dist/cjs/package.json",
     "compile:esm": "tsc --outDir ./dist/esm/ --declaration false",
     "compile:cjs": "tsc --outDir ./dist/cjs/ --declaration false --module commonjs --moduleResolution node",
     "compile:types": "tsc --outDir ./dist/types/ --declaration --emitDeclarationOnly",
     "watch": "tsc --watch"
   },
   "author": "Frank de Jonge (https://frankdejonge.nl)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/flystorage/flystorage.git",
+    "directory": "packages/file-storage"
+  },
   "keywords": ["fs", "file", "files", "filesystem", "filesystems", "storage"],
   "license": "MIT"
 }