Feature/migration imgs supabase

package.json

@@ -22,7 +22,6 @@
     "s3:setup": "ts-node src/utils/setup-s3-bucket.ts"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.798.0",
     "@aws-sdk/s3-request-presigner": "^3.798.0",
     "@prisma/client": "^6.4.1",
     "@stellar/stellar-sdk": "^13.3.0",
@@ -32,7 +31,6 @@
     "@types/swagger-ui-express": "^4.1.7",
     "@types/uuid": "^10.0.0",
     "axios": "^1.7.9",
-    "backblaze-b2": "^1.7.0",
     "bcryptjs": "^3.0.2",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
@@ -43,7 +41,6 @@
     "express-rate-limit": "^7.5.0",
     "express-validator": "^7.2.0",
     "jsonwebtoken": "^9.0.2",
-    "multer": "^1.4.5-lts.2",
     "node-cron": "^3.0.3",
     "nodemailer": "^6.10.0",
     "pdf-lib": "^1.17.1",

src/index.ts

@@ -186,13 +186,10 @@ prisma
         globalLogger.info("Cron jobs initialized successfully!");
 
         app.listen(PORT, () => {
-          globalLogger.info(
-            `Server is running on http://localhost:${PORT}`,
-            {
-              port: PORT,
-              environment: ENV,
-            }
-          );
+          globalLogger.info(`Server is running on http://localhost:${PORT}`, {
+            port: PORT,
+            environment: ENV,
+          });
 
           if (ENV === "development") {
             globalLogger.info(

src/modules/organization/presentation/controllers/organization.controller.ts

@@ -8,10 +8,7 @@ import { GetAllOrganizationsUseCase } from "../../application/use-cases/get-all-
 import { CreateOrganizationDto } from "../dto/create-organization.dto";
 import { UpdateOrganizationDto } from "../dto/update-organization.dto";
 import { OrganizationNotFoundException } from "../../domain/exceptions/organization-not-found.exception";
-import {
-  UuidParamsDto,
-  PaginationQueryDto,
-} from "../../../shared/dto/base.dto";
+import { PaginationQueryDto, UuidParamsDto } from "@/shared/dto/base.dto";
 
 export class OrganizationController {
   constructor(
@@ -40,7 +37,7 @@ export class OrganizationController {
   );
 
   getOrganizationById = asyncHandler(
-    async (req: Request<UuidParamsDto>, res: Response): Promise<void> => {
+    async (req: Request, res: Response): Promise<void> => {
       const { id } = req.params;
 
       try {

src/modules/photo/README.md

@@ -0,0 +1,36 @@
+# 📸 Photos Module
+
+This module handles uploading, fetching, and deleting images.
+Unlike other modules in the application, its architecture is slightly different, since file handling introduces particular requirements (e.g., Supabase Storage, Multer, public URLs).
+
+# 🔑 Key Architectural Differences
+
+No use cases or repositories are used, only maintained Entity to get easy access on this information, but this Entity is generate for mi adapter, adapter interface required a return of PhotoEntity.
+The flow is more direct:
+
+Controller → calls the Adapter for Supabase Storage and Prisma for persistence.
+
+Entity → ensures photo consistency (valid URL, userId, metadata).
+
+Dedicated Adapters:
+
+photo-service.adapter.interface.ts → defines the generic interface for a storage service.
+
+supabase-service.adapter.ts → concrete implementation using Supabase Storage.
+
+Simplified Controllers:
+Controllers use asyncHandler, validators, and Multer for file processing.
+
+# 📂 Structure
+
+```text
+modules/
+  photo/
+    domain/entities/interfaces/ #interfaces of entity
+    domain/entitites/photo.entity.ts #Entity
+    infrastructure/
+    presentation/controllers/
+    presentation/dto
+    routes.ts
+README.md
+```

src/modules/photo/domain/entities/interfaces/photo.interface.ts

@@ -0,0 +1,49 @@
+export interface IStorageAdapter {
+  upload(file: Buffer, filename: string): Promise<{ url: string; key: string }>;
+  delete(key: string): Promise<void>;
+}
+
+export interface IPhotoMetadata {
+  fileSize?: number;
+  mimeType?: string;
+  dimensions?: {
+    width: number;
+    height: number;
+  };
+  camera?: {
+    make?: string;
+    model?: string;
+    settings?: {
+      iso?: number;
+      aperture?: string;
+      shutterSpeed?: string;
+    };
+  };
+  location?: {
+    latitude?: number;
+    longitude?: number;
+    address?: string;
+  };
+  tags?: string[];
+  description?: string;
+  [key: string]: unknown; // Allow additional properties
+}
+
+export interface IPhotoProps {
+  id?: string;
+  url: string;
+  userId: string;
+  uploadedAt?: Date;
+  metadata?: IPhotoMetadata;
+}
+
+export interface IPhoto {
+  id: string;
+  url: string;
+  userId: string;
+  uploadedAt: Date;
+  metadata?: IPhotoMetadata;
+  validate(): boolean;
+  updateMetadata(newMetadata: Partial<IPhotoMetadata>): void;
+  toObject(): IPhotoProps;
+}

src/modules/photo/domain/entities/photo.entity.ts

@@ -1,53 +1,45 @@
-import { Entity, Column } from "typeorm";
 import { BaseEntity } from "../../../shared/domain/entities/base.entity";
+import { IPhotoMetadata, IPhotoProps } from "./interfaces/photo.interface";
+import {
+  InvalidPhotoUrlException,
+  MissingUserIdException,
+} from "../exceptions/domain.exception";
 
-export interface PhotoProps {
-  id?: string;
-  url: string;
-  userId: string;
-  uploadedAt?: Date;
-  metadata?: Record<string, any>;
-}
-
-@Entity("photos")
-export class Photo extends BaseEntity {
-  @Column({ type: "varchar", length: 500, nullable: false })
+export class PhotoEntity extends BaseEntity {
   url: string;
 
-  @Column({ type: "uuid", nullable: false })
   userId: string;
 
-  @Column({ type: "jsonb", nullable: true })
-  metadata?: Record<string, any>;
+  metadata?: IPhotoMetadata;
 
   // Domain logic and validation
-  public validate(): boolean {
+  protected validate(): boolean {
     if (!this.url || this.url.trim() === "") {
-      throw new Error("Photo URL is required");
+      throw new InvalidPhotoUrlException(this.url);
     }
 
     if (!/^https?:\/\/.+$/.test(this.url)) {
-      throw new Error("Photo URL must be a valid HTTP/HTTPS URL");
+      throw new InvalidPhotoUrlException(this.url);
     }
 
     if (!this.userId || this.userId.trim() === "") {
-      throw new Error("User ID is required");
+      throw new MissingUserIdException();
     }
 
     return true;
   }
 
   // Update metadata
-  public updateMetadata(newMetadata: Record<string, any>): void {
+  public updateMetadata(newMetadata: IPhotoMetadata): void {
     this.metadata = {
       ...this.metadata,
       ...newMetadata,
     };
   }
 
   // Static factory method
-  public static create(props: PhotoProps): Photo {
-    const photo = new Photo();
+  public static create(props: IPhotoProps): PhotoEntity {
+    const photo = new PhotoEntity();
     photo.url = props.url;
     photo.userId = props.userId;
     photo.metadata = props.metadata ?? {};
@@ -56,7 +48,7 @@ export class Photo extends BaseEntity {
   }
 
   // Convert to plain object for persistence
-  public toObject(): PhotoProps {
+  public toObject(): IPhotoProps {
     return {
       id: this.id,
       url: this.url,

src/modules/photo/domain/exceptions/domain.exception.ts

@@ -0,0 +1,13 @@
+import { DomainException } from "../../../shared/domain/exceptions/domain.exception";
+
+export class InvalidPhotoUrlException extends DomainException {
+  constructor(url: string) {
+    super(`Invalid photo URL: ${url}`);
+  }
+}
+
+export class MissingUserIdException extends DomainException {
+  constructor() {
+    super("User ID is required");
+  }
+}

src/modules/photo/infrastructure/adapters/interface/photo-service.adapter.ts

@@ -0,0 +1,16 @@
+import { IPhotoMetadata } from "@/modules/photo/domain/entities/interfaces/photo.interface";
+import { PhotoEntity } from "@/modules/photo/domain/entities/photo.entity";
+
+export interface IPhotoServiceAdapter {
+  upload(
+    file: Express.Multer.File,
+    userId: string,
+    metadata?: IPhotoMetadata
+  ): Promise<PhotoEntity>;
+  getById(photoId: string): Promise<{ id: string; url: string } | null>;
+  delete(photoUrl: string): Promise<void>;
+  updateMetadata(
+    photoId: string,
+    metadata: IPhotoMetadata
+  ): Promise<IPhotoMetadata>;
+}

src/modules/photo/infrastructure/adapters/supabase-service.adapter.ts

@@ -0,0 +1,105 @@
+import { prisma } from "@/config/prisma";
+import { IPhotoMetadata } from "../../domain/entities/interfaces/photo.interface";
+import { IPhotoServiceAdapter } from "./interface/photo-service.adapter";
+import { supabase } from "@/config/supabase";
+import { PhotoEntity } from "../../domain/entities/photo.entity";
+
+export class SupabasePhotoService implements IPhotoServiceAdapter {
+  //Metadata options are enabled if needed later
+  async upload(
+    file: Express.Multer.File,
+    userId: string,
+    metadata?: IPhotoMetadata
+  ): Promise<PhotoEntity> {
+    const fileName = `${Date.now()}-${file.originalname}`;
+
+    // Subir archivo a Supabase Storage
+    const { error: uploadError } = await supabase.storage
+      .from("photos")
+      .upload(fileName, file.buffer, {
+        contentType: file.mimetype,
+        upsert: false,
+      });
+
+    if (uploadError) throw uploadError;
+
+    // Obtener URL pública
+    const { data: publicUrl } = supabase.storage
+      .from("photos")
+      .getPublicUrl(fileName);
+
+    if (!publicUrl) throw new Error("Could not get public URL");
+
+    // Guardar en DB con Prisma
+    const photo = await prisma.photo.create({
+      data: {
+        userId,
+        url: publicUrl.publicUrl,
+        metadata: {
+          ...metadata,
+          fileName: file.originalname,
+          fileSize: file.size,
+          mimeType: file.mimetype,
+        },
+        uploadedAt: new Date(),
+      },
+    });
+
+    return PhotoEntity.create({
+      id: photo.url,
+      url: photo.url,
+      userId,
+      metadata,
+      uploadedAt: photo.uploadedAt ?? new Date(),
+    });
+  }
+
+  async delete(photoId: string): Promise<void> {
+    // Find in DB
+    const photo = await prisma.photo.findUnique({
+      where: { id: photoId },
+    });
+
+    if (!photo) {
+      throw new Error("Photo not found");
+    }
+
+    // Extract fileName from public URL (what follows after /photos/)
+    const urlParts = photo.url.split("/");
+    const fileName = urlParts[urlParts.length - 1];
+
+    // Delete from Supabase Storage using supabaseStorage
+    const { error: deleteError } = await supabase.storage
+      .from("photos")
+      .remove([fileName]);
+
+    if (deleteError) throw deleteError;
+
+    // Delete from DB
+    await prisma.photo.delete({ where: { id: photoId } });
+  }
+
+  async getById(photoId: string): Promise<{ id: string; url: string } | null> {
+    const photo = await prisma.photo.findUnique({
+      where: { id: photoId },
+    });
+
+    if (!photo) return null;
+
+    return { id: photo.id, url: photo.url };
+  }
+
+  async updateMetadata(
+    photoId: string,
+    metadata: IPhotoMetadata
+  ): Promise<IPhotoMetadata> {
+    const updatedPhoto = await prisma.photo.update({
+      where: { id: photoId },
+      data: { metadata },
+      select: { metadata: true },
+    });
+
+    // Assuming metadata is not null after update
+    return updatedPhoto.metadata as IPhotoMetadata;
+  }
+}