@m5kdev/backend 0.6.0 → 0.8.0

package/dist/src/modules/crypto/crypto.repository.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CryptoRepository = void 0;
-const tslib_1 = require("tslib");
-const base_repository_1 = require("../base/base.repository");
-const crypto = tslib_1.__importStar(require("./crypto.db"));
-const schema = { ...crypto };
-class CryptoRepository extends base_repository_1.BaseTableRepository {
-}
-exports.CryptoRepository = CryptoRepository;

package/dist/src/modules/crypto/crypto.service.d.ts

@@ -1,10 +0,0 @@
-import { BaseService } from "../base/base.service";
-import type { ServerResult } from "../base/base.dto";
-import type { CryptoRepository } from "./crypto.repository";
-export declare class CryptoService extends BaseService<{
-    crypto: CryptoRepository;
-}, Record<string, never>> {
-    private root;
-    private getRoot;
-    createBitcoinAddress(derivationIndex: number): ServerResult<string>;
-}

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

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CryptoService = void 0;
-const tslib_1 = require("tslib");
-const bip32_1 = tslib_1.__importDefault(require("bip32"));
-const bip39 = tslib_1.__importStar(require("bip39"));
-const bitcoin = tslib_1.__importStar(require("bitcoinjs-lib"));
-const ecc = tslib_1.__importStar(require("tiny-secp256k1"));
-const neverthrow_1 = require("neverthrow");
-const base_service_1 = require("../base/base.service");
-const BITCOIN_NATIVE_SEGWIT_PATH = "m/84'/0'/0'/0";
-const bip32 = (0, bip32_1.default)(ecc);
-class CryptoService extends base_service_1.BaseService {
-    root = null;
-    getRoot() {
-        if (this.root)
-            return this.root;
-        const seed = process.env.BITCOIN_SEED;
-        if (!seed?.trim()) {
-            throw new Error("BITCOIN_SEED environment variable is not set");
-        }
-        if (!bip39.validateMnemonic(seed.trim())) {
-            throw new Error("BITCOIN_SEED is not a valid BIP39 mnemonic");
-        }
-        const seedBuffer = bip39.mnemonicToSeedSync(seed.trim());
-        this.root = bip32.fromSeed(seedBuffer);
-        return this.root;
-    }
-    createBitcoinAddress(derivationIndex) {
-        return this.throwable(() => {
-            if (derivationIndex < 0 || !Number.isInteger(derivationIndex)) {
-                return this.error("BAD_REQUEST", "derivationIndex must be a non-negative integer");
-            }
-            const root = this.getRoot();
-            const path = `${BITCOIN_NATIVE_SEGWIT_PATH}/${derivationIndex}`;
-            const child = root.derivePath(path);
-            if (!child.publicKey) {
-                return this.error("INTERNAL_SERVER_ERROR", "Failed to derive public key");
-            }
-            const payment = bitcoin.payments.p2wpkh({
-                pubkey: child.publicKey,
-                network: bitcoin.networks.bitcoin,
-            });
-            const address = payment.address;
-            if (!address) {
-                return this.error("INTERNAL_SERVER_ERROR", "Failed to generate address");
-            }
-            return (0, neverthrow_1.ok)(address);
-        });
-    }
-}
-exports.CryptoService = CryptoService;

package/dist/src/modules/email/email.service.d.ts

@@ -1,56 +0,0 @@
-import { type FunctionComponent } from "react";
-import { Resend } from "resend";
-import { BaseService } from "../base/base.service";
-type Brand = {
-    name: string;
-    logo: string;
-    tagline: string;
-};
-type OverrideOptions = {
-    from?: string;
-    subject?: string;
-    previewText?: string;
-};
-type EmailTemplate = {
-    id: string;
-    subject?: string;
-    previewText?: string;
-    from?: string;
-    react: FunctionComponent<Record<string, unknown>>;
-};
-type EmailTemplates = {
-    accountDeletion: EmailTemplate;
-    verification: EmailTemplate;
-    waitlistConfirmation: EmailTemplate;
-    passwordReset: EmailTemplate;
-    systemWaitlistNotification: EmailTemplate;
-    waitlistInvite: EmailTemplate;
-    waitlistUserInvite: EmailTemplate;
-    organizationInvite: EmailTemplate;
-    [key: string]: EmailTemplate;
-};
-type EmailServiceProps = {
-    resendApiKey?: string;
-    brand: Brand;
-    noReplyFrom: string;
-    systemNotificationEmail: string;
-    templates: EmailTemplates;
-};
-export declare class EmailService extends BaseService<never, never> {
-    client: Resend;
-    brand: Brand;
-    noReplyFrom: string;
-    templates: EmailTemplates;
-    systemNotificationEmail: string;
-    constructor(props: EmailServiceProps);
-    sendTemplate(to: string | string[], templateKey: keyof EmailTemplates, templateProps: Record<string, unknown>, options?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-    sendBrandTemplate(to: string | string[], templateKey: keyof EmailTemplates, templateProps: Record<string, unknown>, options?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-    sendWaitlistConfirmation(email: string, overrideOptions?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-    sendWaitlistInvite(email: string, code: string, overrideOptions?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-    sendWaitlistUserInvite(email: string, code: string, inviter: string, name?: string, overrideOptions?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-    sendOrganizationInvite(email: string, organizationName: string, inviterName: string, role: string, url: string, overrideOptions?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-    sendVerification(email: string, url: string, overrideOptions?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-    sendResetPassword(email: string, url: string, overrideOptions?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-    sendDeleteAccountVerification(email: string, url: string, overrideOptions?: OverrideOptions): Promise<import("neverthrow").Err<never, import("../../utils/errors").ServerError> | import("neverthrow").Ok<void, never>>;
-}
-export {};

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

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EmailService = void 0;
-const neverthrow_1 = require("neverthrow");
-const react_1 = require("react");
-const resend_1 = require("resend");
-const base_service_1 = require("../base/base.service");
-class EmailService extends base_service_1.BaseService {
-    client;
-    brand;
-    noReplyFrom;
-    templates;
-    systemNotificationEmail;
-    constructor(props) {
-        super(undefined, undefined);
-        this.client = new resend_1.Resend(props.resendApiKey || process.env.RESEND_API_KEY);
-        this.brand = props.brand;
-        this.noReplyFrom = props.noReplyFrom;
-        this.templates = props.templates;
-        this.systemNotificationEmail = props.systemNotificationEmail;
-    }
-    async sendTemplate(to, templateKey, templateProps, options) {
-        const template = this.templates[templateKey];
-        if (!template) {
-            return this.error("NOT_FOUND", `Email template not found: ${String(templateKey)}`);
-        }
-        const from = options?.from || this.noReplyFrom;
-        const subject = options?.subject || template.subject || String(templateKey);
-        const previewText = options?.previewText || template.previewText || subject;
-        const { error } = await this.client.emails.send({
-            to,
-            subject,
-            from,
-            react: (0, react_1.createElement)(template.react, { ...templateProps, previewText }),
-        });
-        if (error)
-            return this.error("INTERNAL_SERVER_ERROR", `Failed to send email: ${templateKey}`, {
-                cause: error,
-            });
-        return (0, neverthrow_1.ok)();
-    }
-    async sendBrandTemplate(to, templateKey, templateProps, options) {
-        return this.sendTemplate(to, templateKey, {
-            brand: this.brand,
-            ...templateProps,
-        }, options);
-    }
-    async sendWaitlistConfirmation(email, overrideOptions) {
-        return this.sendTemplate(email, "waitlistConfirmation", {
-            email,
-            brand: this.brand,
-        }, overrideOptions);
-    }
-    async sendWaitlistInvite(email, code, overrideOptions) {
-        const url = `${process.env.VITE_APP_URL}/signup?code=${code}&email=${email}`;
-        return this.sendTemplate(email, "waitlistInvite", {
-            url,
-            brand: this.brand,
-        }, overrideOptions);
-    }
-    async sendWaitlistUserInvite(email, code, inviter, name, overrideOptions) {
-        const url = `${process.env.VITE_APP_URL}/signup?code=${code}&email=${email}`;
-        return this.sendTemplate(email, "waitlistUserInvite", {
-            url,
-            brand: this.brand,
-            inviter,
-            name,
-        }, {
-            previewText: `Create your ${this.brand.name} account today!`,
-            subject: `${inviter} has invited you to join ${this.brand.name}!`,
-            ...overrideOptions,
-        });
-    }
-    async sendOrganizationInvite(email, organizationName, inviterName, role, url, overrideOptions) {
-        return this.sendTemplate(email, "organizationInvite", {
-            url,
-            brand: this.brand,
-            organizationName,
-            inviterName,
-            role,
-        }, {
-            previewText: `${inviterName} invited you to ${organizationName}`,
-            subject: `${inviterName} invited you to join ${organizationName}`,
-            ...overrideOptions,
-        });
-    }
-    async sendVerification(email, url, overrideOptions) {
-        return this.sendTemplate(email, "verification", {
-            url,
-            brand: this.brand,
-        }, overrideOptions);
-    }
-    async sendResetPassword(email, url, overrideOptions) {
-        return this.sendTemplate(email, "passwordReset", {
-            url,
-            brand: this.brand,
-        }, overrideOptions);
-    }
-    async sendDeleteAccountVerification(email, url, overrideOptions) {
-        return this.sendTemplate(email, "accountDeletion", {
-            url,
-            brand: this.brand,
-        }, overrideOptions);
-    }
-}
-exports.EmailService = EmailService;

package/dist/src/modules/file/file.repository.d.ts

@@ -1,12 +0,0 @@
-import { type GetObjectCommandOutput } from "@aws-sdk/client-s3";
-import type { ServerResultAsync } from "../base/base.dto";
-import { BaseExternaRepository } from "../base/base.repository";
-export declare class FileRepository extends BaseExternaRepository {
-    private readonly s3;
-    constructor();
-    getS3UploadUrl(filename: string, filetype: string, expiresIn?: number): ServerResultAsync<string>;
-    getS3DownloadUrl(path: string, expiresIn?: number): ServerResultAsync<string>;
-    getS3Object(path: string): ServerResultAsync<GetObjectCommandOutput>;
-    getS3ObjectT(path: string): ServerResultAsync<GetObjectCommandOutput>;
-    deleteS3Object(path: string): ServerResultAsync<void>;
-}

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

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileRepository = void 0;
-const client_s3_1 = require("@aws-sdk/client-s3");
-const s3_request_presigner_1 = require("@aws-sdk/s3-request-presigner");
-const neverthrow_1 = require("neverthrow");
-const base_repository_1 = require("../base/base.repository");
-class FileRepository extends base_repository_1.BaseExternaRepository {
-    s3;
-    constructor() {
-        super();
-        if (!process.env.AWS_REGION ||
-            !process.env.AWS_ACCESS_KEY_ID ||
-            !process.env.AWS_SECRET_ACCESS_KEY) {
-            throw new Error("Missing AWS environment variables");
-        }
-        this.s3 = new client_s3_1.S3Client({
-            region: process.env.AWS_REGION,
-            credentials: {
-                accessKeyId: process.env.AWS_ACCESS_KEY_ID,
-                secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
-            },
-            ...(process.env.AWS_S3_ENDPOINT ? { endpoint: process.env.AWS_S3_ENDPOINT } : {}),
-            forcePathStyle: !!process.env.AWS_S3_ENDPOINT, // Path style is often required for non-AWS S3 providers
-        });
-    }
-    async getS3UploadUrl(filename, filetype, expiresIn = 60 * 5) {
-        return this.throwableAsync(async () => {
-            const command = new client_s3_1.PutObjectCommand({
-                Bucket: process.env.AWS_S3_BUCKET,
-                Key: filename,
-                ContentType: filetype,
-            });
-            const url = await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn });
-            return (0, neverthrow_1.ok)(url);
-        });
-    }
-    async getS3DownloadUrl(path, expiresIn = 60 * 5) {
-        return this.throwableAsync(async () => {
-            const command = new client_s3_1.GetObjectCommand({
-                Bucket: process.env.AWS_S3_BUCKET,
-                Key: path,
-            });
-            const url = await (0, s3_request_presigner_1.getSignedUrl)(this.s3, command, { expiresIn });
-            return (0, neverthrow_1.ok)(url);
-        });
-    }
-    async getS3Object(path) {
-        return this.throwableAsync(async () => {
-            const command = new client_s3_1.GetObjectCommand({
-                Bucket: process.env.AWS_S3_BUCKET,
-                Key: path,
-            });
-            const data = await this.s3.send(command);
-            return (0, neverthrow_1.ok)(data);
-        });
-    }
-    async getS3ObjectT(path) {
-        return this.throwableAsync(async () => {
-            const command = new client_s3_1.GetObjectCommand({
-                Bucket: process.env.AWS_S3_BUCKET,
-                Key: path,
-            });
-            const data = await this.s3.send(command);
-            return (0, neverthrow_1.ok)(data);
-        });
-    }
-    async deleteS3Object(path) {
-        return this.throwableAsync(async () => {
-            const command = new client_s3_1.DeleteObjectCommand({
-                Bucket: process.env.AWS_S3_BUCKET,
-                Key: path,
-            });
-            await this.s3.send(command);
-            return (0, neverthrow_1.ok)(undefined);
-        });
-    }
-}
-exports.FileRepository = FileRepository;

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

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadRouter = void 0;
-const tslib_1 = require("tslib");
-const node_path_1 = tslib_1.__importDefault(require("node:path"));
-const file_constants_1 = require("@m5kdev/commons/modules/file/file.constants");
-const body_parser_1 = tslib_1.__importDefault(require("body-parser"));
-const express_1 = tslib_1.__importDefault(require("express"));
-const multer_1 = tslib_1.__importDefault(require("multer"));
-const uuid_1 = require("uuid");
-const file_repository_1 = require("./file.repository");
-const file_service_1 = require("./file.service");
-const fileRepository = new file_repository_1.FileRepository();
-const fileService = new file_service_1.FileService({ file: fileRepository });
-function validateMimeType(type, file) {
-    return file_constants_1.fileTypes[type]?.mimetypes.includes(file.mimetype);
-}
-function getFileExtension(file) {
-    return file.originalname.split(".").pop();
-}
-const storage = multer_1.default.diskStorage({
-    destination: (_req, _file, cb) => {
-        cb(null, node_path_1.default.join(__dirname, "..", "uploads"));
-    },
-    filename: (_req, file, cb) => {
-        cb(null, `${(0, uuid_1.v4)()}.${getFileExtension(file)}`);
-    },
-});
-const fileFilter = (req, file, cb) => {
-    const { type } = req.params;
-    if (type && validateMimeType(type, file)) {
-        cb(null, true);
-    }
-    else {
-        cb(new Error("Invalid file type"));
-    }
-};
-const upload = (0, multer_1.default)({ storage, fileFilter });
-const uploadRouter = express_1.default.Router();
-exports.uploadRouter = uploadRouter;
-uploadRouter.post("/file/:type", upload.single("file"), (req, res) => {
-    const { file } = req;
-    if (!file) {
-        return res.status(400).json({ error: "No file uploaded" });
-    }
-    return res.json({
-        url: `${process.env.VITE_SERVER_URL}/upload/file/${file.filename}`,
-        mimetype: file.mimetype,
-        size: file.size,
-    });
-});
-uploadRouter.get("/file/:filename", (req, res) => {
-    res.sendFile(node_path_1.default.join(__dirname, "..", "uploads", req.params.filename));
-});
-uploadRouter.get("/files/:path", async (req, res) => {
-    try {
-        const url = await fileService.getS3DownloadUrl(req.params.path);
-        if (url.isErr()) {
-            console.error(url.error);
-            return res.status(500).json({ error: url.error.message });
-        }
-        return res.json({ url: url.value });
-    }
-    catch (err) {
-        console.error(err);
-        return res.status(500).json({ error: err.message || "Failed to generate presigned URL" });
-    }
-});
-uploadRouter.post("/s3-presigned-url", body_parser_1.default.json(), async (req, res) => {
-    const { filename, filetype } = req.body;
-    if (!filename || !filetype) {
-        return res.status(400).json({ error: "Missing filename or filetype" });
-    }
-    try {
-        const url = await fileService.getS3UploadUrl(filename, filetype);
-        if (url.isErr()) {
-            return res.status(500).json({ error: url.error.message });
-        }
-        return res.json({ url: url.value });
-    }
-    catch (err) {
-        console.error(err);
-        return res.status(500).json({ error: err.message || "Failed to generate presigned URL" });
-    }
-});
-uploadRouter.delete("/files/:path(*)", async (req, res) => {
-    try {
-        const result = await fileService.deleteS3Object(req.params.path);
-        if (result.isErr()) {
-            console.error(result.error);
-            return res.status(500).json({ error: result.error.message });
-        }
-        return res.json({ success: true });
-    }
-    catch (err) {
-        console.error(err);
-        return res.status(500).json({ error: err.message || "Failed to delete S3 object" });
-    }
-});

package/dist/src/modules/file/file.service.d.ts

@@ -1,24 +0,0 @@
-import { fileTypes } from "@m5kdev/commons/modules/file/file.constants";
-import type { ServerResult, ServerResultAsync } from "../base/base.dto";
-import { BaseService } from "../base/base.service";
-import type { FileRepository } from "./file.repository";
-export declare class FileService extends BaseService<{
-    file: FileRepository;
-}, never> {
-    isS3Path(path: string): boolean;
-    parseS3Path(S3Path: string): ServerResult<{
-        bucket: string;
-        path: string;
-    }>;
-    wrapS3Path(path: string, bucket: string): string;
-    getS3UploadUrl(filename: string, filetype: string, expiresIn?: number): ServerResultAsync<string>;
-    getS3DownloadUrl(path: string, expiresIn?: number): ServerResultAsync<string>;
-    getS3Object(path: string): ServerResultAsync<import("@aws-sdk/client-s3").GetObjectCommandOutput>;
-    deleteS3Object(path: string): ServerResultAsync<void>;
-    uploadFileToS3(localPath: string, returnDownloadUrl?: boolean): ServerResultAsync<string>;
-    downloadS3ToFile(s3Path: string): ServerResultAsync<string>;
-    getFileType(path: string): {
-        fileType: keyof typeof fileTypes;
-        extension: string;
-    } | undefined;
-}

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

@@ -1,150 +0,0 @@
-"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("../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;