@m5kdev/backend 0.1.0

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

@@ -0,0 +1,57 @@
+import BIP32Factory from "bip32";
+import * as bip39 from "bip39";
+import * as bitcoin from "bitcoinjs-lib";
+import * as ecc from "tiny-secp256k1";
+import { ok } from "neverthrow";
+import { BaseService } from "#modules/base/base.service";
+import type { ServerResult } from "#modules/base/base.dto";
+import type { CryptoRepository } from "#modules/crypto/crypto.repository";
+import type { BIP32Interface } from "bip32";
+
+const BITCOIN_NATIVE_SEGWIT_PATH = "m/84'/0'/0'/0";
+
+const bip32 = BIP32Factory(ecc);
+
+export class CryptoService extends BaseService<
+  { crypto: CryptoRepository },
+  Record<string, never>
+> {
+  private root: BIP32Interface | null = null;
+
+  private getRoot(): BIP32Interface {
+    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: number): ServerResult<string> {
+    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 ok(address);
+    });
+  }
+}

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

@@ -0,0 +1,222 @@
+import { ok } from "neverthrow";
+import { createElement, type FunctionComponent } from "react";
+import { Resend } from "resend";
+import { BaseService } from "#modules/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 class EmailService extends BaseService<never, never> {
+  public client: Resend;
+  public brand: Brand;
+  public noReplyFrom: string;
+  public templates: EmailTemplates;
+  public systemNotificationEmail: string;
+
+  constructor(props: EmailServiceProps) {
+    super(undefined, undefined);
+    this.client = new Resend(props.resendApiKey || process.env.RESEND_API_KEY);
+    this.client = {} as unknown as Resend;
+    this.brand = props.brand;
+    this.noReplyFrom = props.noReplyFrom;
+    this.templates = props.templates;
+    this.systemNotificationEmail = props.systemNotificationEmail;
+  }
+
+  async sendTemplate(
+    to: string | string[],
+    templateKey: keyof EmailTemplates,
+    templateProps: Record<string, unknown>,
+    options?: OverrideOptions
+  ) {
+    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: createElement(template.react, { ...templateProps, previewText }),
+    });
+    if (error)
+      return this.error("INTERNAL_SERVER_ERROR", `Failed to send email: ${templateKey}`, {
+        cause: error,
+      });
+    return ok();
+  }
+
+  async sendBrandTemplate(
+    to: string | string[],
+    templateKey: keyof EmailTemplates,
+    templateProps: Record<string, unknown>,
+    options?: OverrideOptions
+  ) {
+    return this.sendTemplate(
+      to,
+      templateKey,
+      {
+        brand: this.brand,
+        ...templateProps,
+      },
+      options
+    );
+  }
+
+  async sendWaitlistConfirmation(email: string, overrideOptions?: OverrideOptions) {
+    return this.sendTemplate(
+      email,
+      "waitlistConfirmation",
+      {
+        email,
+        brand: this.brand,
+      },
+      overrideOptions
+    );
+  }
+
+  async sendWaitlistInvite(email: string, code: string, overrideOptions?: 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: string,
+    code: string,
+    inviter: string,
+    name?: string,
+    overrideOptions?: 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: string,
+    organizationName: string,
+    inviterName: string,
+    role: string,
+    url: string,
+    overrideOptions?: 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: string, url: string, overrideOptions?: OverrideOptions) {
+    return this.sendTemplate(
+      email,
+      "verification",
+      {
+        url,
+        brand: this.brand,
+      },
+      overrideOptions
+    );
+  }
+
+  async sendResetPassword(email: string, url: string, overrideOptions?: OverrideOptions) {
+    return this.sendTemplate(
+      email,
+      "passwordReset",
+      {
+        url,
+        brand: this.brand,
+      },
+      overrideOptions
+    );
+  }
+
+  async sendDeleteAccountVerification(
+    email: string,
+    url: string,
+    overrideOptions?: OverrideOptions
+  ) {
+    return this.sendTemplate(
+      email,
+      "accountDeletion",
+      {
+        url,
+        brand: this.brand,
+      },
+      overrideOptions
+    );
+  }
+}

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

@@ -0,0 +1,95 @@
+import {
+  DeleteObjectCommand,
+  GetObjectCommand,
+  type GetObjectCommandOutput,
+  PutObjectCommand,
+  S3Client,
+} from "@aws-sdk/client-s3";
+import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
+import { ok } from "neverthrow";
+import type { ServerResultAsync } from "#modules/base/base.dto";
+import { BaseExternaRepository } from "#modules/base/base.repository";
+
+export class FileRepository extends BaseExternaRepository {
+  private readonly s3: S3Client;
+  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 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: string,
+    filetype: string,
+    expiresIn = 60 * 5
+  ): ServerResultAsync<string> {
+    return this.throwableAsync(async () => {
+      const command = new PutObjectCommand({
+        Bucket: process.env.AWS_S3_BUCKET,
+        Key: filename,
+        ContentType: filetype,
+      });
+      const url = await getSignedUrl(this.s3, command, { expiresIn });
+      return ok(url);
+    });
+  }
+
+  async getS3DownloadUrl(path: string, expiresIn = 60 * 5): ServerResultAsync<string> {
+    return this.throwableAsync(async () => {
+      const command = new GetObjectCommand({
+        Bucket: process.env.AWS_S3_BUCKET,
+        Key: path,
+      });
+      const url = await getSignedUrl(this.s3, command, { expiresIn });
+      return ok(url);
+    });
+  }
+
+  async getS3Object(path: string): ServerResultAsync<GetObjectCommandOutput> {
+    return this.throwableAsync(async () => {
+      const command = new GetObjectCommand({
+        Bucket: process.env.AWS_S3_BUCKET,
+        Key: path,
+      });
+      const data = await this.s3.send(command);
+      return ok(data);
+    });
+  }
+
+  async getS3ObjectT(path: string): ServerResultAsync<GetObjectCommandOutput> {
+    return this.throwableAsync(async () => {
+      const command = new GetObjectCommand({
+        Bucket: process.env.AWS_S3_BUCKET,
+        Key: path,
+      });
+      const data = await this.s3.send(command);
+      return ok(data);
+    });
+  }
+
+  async deleteS3Object(path: string): ServerResultAsync<void> {
+    return this.throwableAsync(async () => {
+      const command = new DeleteObjectCommand({
+        Bucket: process.env.AWS_S3_BUCKET,
+        Key: path,
+      });
+      await this.s3.send(command);
+      return ok(undefined);
+    });
+  }
+}

package/src/modules/file/file.router.ts

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { fileTypes } from "@m5kdev/commons/modules/file/file.constants";
+import bodyParser from "body-parser";
+import express, { type Request, type Response } from "express";
+import multer from "multer";
+import { v4 as uuidv4 } from "uuid";
+import { FileRepository } from "#modules/file/file.repository";
+import { FileService } from "#modules/file/file.service";
+
+const fileRepository = new FileRepository();
+const fileService = new FileService({ file: fileRepository });
+
+function validateMimeType(type: string, file: Express.Multer.File): boolean {
+  return fileTypes[type]?.mimetypes.includes(file.mimetype);
+}
+
+function getFileExtension(file: Express.Multer.File): string | undefined {
+  return file.originalname.split(".").pop();
+}
+
+const storage = multer.diskStorage({
+  destination: (_req, _file, cb) => {
+    cb(null, path.join(__dirname, "..", "uploads"));
+  },
+  filename: (_req, file, cb) => {
+    cb(null, `${uuidv4()}.${getFileExtension(file)}`);
+  },
+});
+
+const fileFilter = (
+  req: Request,
+  file: Express.Multer.File,
+  cb: multer.FileFilterCallback
+): void => {
+  const { type } = req.params;
+  if (type && validateMimeType(type, file)) {
+    cb(null, true);
+  } else {
+    cb(new Error("Invalid file type"));
+  }
+};
+
+const upload = multer({ storage, fileFilter });
+const uploadRouter: express.Router = express.Router();
+
+uploadRouter.post("/file/:type", upload.single("file"), (req: Request, res: Response) => {
+  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: Request, res: Response) => {
+  res.sendFile(path.join(__dirname, "..", "uploads", req.params.filename!));
+});
+
+uploadRouter.get("/files/:path", async (req: Request, res: Response) => {
+  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: any) {
+    console.error(err);
+    return res.status(500).json({ error: err.message || "Failed to generate presigned URL" });
+  }
+});
+
+uploadRouter.post("/s3-presigned-url", bodyParser.json(), async (req: Request, res: Response) => {
+  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: any) {
+    console.error(err);
+    return res.status(500).json({ error: err.message || "Failed to generate presigned URL" });
+  }
+});
+
+uploadRouter.delete("/files/:path(*)", async (req: Request, res: Response) => {
+  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: any) {
+    console.error(err);
+    return res.status(500).json({ error: err.message || "Failed to delete S3 object" });
+  }
+});
+
+export { uploadRouter };

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

@@ -0,0 +1,186 @@
+import { createWriteStream } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path, { dirname } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { fileTypes } from "@m5kdev/commons/modules/file/file.constants";
+import { err, ok } from "neverthrow";
+import { v4 as uuidv4 } from "uuid";
+import type { ServerResult, ServerResultAsync } from "#modules/base/base.dto";
+import { BaseService } from "#modules/base/base.service";
+import type { FileRepository } from "#modules/file/file.repository";
+
+export class FileService extends BaseService<{ file: FileRepository }, never> {
+  isS3Path(path: string): boolean {
+    return path.startsWith("s3::");
+  }
+
+  parseS3Path(S3Path: string): ServerResult<{ bucket: string; path: string }> {
+    if (!this.isS3Path(S3Path)) {
+      return this.error("BAD_REQUEST", "Invalid S3 path");
+    }
+    const [bucket, path] = S3Path.split("s3::")[1].split("//");
+    return ok({ bucket, path });
+  }
+
+  wrapS3Path(path: string, bucket: string): string {
+    return `s3::${bucket}//${path}`;
+  }
+
+  getS3UploadUrl(
+    filename: string,
+    filetype: string,
+    expiresIn = 60 * 5
+  ): ServerResultAsync<string> {
+    return this.repository.file.getS3UploadUrl(filename, filetype, expiresIn);
+  }
+
+  getS3DownloadUrl(path: string, expiresIn = 60 * 5): ServerResultAsync<string> {
+    return this.repository.file.getS3DownloadUrl(path, expiresIn);
+  }
+
+  getS3Object(path: string) {
+    return this.repository.file.getS3Object(path);
+  }
+
+  deleteS3Object(path: string) {
+    return this.repository.file.deleteS3Object(path);
+  }
+
+  async uploadFileToS3(localPath: string, returnDownloadUrl = false): ServerResultAsync<string> {
+    return this.throwableAsync(async () => {
+      const extension = localPath.split(".").pop()?.toLowerCase();
+      const filename = `${uuidv4()}${extension ? `.${extension}` : ""}`;
+
+      const mimeByExt: Record<string, string> = {
+        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 err(presigned.error);
+
+      const file = await 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 err(downloadUrl.error);
+        return ok(downloadUrl.value);
+      }
+
+      return ok(filename);
+    });
+  }
+
+  async downloadS3ToFile(s3Path: string): ServerResultAsync<string> {
+    return this.throwableAsync(async () => {
+      const extension = s3Path.split(".").pop();
+      const destinationPath = path.join(
+        tmpdir(),
+        "s3-downloads",
+        `${uuidv4()}${extension ? `.${extension}` : ""}`
+      );
+
+      const result = await this.repository.file.getS3Object(s3Path);
+      if (result.isErr()) return err(result.error);
+
+      const body = result.value.Body;
+      if (!body) return this.error("NOT_FOUND", "S3 object body is empty");
+
+      await mkdir(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 writeFile(destinationPath, bytes);
+        return ok(destinationPath);
+      }
+
+      // Fallback: try streaming approaches
+      const writeStream = createWriteStream(destinationPath);
+      let input: NodeJS.ReadableStream | null = null;
+      const unknownBody: unknown = body;
+
+      if (
+        typeof unknownBody === "object" &&
+        unknownBody !== null &&
+        "pipe" in unknownBody &&
+        typeof (unknownBody as { pipe?: unknown }).pipe === "function"
+      ) {
+        input = unknownBody as NodeJS.ReadableStream;
+      } else if (
+        typeof unknownBody === "object" &&
+        unknownBody !== null &&
+        "getReader" in unknownBody &&
+        typeof (unknownBody as { getReader?: unknown }).getReader === "function"
+      ) {
+        input = Readable.fromWeb(unknownBody as unknown as globalThis.ReadableStream);
+      } else if (
+        typeof unknownBody === "object" &&
+        unknownBody !== null &&
+        "stream" in unknownBody &&
+        typeof (unknownBody as { stream?: unknown }).stream === "function"
+      ) {
+        input = Readable.fromWeb(
+          (unknownBody as { stream: () => globalThis.ReadableStream }).stream()
+        );
+      }
+
+      if (input) {
+        await pipeline(input, writeStream);
+        return ok(destinationPath);
+      }
+
+      if (
+        typeof unknownBody === "object" &&
+        unknownBody !== null &&
+        "arrayBuffer" in unknownBody &&
+        typeof (unknownBody as { arrayBuffer?: unknown }).arrayBuffer === "function"
+      ) {
+        const buffer = Buffer.from(
+          await (unknownBody as { arrayBuffer: () => Promise<ArrayBuffer> }).arrayBuffer()
+        );
+        await pipeline(Readable.from(buffer), writeStream);
+        return ok(destinationPath);
+      }
+
+      return this.error("INTERNAL_SERVER_ERROR", "Unsupported S3 body type");
+    });
+  }
+
+  getFileType(path: string): { fileType: keyof typeof fileTypes; extension: string } | undefined {
+    // determine the type of the file
+    const extension = path.split(".").pop();
+    if (!extension) return undefined;
+
+    for (const [key, value] of Object.entries(fileTypes)) {
+      if (value.extensions.includes(extension)) {
+        return { fileType: key, extension };
+      }
+    }
+    return undefined;
+  }
+}