@daiso-tech/core 0.48.5 → 0.49.0

package/dist/file-storage/implementations/derivables/file-storage/file.js

@@ -0,0 +1,722 @@
+/**
+ * @module FileStorage
+ */
+import { Buffer } from "node:buffer";
+import { Readable } from "stream";
+import { lookup } from "mime-types";
+import {} from "../../../../event-bus/contracts/_module.js";
+import { TO_BYTES } from "../../../../file-size/contracts/_module.js";
+import { FileSize } from "../../../../file-size/implementations/_module.js";
+import { KeyExistsFileError, KeyNotFoundFileError, isFileError, FILE_EVENTS, FILE_WRITE_ENUM, InvalidKeyFileError, } from "../../../../file-storage/contracts/_module.js";
+import { resolveFileContent } from "../../../../file-storage/implementations/derivables/file-storage/resolve-file-content.js";
+import { ResolveFileStream } from "../../../../file-storage/implementations/derivables/file-storage/resolve-file-stream.js";
+import {} from "../../../../hooks/_module.js";
+import {} from "../../../../namespace/contracts/_module.js";
+import {} from "../../../../task/contracts/_module.js";
+import { Task } from "../../../../task/implementations/_module.js";
+import { TimeSpan } from "../../../../time-span/implementations/_module.js";
+import {} from "../../../../utilities/_module.js";
+/**
+ * @internal
+ */
+export class File {
+    /**
+     * @internal
+     */
+    static _internal_serialize(deserializedValue) {
+        return {
+            version: "1",
+            key: deserializedValue._key.get(),
+        };
+    }
+    originalAdapter;
+    adapter;
+    _key;
+    eventDispatcher;
+    serdeTransformerName;
+    namespace;
+    defaultContentType;
+    defaultContentDisposition;
+    defaultContentEncoding;
+    defaultCacheControl;
+    defaultContentLanguage;
+    onlyLowercase;
+    keyValidator;
+    constructor(settings) {
+        const { onlyLowercase, keyValidator, adapter, key, eventDispatcher, serdeTransformerName, namespace, defaultContentType, defaultContentDisposition, defaultContentEncoding, defaultCacheControl, defaultContentLanguage, originalAdapter, } = settings;
+        this.onlyLowercase = onlyLowercase;
+        this.keyValidator = keyValidator;
+        this.originalAdapter = originalAdapter;
+        this.defaultContentType = defaultContentType;
+        this.adapter = adapter;
+        this._key = key;
+        this.eventDispatcher = eventDispatcher;
+        this.serdeTransformerName = serdeTransformerName;
+        this.namespace = namespace;
+        this.defaultContentDisposition = defaultContentDisposition;
+        this.defaultContentEncoding = defaultContentEncoding;
+        this.defaultCacheControl = defaultCacheControl;
+        this.defaultContentLanguage = defaultContentLanguage;
+        this.handleKey(this._key);
+    }
+    handleKey(key) {
+        let rawKey = key.toString();
+        if (this.onlyLowercase) {
+            rawKey = rawKey.toLowerCase();
+        }
+        const validationMessage = this.keyValidator(rawKey);
+        if (validationMessage !== null) {
+            throw InvalidKeyFileError.create(validationMessage);
+        }
+        return rawKey;
+    }
+    _internal_getNamespace() {
+        return this.namespace;
+    }
+    _internal_getSerdeTransformerName() {
+        return this.serdeTransformerName;
+    }
+    _internal_getAdapter() {
+        return this.originalAdapter;
+    }
+    get key() {
+        return this._key;
+    }
+    handleUnexpectedErrorEvent = () => {
+        return async (args, next) => {
+            try {
+                return await next(...args);
+            }
+            catch (error) {
+                if (isFileError(error)) {
+                    throw error;
+                }
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.UNEXPECTED_ERROR, {
+                    error,
+                    file: this,
+                })
+                    .detach();
+                throw error;
+            }
+        };
+    };
+    handleNullableFoundEvent() {
+        return async (args, next) => {
+            const value = await next(...args);
+            if (value === null) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.NOT_FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            else {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            return value;
+        };
+    }
+    handleBooleanFoundEvent() {
+        return async (args, next) => {
+            const exists = await next(...args);
+            if (exists) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            else {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.NOT_FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            return exists;
+        };
+    }
+    getText() {
+        return new Task(async () => {
+            const bytes = await this.getBytes();
+            if (bytes === null) {
+                return null;
+            }
+            return new TextDecoder().decode(bytes);
+        });
+    }
+    getTextOrFail() {
+        return new Task(async () => {
+            const text = await this.getText();
+            if (text === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return text;
+        });
+    }
+    getBytes() {
+        return new Task(async () => {
+            return await this.adapter.getBytes(this._key.toString());
+        }).pipe([
+            this.handleUnexpectedErrorEvent(),
+            this.handleNullableFoundEvent(),
+        ]);
+    }
+    getBytesOrFail() {
+        return new Task(async () => {
+            const bytes = await this.getBytes();
+            if (bytes === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return bytes;
+        });
+    }
+    getBuffer() {
+        return new Task(async () => {
+            const bytes = await this.getBytes();
+            if (bytes === null) {
+                return null;
+            }
+            return Buffer.from(bytes);
+        });
+    }
+    getBufferOrFail() {
+        return new Task(async () => {
+            const buffer = await this.getBuffer();
+            if (buffer === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return buffer;
+        });
+    }
+    getArrayBuffer() {
+        return new Task(async () => {
+            const bytes = await this.getBuffer();
+            if (bytes === null) {
+                return null;
+            }
+            return new Uint8Array(Buffer.from(bytes)).buffer;
+        });
+    }
+    getArrayBufferOrFail() {
+        return new Task(async () => {
+            const arrayBuffer = await this.getArrayBuffer();
+            if (arrayBuffer === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return arrayBuffer;
+        });
+    }
+    getReadable() {
+        return new Task(async () => {
+            const stream = await this.adapter.getStream(this._key.toString());
+            if (stream === null) {
+                return null;
+            }
+            return Readable.from(stream);
+        }).pipe([
+            this.handleUnexpectedErrorEvent(),
+            this.handleNullableFoundEvent(),
+        ]);
+    }
+    getReadableOrFail() {
+        return new Task(async () => {
+            const stream = await this.getReadable();
+            if (stream === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return stream;
+        });
+    }
+    getReadableStream() {
+        return new Task(async () => {
+            const stream = await this.adapter.getStream(this._key.toString());
+            if (stream === null) {
+                return null;
+            }
+            return ReadableStream.from(stream);
+        }).pipe([
+            this.handleUnexpectedErrorEvent(),
+            this.handleNullableFoundEvent(),
+        ]);
+    }
+    getReadableStreamOrFail() {
+        return new Task(async () => {
+            const stream = await this.getReadableStream();
+            if (stream === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return stream;
+        });
+    }
+    getMetadata() {
+        return new Task(async () => {
+            const metadata = await this.adapter.getMetaData(this._key.toString());
+            if (metadata === null) {
+                return null;
+            }
+            return {
+                contentType: metadata.contentType,
+                etag: metadata.etag,
+                updatedAt: metadata.updatedAt,
+                fileSize: FileSize.fromBytes(metadata.fileSizeInBytes),
+            };
+        }).pipe([
+            this.handleUnexpectedErrorEvent(),
+            this.handleNullableFoundEvent(),
+        ]);
+    }
+    getMetadataOrFail() {
+        return new Task(async () => {
+            const metadata = await this.getMetadata();
+            if (metadata === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return metadata;
+        });
+    }
+    exists() {
+        return new Task(async () => {
+            return await this.adapter.exists(this._key.toString());
+        }).pipe([
+            this.handleUnexpectedErrorEvent(),
+            this.handleBooleanFoundEvent(),
+        ]);
+    }
+    missing() {
+        return new Task(async () => {
+            return !(await this.exists());
+        });
+    }
+    handleAddEvent() {
+        return async (args, next) => {
+            const hasAdded = await next(...args);
+            if (hasAdded) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.ADDED, {
+                    file: this,
+                })
+                    .detach();
+            }
+            else {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.KEY_EXISTS, {
+                    file: this,
+                })
+                    .detach();
+            }
+            return hasAdded;
+        };
+    }
+    add(content) {
+        return new Task(async () => {
+            const { data, contentType = this.getContentType(this._key.get()) } = content;
+            const resolvedData = resolveFileContent(data);
+            return await this.adapter.add(this._key.toString(), {
+                data: resolvedData,
+                contentType,
+                contentDisposition: this.defaultContentDisposition,
+                contentEncoding: this.defaultContentEncoding,
+                cacheControl: this.defaultCacheControl,
+                contentLanguage: this.defaultContentLanguage,
+                fileSizeInBytes: resolvedData.length,
+            });
+        }).pipe([this.handleUnexpectedErrorEvent(), this.handleAddEvent()]);
+    }
+    addOrFail(content) {
+        return new Task(async () => {
+            const hasAdded = await this.add(content);
+            if (!hasAdded) {
+                throw KeyExistsFileError.create(this._key);
+            }
+        });
+    }
+    getContentType(key) {
+        let resolvedContentType = lookup(key);
+        if (resolvedContentType === false) {
+            resolvedContentType = this.defaultContentType;
+        }
+        return resolvedContentType;
+    }
+    addStream(stream) {
+        return new Task(async () => {
+            const { data, fileSize = null, contentType = this.getContentType(this._key.get()), } = stream;
+            return await this.adapter.addStream(this._key.toString(), {
+                data: new ResolveFileStream(data),
+                fileSizeInBytes: fileSize?.[TO_BYTES]() ?? null,
+                contentType,
+                contentDisposition: this.defaultContentDisposition,
+                contentEncoding: this.defaultContentEncoding,
+                cacheControl: this.defaultCacheControl,
+                contentLanguage: this.defaultContentLanguage,
+            });
+        }).pipe([this.handleUnexpectedErrorEvent(), this.handleAddEvent()]);
+    }
+    addStreamOrFail(stream) {
+        return new Task(async () => {
+            const hasAdded = await this.addStream(stream);
+            if (!hasAdded) {
+                throw KeyExistsFileError.create(this._key);
+            }
+        });
+    }
+    handleUpdateEvent() {
+        return async (args, next) => {
+            const hasUpdated = await next(...args);
+            if (hasUpdated) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.UPDATED, {
+                    file: this,
+                })
+                    .detach();
+            }
+            else {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.NOT_FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            return hasUpdated;
+        };
+    }
+    update(content) {
+        return new Task(async () => {
+            const { data, contentType = this.getContentType(this._key.get()) } = content;
+            const resolvedData = resolveFileContent(data);
+            return await this.adapter.update(this._key.toString(), {
+                data: resolvedData,
+                contentType,
+                contentDisposition: this.defaultContentDisposition,
+                contentEncoding: this.defaultContentEncoding,
+                cacheControl: this.defaultCacheControl,
+                contentLanguage: this.defaultContentLanguage,
+                fileSizeInBytes: resolvedData.length,
+            });
+        }).pipe([this.handleUnexpectedErrorEvent(), this.handleUpdateEvent()]);
+    }
+    updateOrFail(content) {
+        return new Task(async () => {
+            const hasUpdated = await this.update(content);
+            if (!hasUpdated) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+        });
+    }
+    updateStream(stream) {
+        return new Task(async () => {
+            const { data, fileSize = null, contentType = this.getContentType(this._key.get()), } = stream;
+            return await this.adapter.updateStream(this._key.toString(), {
+                data: new ResolveFileStream(data),
+                fileSizeInBytes: fileSize?.[TO_BYTES]() ?? null,
+                contentType,
+                contentDisposition: this.defaultContentDisposition,
+                contentEncoding: this.defaultContentEncoding,
+                cacheControl: this.defaultCacheControl,
+                contentLanguage: this.defaultContentLanguage,
+            });
+        }).pipe([this.handleUnexpectedErrorEvent(), this.handleUpdateEvent()]);
+    }
+    updateStreamOrFail(stream) {
+        return new Task(async () => {
+            const hasUpdated = await this.updateStream(stream);
+            if (!hasUpdated) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+        });
+    }
+    handlePutEvent() {
+        return async (args, next) => {
+            const hasUpdated = await next(...args);
+            if (hasUpdated) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.UPDATED, {
+                    file: this,
+                })
+                    .detach();
+            }
+            else {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.ADDED, {
+                    file: this,
+                })
+                    .detach();
+            }
+            return hasUpdated;
+        };
+    }
+    put(content) {
+        return new Task(async () => {
+            const { data, contentType = this.getContentType(this._key.get()) } = content;
+            const resolvedData = resolveFileContent(data);
+            return await this.adapter.put(this._key.toString(), {
+                data: resolvedData,
+                contentType,
+                contentDisposition: this.defaultContentDisposition,
+                contentEncoding: this.defaultContentEncoding,
+                cacheControl: this.defaultCacheControl,
+                contentLanguage: this.defaultContentLanguage,
+                fileSizeInBytes: resolvedData.length,
+            });
+        }).pipe([this.handleUnexpectedErrorEvent(), this.handlePutEvent()]);
+    }
+    putStream(stream) {
+        return new Task(async () => {
+            const { data, fileSize = null, contentType = this.getContentType(this._key.get()), } = stream;
+            return await this.adapter.putStream(this._key.toString(), {
+                data: new ResolveFileStream(data),
+                fileSizeInBytes: fileSize?.[TO_BYTES]() ?? null,
+                contentType,
+                contentDisposition: this.defaultContentDisposition,
+                contentEncoding: this.defaultContentEncoding,
+                cacheControl: this.defaultCacheControl,
+                contentLanguage: this.defaultContentLanguage,
+            });
+        }).pipe([this.handleUnexpectedErrorEvent(), this.handlePutEvent()]);
+    }
+    handleRemoveEvent() {
+        return async (args, next) => {
+            const hasRemoved = await next(...args);
+            if (hasRemoved) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.REMOVED, {
+                    file: this,
+                })
+                    .detach();
+            }
+            else {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.NOT_FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            return hasRemoved;
+        };
+    }
+    remove() {
+        return new Task(async () => {
+            return await this.adapter.removeMany([this.key.toString()]);
+        }).pipe(this.handleRemoveEvent());
+    }
+    removeOrFail() {
+        return new Task(async () => {
+            const hasFound = await this.remove();
+            if (!hasFound) {
+                throw KeyNotFoundFileError.create(this.key);
+            }
+        }).pipe([this.handleUnexpectedErrorEvent()]);
+    }
+    _copy(destination) {
+        return new Task(async () => {
+            const destinationKey = this.namespace.create(destination);
+            const result = await this.adapter.copy(this._key.toString(), destinationKey.toString());
+            if (result === FILE_WRITE_ENUM.KEY_EXISTS) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.DESTINATION_EXISTS, {
+                    source: this,
+                    destination: destinationKey,
+                })
+                    .detach();
+            }
+            if (result === FILE_WRITE_ENUM.NOT_FOUND) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.NOT_FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            if (result === FILE_WRITE_ENUM.SUCCESS) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.COPIED, {
+                    source: this,
+                    destination: destinationKey,
+                    replaced: false,
+                })
+                    .detach();
+            }
+            return result;
+        }).pipe([this.handleUnexpectedErrorEvent()]);
+    }
+    copy(destination) {
+        return new Task(async () => {
+            const result = await this._copy(destination);
+            return result === FILE_WRITE_ENUM.SUCCESS;
+        });
+    }
+    copyOrFail(destination) {
+        return new Task(async () => {
+            const result = await this._copy(destination);
+            if (result === FILE_WRITE_ENUM.KEY_EXISTS) {
+                throw KeyExistsFileError.create(this._key);
+            }
+            if (result === FILE_WRITE_ENUM.NOT_FOUND) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+        });
+    }
+    copyAndReplace(destination) {
+        return new Task(async () => {
+            const destinationKey = this.namespace.create(destination);
+            const hasCopied = await this.adapter.copyAndReplace(this._key.toString(), destinationKey.toString());
+            if (hasCopied) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.COPIED, {
+                    source: this,
+                    destination: destinationKey,
+                    replaced: true,
+                })
+                    .detach();
+            }
+            else {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.NOT_FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            return hasCopied;
+        }).pipe([this.handleUnexpectedErrorEvent()]);
+    }
+    copyAndReplaceOrFail(destination) {
+        return new Task(async () => {
+            const hasCopied = await this.copyAndReplace(destination);
+            if (!hasCopied) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+        });
+    }
+    _move(destination) {
+        return new Task(async () => {
+            const destinationKey = this.namespace.create(destination);
+            const result = await this.adapter.move(this._key.toString(), destinationKey.toString());
+            if (result === FILE_WRITE_ENUM.KEY_EXISTS) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.DESTINATION_EXISTS, {
+                    source: this,
+                    destination: destinationKey,
+                })
+                    .detach();
+            }
+            if (result === FILE_WRITE_ENUM.NOT_FOUND) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.NOT_FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            if (result === FILE_WRITE_ENUM.SUCCESS) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.MOVED, {
+                    source: this,
+                    destination: destinationKey,
+                    replaced: false,
+                })
+                    .detach();
+            }
+            return result;
+        }).pipe([this.handleUnexpectedErrorEvent()]);
+    }
+    move(destination) {
+        return new Task(async () => {
+            const result = await this._move(destination);
+            return result === FILE_WRITE_ENUM.SUCCESS;
+        });
+    }
+    moveOrFail(destination) {
+        return new Task(async () => {
+            const result = await this._move(destination);
+            if (result === FILE_WRITE_ENUM.KEY_EXISTS) {
+                throw KeyExistsFileError.create(this._key);
+            }
+            if (result === FILE_WRITE_ENUM.NOT_FOUND) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+        });
+    }
+    moveAndReplace(destination) {
+        return new Task(async () => {
+            const destinationKey = this.namespace.create(destination);
+            const hasMoved = await this.adapter.moveAndReplace(this._key.toString(), destinationKey.toString());
+            if (hasMoved) {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.MOVED, {
+                    source: this,
+                    destination: destinationKey,
+                    replaced: true,
+                })
+                    .detach();
+            }
+            else {
+                this.eventDispatcher
+                    .dispatch(FILE_EVENTS.NOT_FOUND, {
+                    file: this,
+                })
+                    .detach();
+            }
+            return hasMoved;
+        }).pipe([this.handleUnexpectedErrorEvent()]);
+    }
+    moveAndReplaceOrFail(destination) {
+        return new Task(async () => {
+            const hasCopied = await this.moveAndReplace(destination);
+            if (!hasCopied) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+        });
+    }
+    getPublicUrl() {
+        return new Task(async () => {
+            return await this.adapter.getPublicUrl(this.key.toString());
+        }).pipe([
+            this.handleUnexpectedErrorEvent(),
+            this.handleNullableFoundEvent(),
+        ]);
+    }
+    getPublicUrlOrFail() {
+        return new Task(async () => {
+            const url = await this.getPublicUrl();
+            if (url === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return url;
+        });
+    }
+    getSignedUploadUrl(options = {}) {
+        return new Task(async () => {
+            const { ttl = TimeSpan.fromMinutes(10), contentType = null } = options;
+            return await this.adapter.getSignedUploadUrl(this._key.toString(), {
+                expirationInSeconds: TimeSpan.fromTimeSpan(ttl).toSeconds(),
+                contentType,
+            });
+        });
+    }
+    getSignedDownloadUrl(options = {}) {
+        return new Task(async () => {
+            const { ttl: expiration = TimeSpan.fromMinutes(10), contentType = null, contentDisposition = null, } = options;
+            return await this.adapter.getSignedDownloadUrl(this._key.toString(), {
+                expirationInSeconds: TimeSpan.fromTimeSpan(expiration).toSeconds(),
+                contentType,
+                contentDisposition,
+            });
+        }).pipe([
+            this.handleUnexpectedErrorEvent(),
+            this.handleNullableFoundEvent(),
+        ]);
+    }
+    getSignedDownloadUrlOrFail(options) {
+        return new Task(async () => {
+            const url = await this.getSignedDownloadUrl(options);
+            if (url === null) {
+                throw KeyNotFoundFileError.create(this._key);
+            }
+            return url;
+        });
+    }
+}
+//# sourceMappingURL=file.js.map