@flystorage/file-storage 0.0.1

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

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

package/dist/cjs/errors.js

@@ -0,0 +1,103 @@
+"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.UnableToGetChecksum = exports.ChecksumIsNotAvailable = exports.FlystorageError = exports.errorToMessage = void 0;
+function errorToMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+exports.errorToMessage = errorToMessage;
+class FlystorageError extends Error {
+    context;
+    code = 'unknown_error';
+    constructor(message, context = {}, cause = undefined) {
+        const options = cause === undefined ? undefined : { cause };
+        // @ts-ignore TS2554
+        super(message, options);
+        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 {
+    algo;
+    code = 'flystorage.checksum_not_supported';
+    constructor(message, algo, context = {}, cause = undefined) {
+        super(message, context, cause);
+        this.algo = algo;
+    }
+    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 {
+    code = 'flystorage.unable_to_get_checksum';
+    static because = (reason, { context = {}, cause = undefined }) => new UnableToWriteFile(`Unable to write the file. Reason: ${reason}`, context, cause);
+}
+exports.UnableToGetChecksum = UnableToGetChecksum;
+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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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/cjs/file-storage.js

@@ -0,0 +1,235 @@
+"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) {
+    return stat.isFile;
+}
+exports.isFile = isFile;
+function isDirectory(stat) {
+    return stat.isDirectory;
+}
+exports.isDirectory = isDirectory;
+function toReadable(contents) {
+    if (contents instanceof stream_1.Readable) {
+        return contents;
+    }
+    return stream_1.Readable.from(contents);
+}
+const naturalSorting = new Intl.Collator(undefined, {
+    numeric: true,
+    sensitivity: 'base'
+});
+class FileStorage {
+    adapter;
+    pathNormalizer;
+    options;
+    constructor(adapter, pathNormalizer = new path_normalizer_js_1.PathNormalizerV1(), options = {}) {
+        this.adapter = adapter;
+        this.pathNormalizer = pathNormalizer;
+        this.options = options;
+    }
+    async write(path, contents, options = {}) {
+        try {
+            const body = toReadable(contents);
+            await this.adapter.write(this.pathNormalizer.normalizePath(path), body, Object.assign({}, this.options.writes || {}, options));
+            await closeReadable(body);
+        }
+        catch (error) {
+            throw errors.UnableToWriteFile.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async read(path) {
+        try {
+            return stream_1.Readable.from(await this.adapter.read(this.pathNormalizer.normalizePath(path)));
+        }
+        catch (error) {
+            throw errors.UnableToReadFile.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async readToString(path) {
+        return await readableToString(await this.read(path));
+    }
+    async readToUint8Array(path) {
+        return await readableToUint8Array(await this.read(path));
+    }
+    async deleteFile(path) {
+        try {
+            await this.adapter.deleteFile(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToDeleteFile.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async createDirectory(path, options = {}) {
+        try {
+            return await this.adapter.createDirectory(this.pathNormalizer.normalizePath(path), options);
+        }
+        catch (error) {
+            throw errors.UnableToCreateDirectory.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async deleteDirectory(path) {
+        try {
+            return await this.adapter.deleteDirectory(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToDeleteDirectory.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async stat(path) {
+        try {
+            return await this.adapter.stat(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToGetStat.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async setVisibility(path, visibility) {
+        try {
+            return await this.adapter.changeVisibility(this.pathNormalizer.normalizePath(path), visibility);
+        }
+        catch (error) {
+            throw errors.UnableToSetVisibility.because(errors.errorToMessage(error), { cause: error, context: { path, visibility } });
+        }
+    }
+    async visibility(path) {
+        try {
+            return await this.adapter.visibility(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToGetVisibility.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async fileExists(path) {
+        try {
+            return await this.adapter.fileExists(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToCheckFileExistence.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    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 } });
+                }
+            }
+        };
+    }
+    async statFile(path) {
+        const stat = await this.stat(path);
+        if (isFile(stat)) {
+            return stat;
+        }
+        throw errors.UnableToGetStat.noFileStatResolved({ context: { path } });
+    }
+    async directoryExists(path) {
+        try {
+            return await this.adapter.directoryExists(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToCheckDirectoryExistence.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async publicUrl(path, options = {}) {
+        try {
+            return await this.adapter.publicUrl(this.pathNormalizer.normalizePath(path), options);
+        }
+        catch (error) {
+            throw errors.UnableToGetPublicUrl.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async temporaryUrl(path, options) {
+        try {
+            return await this.adapter.temporaryUrl(this.pathNormalizer.normalizePath(path), options);
+        }
+        catch (error) {
+            throw errors.UnableToGetTemporaryUrl.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async checksum(path, options = {}) {
+        try {
+            return await this.adapter.checksum(this.pathNormalizer.normalizePath(path), options);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.ChecksumIsNotAvailable) {
+                return this.calculateChecksum(path, options);
+            }
+            throw errors.UnableToGetChecksum.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async calculateChecksum(path, options) {
+        try {
+            return await (0, checksum_from_stream_js_1.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) {
+    return expiresAt instanceof Date ? expiresAt : new Date(expiresAt);
+}
+exports.normalizeExpiryToDate = normalizeExpiryToDate;
+function normalizeExpiryToMilliseconds(expiresAt) {
+    return expiresAt instanceof Date ? expiresAt.getTime() : expiresAt;
+}
+exports.normalizeExpiryToMilliseconds = normalizeExpiryToMilliseconds;
+async function closeReadable(body) {
+    if (body.closed) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        body.on('close', (err) => {
+            err ? reject(err) : resolve();
+        });
+        body.destroy();
+    });
+}
+exports.closeReadable = closeReadable;
+const decoder = new TextDecoder();
+async function readableToString(stream) {
+    return decoder.decode(await readableToUint8Array(stream));
+}
+exports.readableToString = readableToString;
+function readableToUint8Array(stream) {
+    return new Promise((resolve, reject) => {
+        const parts = [];
+        stream.on('data', (chunk) => {
+            parts.push(chunk);
+        });
+        stream.on('error', reject);
+        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);
+    let position = 0;
+    input.forEach(i => {
+        output.set(i, position);
+        position += i.byteLength;
+    });
+    return output;
+}

package/dist/cjs/index.js

@@ -0,0 +1,22 @@
+"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);

package/dist/cjs/path-normalizer.js

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

package/dist/cjs/path-prefixer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathPrefixer = void 0;
+const node_path_1 = require("node:path");
+class PathPrefixer {
+    prefix = '';
+    constructor(prefix = '') {
+        if (prefix.length > 0) {
+            this.prefix = (0, node_path_1.join)(prefix, '/');
+        }
+    }
+    prefixFilePath(path) {
+        return this.prefix.length > 0 ? (0, node_path_1.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, '/');
+    }
+    stripFilePath(path) {
+        return path.substring(this.prefix.length);
+    }
+    stripDirectoryPath(path) {
+        return this.stripFilePath(path).replace(/\/+$/g, '');
+    }
+}
+exports.PathPrefixer = PathPrefixer;

package/dist/cjs/portable-visibility.js

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

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

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

package/dist/esm/errors.js

@@ -0,0 +1,103 @@
+"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.UnableToGetChecksum = exports.ChecksumIsNotAvailable = exports.FlystorageError = exports.errorToMessage = void 0;
+function errorToMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+exports.errorToMessage = errorToMessage;
+class FlystorageError extends Error {
+    context;
+    code = 'unknown_error';
+    constructor(message, context = {}, cause = undefined) {
+        const options = cause === undefined ? undefined : { cause };
+        // @ts-ignore TS2554
+        super(message, options);
+        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 {
+    algo;
+    code = 'flystorage.checksum_not_supported';
+    constructor(message, algo, context = {}, cause = undefined) {
+        super(message, context, cause);
+        this.algo = algo;
+    }
+    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 {
+    code = 'flystorage.unable_to_get_checksum';
+    static because = (reason, { context = {}, cause = undefined }) => new UnableToWriteFile(`Unable to write the file. Reason: ${reason}`, context, cause);
+}
+exports.UnableToGetChecksum = UnableToGetChecksum;
+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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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 {
+    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

@@ -0,0 +1,235 @@
+"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) {
+    return stat.isFile;
+}
+exports.isFile = isFile;
+function isDirectory(stat) {
+    return stat.isDirectory;
+}
+exports.isDirectory = isDirectory;
+function toReadable(contents) {
+    if (contents instanceof stream_1.Readable) {
+        return contents;
+    }
+    return stream_1.Readable.from(contents);
+}
+const naturalSorting = new Intl.Collator(undefined, {
+    numeric: true,
+    sensitivity: 'base'
+});
+class FileStorage {
+    adapter;
+    pathNormalizer;
+    options;
+    constructor(adapter, pathNormalizer = new path_normalizer_js_1.PathNormalizerV1(), options = {}) {
+        this.adapter = adapter;
+        this.pathNormalizer = pathNormalizer;
+        this.options = options;
+    }
+    async write(path, contents, options = {}) {
+        try {
+            const body = toReadable(contents);
+            await this.adapter.write(this.pathNormalizer.normalizePath(path), body, Object.assign({}, this.options.writes || {}, options));
+            await closeReadable(body);
+        }
+        catch (error) {
+            throw errors.UnableToWriteFile.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async read(path) {
+        try {
+            return stream_1.Readable.from(await this.adapter.read(this.pathNormalizer.normalizePath(path)));
+        }
+        catch (error) {
+            throw errors.UnableToReadFile.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async readToString(path) {
+        return await readableToString(await this.read(path));
+    }
+    async readToUint8Array(path) {
+        return await readableToUint8Array(await this.read(path));
+    }
+    async deleteFile(path) {
+        try {
+            await this.adapter.deleteFile(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToDeleteFile.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async createDirectory(path, options = {}) {
+        try {
+            return await this.adapter.createDirectory(this.pathNormalizer.normalizePath(path), options);
+        }
+        catch (error) {
+            throw errors.UnableToCreateDirectory.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async deleteDirectory(path) {
+        try {
+            return await this.adapter.deleteDirectory(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToDeleteDirectory.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async stat(path) {
+        try {
+            return await this.adapter.stat(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToGetStat.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async setVisibility(path, visibility) {
+        try {
+            return await this.adapter.changeVisibility(this.pathNormalizer.normalizePath(path), visibility);
+        }
+        catch (error) {
+            throw errors.UnableToSetVisibility.because(errors.errorToMessage(error), { cause: error, context: { path, visibility } });
+        }
+    }
+    async visibility(path) {
+        try {
+            return await this.adapter.visibility(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToGetVisibility.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async fileExists(path) {
+        try {
+            return await this.adapter.fileExists(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToCheckFileExistence.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    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 } });
+                }
+            }
+        };
+    }
+    async statFile(path) {
+        const stat = await this.stat(path);
+        if (isFile(stat)) {
+            return stat;
+        }
+        throw errors.UnableToGetStat.noFileStatResolved({ context: { path } });
+    }
+    async directoryExists(path) {
+        try {
+            return await this.adapter.directoryExists(this.pathNormalizer.normalizePath(path));
+        }
+        catch (error) {
+            throw errors.UnableToCheckDirectoryExistence.because(errors.errorToMessage(error), { cause: error, context: { path } });
+        }
+    }
+    async publicUrl(path, options = {}) {
+        try {
+            return await this.adapter.publicUrl(this.pathNormalizer.normalizePath(path), options);
+        }
+        catch (error) {
+            throw errors.UnableToGetPublicUrl.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async temporaryUrl(path, options) {
+        try {
+            return await this.adapter.temporaryUrl(this.pathNormalizer.normalizePath(path), options);
+        }
+        catch (error) {
+            throw errors.UnableToGetTemporaryUrl.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async checksum(path, options = {}) {
+        try {
+            return await this.adapter.checksum(this.pathNormalizer.normalizePath(path), options);
+        }
+        catch (error) {
+            if (error instanceof errors_js_1.ChecksumIsNotAvailable) {
+                return this.calculateChecksum(path, options);
+            }
+            throw errors.UnableToGetChecksum.because(errors.errorToMessage(error), { cause: error, context: { path, options } });
+        }
+    }
+    async calculateChecksum(path, options) {
+        try {
+            return await (0, checksum_from_stream_js_1.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) {
+    return expiresAt instanceof Date ? expiresAt : new Date(expiresAt);
+}
+exports.normalizeExpiryToDate = normalizeExpiryToDate;
+function normalizeExpiryToMilliseconds(expiresAt) {
+    return expiresAt instanceof Date ? expiresAt.getTime() : expiresAt;
+}
+exports.normalizeExpiryToMilliseconds = normalizeExpiryToMilliseconds;
+async function closeReadable(body) {
+    if (body.closed) {
+        return;
+    }
+    await new Promise((resolve, reject) => {
+        body.on('close', (err) => {
+            err ? reject(err) : resolve();
+        });
+        body.destroy();
+    });
+}
+exports.closeReadable = closeReadable;
+const decoder = new TextDecoder();
+async function readableToString(stream) {
+    return decoder.decode(await readableToUint8Array(stream));
+}
+exports.readableToString = readableToString;
+function readableToUint8Array(stream) {
+    return new Promise((resolve, reject) => {
+        const parts = [];
+        stream.on('data', (chunk) => {
+            parts.push(chunk);
+        });
+        stream.on('error', reject);
+        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);
+    let position = 0;
+    input.forEach(i => {
+        output.set(i, position);
+        position += i.byteLength;
+    });
+    return output;
+}

package/dist/esm/index.js

@@ -0,0 +1,22 @@
+"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);

package/dist/esm/path-normalizer.js

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

package/dist/esm/path-prefixer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathPrefixer = void 0;
+const node_path_1 = require("node:path");
+class PathPrefixer {
+    prefix = '';
+    constructor(prefix = '') {
+        if (prefix.length > 0) {
+            this.prefix = (0, node_path_1.join)(prefix, '/');
+        }
+    }
+    prefixFilePath(path) {
+        return this.prefix.length > 0 ? (0, node_path_1.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, '/');
+    }
+    stripFilePath(path) {
+        return path.substring(this.prefix.length);
+    }
+    stripDirectoryPath(path) {
+        return this.stripFilePath(path).replace(/\/+$/g, '');
+    }
+}
+exports.PathPrefixer = PathPrefixer;

package/dist/esm/portable-visibility.js

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

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

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { BinaryToTextEncoding } from 'crypto';
+import { Readable } from 'node:stream';
+export declare function checksumFromStream(stream: Readable, options: {
+    algo?: string;
+    encoding?: BinaryToTextEncoding;
+}): Promise<string>;

package/dist/types/errors.d.ts

@@ -0,0 +1,128 @@
+export type ErrorContext = {
+    [index: string]: any;
+};
+export type OperationError = Error & {
+    readonly code: string;
+    readonly context: ErrorContext;
+};
+export declare function errorToMessage(error: unknown): string;
+export declare abstract class FlystorageError extends Error implements OperationError {
+    readonly context: ErrorContext;
+    readonly code: string;
+    constructor(message: string, context?: ErrorContext, cause?: unknown);
+}
+/**
+ * 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.
+ */
+export declare class ChecksumIsNotAvailable extends FlystorageError {
+    readonly algo: string;
+    readonly code = "flystorage.checksum_not_supported";
+    constructor(message: string, algo: string, context?: ErrorContext, cause?: unknown);
+    static checksumNotSupported: (algo: string, { context, cause }?: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => ChecksumIsNotAvailable;
+}
+export declare class UnableToGetChecksum extends FlystorageError {
+    readonly code = "flystorage.unable_to_get_checksum";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToWriteFile;
+}
+export declare class UnableToWriteFile extends FlystorageError {
+    readonly code = "flystorage.unable_to_write_file";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToWriteFile;
+}
+export declare class UnableToReadFile extends FlystorageError {
+    readonly code = "flystorage.unable_to_read_file";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToReadFile;
+}
+export declare class UnableToSetVisibility extends FlystorageError {
+    readonly code = "flystorage.unable_to_set_visibility";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToSetVisibility;
+}
+export declare class UnableToGetVisibility extends FlystorageError {
+    readonly code = "flystorage.unable_to_get_visibility";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToGetVisibility;
+}
+export declare class UnableToGetPublicUrl extends FlystorageError {
+    readonly code = "flystorage.unable_to_get_public_url";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToGetPublicUrl;
+}
+export declare class UnableToGetTemporaryUrl extends FlystorageError {
+    readonly code = "flystorage.unable_to_get_temporary_url";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToGetTemporaryUrl;
+}
+export declare class UnableToGetStat extends FlystorageError {
+    readonly code = "flystorage.unable_to_get_stat";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToGetStat;
+    static noFileStatResolved: ({ context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToGetStat;
+}
+export declare class UnableToCreateDirectory extends FlystorageError {
+    readonly code = "flystorage.unable_to_create_directory";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToCreateDirectory;
+}
+export declare class UnableToDeleteDirectory extends FlystorageError {
+    readonly code = "flystorage.unable_to_delete_directory";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToDeleteDirectory;
+}
+export declare class UnableToDeleteFile extends FlystorageError {
+    readonly code = "flystorage.unable_to_delete_file";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToDeleteFile;
+}
+export declare class UnableToCheckFileExistence extends FlystorageError {
+    readonly code = "flystorage.unable_to_check_file_existence";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToCheckFileExistence;
+}
+export declare class UnableToCheckDirectoryExistence extends FlystorageError {
+    readonly code = "flystorage.unable_to_check_directory_existence";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToCheckDirectoryExistence;
+}
+export declare class UnableToListDirectory extends FlystorageError {
+    readonly code = "flystorage.unable_to_list_directory_contents";
+    static because: (reason: string, { context, cause }: {
+        context?: ErrorContext | undefined;
+        cause?: unknown;
+    }) => UnableToListDirectory;
+}

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

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { BinaryToTextEncoding } from 'crypto';
+import { Readable } from 'stream';
+import { PathNormalizer } from './path-normalizer.js';
+export type CommonStatInfo = Readonly<{
+    path: string;
+    lastModifiedMs?: number;
+    visibility?: string;
+}>;
+export type FileInfo = Readonly<{
+    type: 'file';
+    size?: number;
+    isFile: true;
+    isDirectory: false;
+    mimeType?: string;
+} & CommonStatInfo>;
+export type DirectoryInfo = Readonly<{
+    type: 'directory';
+    isFile: false;
+    isDirectory: true;
+} & CommonStatInfo>;
+export declare function isFile(stat: StatEntry): stat is FileInfo;
+export declare function isDirectory(stat: StatEntry): stat is DirectoryInfo;
+export type StatEntry = FileInfo | DirectoryInfo;
+export interface StorageAdapter {
+    write(path: string, contents: Readable, options: WriteOptions): Promise<void>;
+    read(path: string): Promise<FileContents>;
+    deleteFile(path: string): Promise<void>;
+    createDirectory(path: string, options: CreateDirectoryOptions): Promise<void>;
+    stat(path: string): Promise<StatEntry>;
+    list(path: string, options: {
+        deep: boolean;
+    }): AsyncGenerator<StatEntry>;
+    changeVisibility(path: string, visibility: string): Promise<void>;
+    visibility(path: string): Promise<string>;
+    deleteDirectory(path: string): Promise<void>;
+    fileExists(path: string): Promise<boolean>;
+    directoryExists(path: string): Promise<boolean>;
+    publicUrl(path: string, options: PublicUrlOptions): Promise<string>;
+    temporaryUrl(path: string, options: TemporaryUrlOptions): Promise<string>;
+    checksum(path: string, options: ChecksumOptions): Promise<string>;
+}
+export interface DirectoryListing extends AsyncIterable<StatEntry> {
+    toArray(sorted?: boolean): Promise<StatEntry[]>;
+}
+export type FileContents = Iterable<any> | AsyncIterable<any> | NodeJS.ReadableStream | Readable;
+export type MiscellaneousOptions = {
+    [option: string]: any;
+};
+export type VisibilityOptions = {
+    visibility?: string;
+    directoryVisibility?: string;
+};
+export type WriteOptions = VisibilityOptions & MiscellaneousOptions & {
+    mimeType?: string;
+    size?: number;
+};
+export type CreateDirectoryOptions = MiscellaneousOptions & Pick<VisibilityOptions, 'directoryVisibility'> & {};
+export type PublicUrlOptions = MiscellaneousOptions & {};
+export type TemporaryUrlOptions = MiscellaneousOptions & {
+    expiresAt: ExpiresAt;
+};
+export type ChecksumOptions = MiscellaneousOptions & {
+    algo?: string;
+    encoding?: BinaryToTextEncoding;
+};
+export type ConfigurationOptions = {
+    defaults?: VisibilityOptions;
+    writes?: WriteOptions;
+};
+export declare class FileStorage {
+    private readonly adapter;
+    private readonly pathNormalizer;
+    private readonly options;
+    constructor(adapter: StorageAdapter, pathNormalizer?: PathNormalizer, options?: ConfigurationOptions);
+    write(path: string, contents: FileContents, options?: WriteOptions): Promise<void>;
+    read(path: string): Promise<Readable>;
+    readToString(path: string): Promise<string>;
+    readToUint8Array(path: string): Promise<Uint8Array>;
+    deleteFile(path: string): Promise<void>;
+    createDirectory(path: string, options?: CreateDirectoryOptions): Promise<void>;
+    deleteDirectory(path: string): Promise<void>;
+    stat(path: string): Promise<StatEntry>;
+    setVisibility(path: string, visibility: string): Promise<void>;
+    visibility(path: string): Promise<string>;
+    fileExists(path: string): Promise<boolean>;
+    list(path: string, { deep }?: {
+        deep?: boolean;
+    }): DirectoryListing;
+    statFile(path: string): Promise<FileInfo>;
+    directoryExists(path: string): Promise<boolean>;
+    publicUrl(path: string, options?: PublicUrlOptions): Promise<string>;
+    temporaryUrl(path: string, options: TemporaryUrlOptions): Promise<string>;
+    checksum(path: string, options?: ChecksumOptions): Promise<string>;
+    private calculateChecksum;
+}
+export type TimestampMs = number;
+export type ExpiresAt = Date | TimestampMs;
+export declare function normalizeExpiryToDate(expiresAt: ExpiresAt): Date;
+export declare function normalizeExpiryToMilliseconds(expiresAt: ExpiresAt): number;
+export declare function closeReadable(body: Readable): Promise<void>;
+export declare function readableToString(stream: Readable): Promise<string>;
+export declare function readableToUint8Array(stream: Readable): Promise<Uint8Array>;

package/dist/types/index.d.ts

@@ -0,0 +1,6 @@
+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/types/path-normalizer.d.ts

@@ -0,0 +1,12 @@
+export interface PathNormalizer {
+    normalizePath(path: string): string;
+}
+export declare class PathNormalizerV1 implements PathNormalizer {
+    normalizePath(path: string): string;
+}
+export declare class CorruptedPathDetected extends Error {
+    static unexpectedWhitespace: (path: string) => CorruptedPathDetected;
+}
+export declare class PathTraversalDetected extends Error {
+    static forPath: (path: string) => PathTraversalDetected;
+}

package/dist/types/path-prefixer.d.ts

@@ -0,0 +1,8 @@
+export declare class PathPrefixer {
+    private readonly prefix;
+    constructor(prefix?: string);
+    prefixFilePath(path: string): string;
+    prefixDirectoryPath(path: string): string;
+    stripFilePath(path: string): string;
+    stripDirectoryPath(path: string): string;
+}

package/dist/types/portable-visibility.d.ts

@@ -0,0 +1,4 @@
+export declare enum Visibility {
+    PUBLIC = "public",
+    PRIVATE = "private"
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@flystorage/file-storage",
+  "version": "0.0.1",
+  "description": "File-storage abstraction: multiple filesystems, one API.",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "default": "./dist/esm/index.js",
+        "types": "./dist/types/index.d.ts"
+      },
+      "require": {
+        "default": "./dist/cjs/index.js",
+        "types": "./dist/types/index.d.ts"
+      }
+    }
+  },
+  "scripts": {
+    "compile": "concurrently npm:compile:*",
+    "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)",
+  "keywords": ["fs", "file", "files", "filesystem", "filesystems", "storage"],
+  "license": "MIT"
+}