@m5kdev/backend 0.1.0 → 0.1.2

package/dist/src/modules/file/file.service.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileService = void 0;
+const tslib_1 = require("tslib");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = tslib_1.__importStar(require("node:path"));
+const node_stream_1 = require("node:stream");
+const promises_2 = require("node:stream/promises");
+const file_constants_1 = require("@m5kdev/commons/modules/file/file.constants");
+const neverthrow_1 = require("neverthrow");
+const uuid_1 = require("uuid");
+const base_service_1 = require("#modules/base/base.service");
+class FileService extends base_service_1.BaseService {
+    isS3Path(path) {
+        return path.startsWith("s3::");
+    }
+    parseS3Path(S3Path) {
+        if (!this.isS3Path(S3Path)) {
+            return this.error("BAD_REQUEST", "Invalid S3 path");
+        }
+        const [bucket, path] = S3Path.split("s3::")[1].split("//");
+        return (0, neverthrow_1.ok)({ bucket, path });
+    }
+    wrapS3Path(path, bucket) {
+        return `s3::${bucket}//${path}`;
+    }
+    getS3UploadUrl(filename, filetype, expiresIn = 60 * 5) {
+        return this.repository.file.getS3UploadUrl(filename, filetype, expiresIn);
+    }
+    getS3DownloadUrl(path, expiresIn = 60 * 5) {
+        return this.repository.file.getS3DownloadUrl(path, expiresIn);
+    }
+    getS3Object(path) {
+        return this.repository.file.getS3Object(path);
+    }
+    deleteS3Object(path) {
+        return this.repository.file.deleteS3Object(path);
+    }
+    async uploadFileToS3(localPath, returnDownloadUrl = false) {
+        return this.throwableAsync(async () => {
+            const extension = localPath.split(".").pop()?.toLowerCase();
+            const filename = `${(0, uuid_1.v4)()}${extension ? `.${extension}` : ""}`;
+            const mimeByExt = {
+                jpg: "image/jpeg",
+                jpeg: "image/jpeg",
+                png: "image/png",
+                webp: "image/webp",
+                mp4: "video/mp4",
+                mov: "video/mov",
+                avi: "video/avi",
+                mkv: "video/mkv",
+                webm: "video/webm",
+                mp3: "audio/mp3",
+                wav: "audio/wav",
+                m4a: "audio/m4a",
+            };
+            const filetype = (extension && mimeByExt[extension]) || "application/octet-stream";
+            const presigned = await this.getS3UploadUrl(filename, filetype);
+            if (presigned.isErr())
+                return (0, neverthrow_1.err)(presigned.error);
+            const file = await (0, promises_1.readFile)(localPath);
+            const res = await fetch(presigned.value, {
+                method: "PUT",
+                body: file,
+                headers: { "Content-Type": filetype },
+            });
+            if (!res.ok) {
+                return this.error("INTERNAL_SERVER_ERROR", `Failed to upload to S3: ${res.status}`);
+            }
+            if (returnDownloadUrl) {
+                const downloadUrl = await this.getS3DownloadUrl(filename);
+                if (downloadUrl.isErr())
+                    return (0, neverthrow_1.err)(downloadUrl.error);
+                return (0, neverthrow_1.ok)(downloadUrl.value);
+            }
+            return (0, neverthrow_1.ok)(filename);
+        });
+    }
+    async downloadS3ToFile(s3Path) {
+        return this.throwableAsync(async () => {
+            const extension = s3Path.split(".").pop();
+            const destinationPath = node_path_1.default.join((0, node_os_1.tmpdir)(), "s3-downloads", `${(0, uuid_1.v4)()}${extension ? `.${extension}` : ""}`);
+            const result = await this.repository.file.getS3Object(s3Path);
+            if (result.isErr())
+                return (0, neverthrow_1.err)(result.error);
+            const body = result.value.Body;
+            if (!body)
+                return this.error("NOT_FOUND", "S3 object body is empty");
+            await (0, promises_1.mkdir)((0, node_path_1.dirname)(destinationPath), { recursive: true });
+            // AWS SDK v3 SdkStream has transformToByteArray method - use it for reliable handling
+            if (typeof body === "object" &&
+                "transformToByteArray" in body &&
+                typeof body.transformToByteArray === "function") {
+                const bytes = await body.transformToByteArray();
+                await (0, promises_1.writeFile)(destinationPath, bytes);
+                return (0, neverthrow_1.ok)(destinationPath);
+            }
+            // Fallback: try streaming approaches
+            const writeStream = (0, node_fs_1.createWriteStream)(destinationPath);
+            let input = null;
+            const unknownBody = body;
+            if (typeof unknownBody === "object" &&
+                unknownBody !== null &&
+                "pipe" in unknownBody &&
+                typeof unknownBody.pipe === "function") {
+                input = unknownBody;
+            }
+            else if (typeof unknownBody === "object" &&
+                unknownBody !== null &&
+                "getReader" in unknownBody &&
+                typeof unknownBody.getReader === "function") {
+                input = node_stream_1.Readable.fromWeb(unknownBody);
+            }
+            else if (typeof unknownBody === "object" &&
+                unknownBody !== null &&
+                "stream" in unknownBody &&
+                typeof unknownBody.stream === "function") {
+                input = node_stream_1.Readable.fromWeb(unknownBody.stream());
+            }
+            if (input) {
+                await (0, promises_2.pipeline)(input, writeStream);
+                return (0, neverthrow_1.ok)(destinationPath);
+            }
+            if (typeof unknownBody === "object" &&
+                unknownBody !== null &&
+                "arrayBuffer" in unknownBody &&
+                typeof unknownBody.arrayBuffer === "function") {
+                const buffer = Buffer.from(await unknownBody.arrayBuffer());
+                await (0, promises_2.pipeline)(node_stream_1.Readable.from(buffer), writeStream);
+                return (0, neverthrow_1.ok)(destinationPath);
+            }
+            return this.error("INTERNAL_SERVER_ERROR", "Unsupported S3 body type");
+        });
+    }
+    getFileType(path) {
+        // determine the type of the file
+        const extension = path.split(".").pop();
+        if (!extension)
+            return undefined;
+        for (const [key, value] of Object.entries(file_constants_1.fileTypes)) {
+            if (value.extensions.includes(extension)) {
+                return { fileType: key, extension };
+            }
+        }
+        return undefined;
+    }
+}
+exports.FileService = FileService;