cieslarmichal · cieslarmichal · Mar 5, 2024 · Mar 5, 2024 · Mar 5, 2024 · Mar 5, 2024
diff --git a/apps/backend/package.json b/apps/backend/package.json
@@ -20,9 +20,11 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "^3.441.0",
+    "@aws-sdk/lib-storage": "^3.525.1",
     "@common/contracts": "*",
     "@fastify/cors": "^8.4.2",
     "@fastify/helmet": "^11.1.1",
+    "@fastify/multipart": "^8.1.0",
     "@fastify/swagger": "^8.12.1",
     "@fastify/swagger-ui": "^1.10.2",
     "@fastify/type-provider-typebox": "^3.5.0",

diff --git a/apps/backend/src/common/types/http/httpRequest.ts b/apps/backend/src/common/types/http/httpRequest.ts
@@ -1,8 +1,17 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import { type Readable } from 'node:stream';
+
+export interface AttachedFile {
+  readonly name: string;
+  readonly type: string;
+  readonly data: Readable;
+}
+
 export interface HttpRequest<Body = any, QueryParams = any, PathParams = any> {
   readonly body: Body;
   readonly queryParams: QueryParams;
   readonly pathParams: PathParams;
   readonly headers: Record<string, string>;
+  readonly file?: AttachedFile | undefined;
 }
diff --git a/apps/backend/src/core/httpRouter.ts b/apps/backend/src/core/httpRouter.ts
@@ -12,6 +12,7 @@ import { ResourceAlreadyExistsError } from '../common/errors/common/resourceAlre
 import { ResourceNotFoundError } from '../common/errors/common/resourceNotFoundError.js';
 import { type HttpController } from '../common/types/http/httpController.js';
 import { HttpHeader } from '../common/types/http/httpHeader.js';
+import { type AttachedFile } from '../common/types/http/httpRequest.js';
 import { type HttpRouteSchema, type HttpRoute } from '../common/types/http/httpRoute.js';
 import { HttpStatusCode } from '../common/types/http/httpStatusCode.js';
 import { type DependencyInjectionContainer } from '../libs/dependencyInjection/dependencyInjectionContainer.js';
@@ -81,6 +82,20 @@ export class HttpRouter {
             headers: fastifyRequest.headers,
           });
 
+          let attachedFile: AttachedFile | undefined;
+
+          if (fastifyRequest.isMultipart()) {
+            const file = await fastifyRequest.file();
+
+            if (file) {
+              attachedFile = {
+                name: file.filename,
+                type: file.mimetype,
+                data: file.file,
+              };
+            }
+          }
+
           const {
             statusCode,
             body: responseBody,
@@ -90,6 +105,7 @@ export class HttpRouter {
             pathParams: fastifyRequest.params,
             queryParams: fastifyRequest.query,
             headers: fastifyRequest.headers as Record<string, string>,
+            file: attachedFile,
           });
 
           fastifyReply.status(statusCode);

diff --git a/apps/backend/src/core/httpServer.ts b/apps/backend/src/core/httpServer.ts
@@ -2,6 +2,7 @@
 
 import { fastifyCors } from '@fastify/cors';
 import { fastifyHelmet } from '@fastify/helmet';
+import { fastifyMultipart } from '@fastify/multipart';
 import { fastifySwagger } from '@fastify/swagger';
 import { fastifySwaggerUi } from '@fastify/swagger-ui';
 import { type TypeBoxTypeProvider } from '@fastify/type-provider-typebox';
@@ -63,6 +64,8 @@ export class HttpServer {
 
     await this.initSwagger();
 
+    this.fastifyInstance.register(fastifyMultipart);
+
     await this.fastifyInstance.register(fastifyHelmet);
 
     await this.fastifyInstance.register(fastifyCors, {

diff --git a/...dules/resourceModule/api/httpControllers/resourceHttpController/resourceHttpController.ts b/...dules/resourceModule/api/httpControllers/resourceHttpController/resourceHttpController.ts
@@ -40,17 +40,29 @@ import {
   type FindUserBucketsResponseBodyDTO,
 } from './schemas/findUserBucketsSchema.js';
 import { type ResourceMetadataDTO } from './schemas/resourceMetadataDTO.js';
+import {
+  type UploadResourceResponseBodyDTO,
+  type UploadResourcePathParamsDTO,
+  uploadResourceResponseBodyDTOSchema,
+  uploadResourcePathParamsDTOSchema,
+} from './schemas/uploadResourceSchema.js';
+import { OperationNotValidError } from '../../../../../common/errors/common/operationNotValidError.js';
 import { type HttpController } from '../../../../../common/types/http/httpController.js';
 import { HttpHeader } from '../../../../../common/types/http/httpHeader.js';
 import { HttpMethodName } from '../../../../../common/types/http/httpMethodName.js';
 import { type HttpRequest } from '../../../../../common/types/http/httpRequest.js';
-import { type HttpOkResponse, type HttpNoContentResponse } from '../../../../../common/types/http/httpResponse.js';
+import {
+  type HttpOkResponse,
+  type HttpNoContentResponse,
+  type HttpCreatedResponse,
+} from '../../../../../common/types/http/httpResponse.js';
 import { HttpRoute } from '../../../../../common/types/http/httpRoute.js';
 import { HttpStatusCode } from '../../../../../common/types/http/httpStatusCode.js';
 import { SecurityMode } from '../../../../../common/types/http/securityMode.js';
 import { type AccessControlService } from '../../../../authModule/application/services/accessControlService/accessControlService.js';
 import { type FindUserBucketsQueryHandler } from '../../../../userModule/application/queryHandlers/findUserBucketsQueryHandler/findUserBucketsQueryHandler.js';
 import { type DeleteResourceCommandHandler } from '../../../application/commandHandlers/deleteResourceCommandHandler/deleteResourceCommandHandler.js';
+import { type UploadResourceCommandHandler } from '../../../application/commandHandlers/uploadResourceCommandHandler/uploadResourceCommandHandler.js';
 import { type DownloadImageQueryHandler } from '../../../application/queryHandlers/downloadImageQueryHandler/downloadImageQueryHandler.js';
 import { type DownloadResourceQueryHandler } from '../../../application/queryHandlers/downloadResourceQueryHandler/downloadResourceQueryHandler.js';
 import { type DownloadResourcesQueryHandler } from '../../../application/queryHandlers/downloadResourcesQueryHandler/downloadResourcesQueryHandler.js';
@@ -65,6 +77,7 @@ export class ResourceHttpController implements HttpController {
     private readonly deleteResourceCommandHandler: DeleteResourceCommandHandler,
     private readonly findResourcesMetadataQueryHandler: FindResourcesMetadataQueryHandler,
     private readonly downloadResourceQueryHandler: DownloadResourceQueryHandler,
+    private readonly uploadResourceCommandHandler: UploadResourceCommandHandler,
     private readonly downloadResourcesQueryHandler: DownloadResourcesQueryHandler,
     private readonly downloadImageQueryHandler: DownloadImageQueryHandler,
     private readonly downloadVideoPreviewQueryHandler: DownloadVideoPreviewQueryHandler,
@@ -110,6 +123,25 @@ export class ResourceHttpController implements HttpController {
         tags: ['Resource'],
         description: `Find bucket's resources metadata.`,
       }),
+      new HttpRoute({
+        method: HttpMethodName.post,
+        path: ':bucketName/resources',
+        handler: this.uploadResource.bind(this),
+        schema: {
+          request: {
+            pathParams: uploadResourcePathParamsDTOSchema,
+          },
+          response: {
+            [HttpStatusCode.created]: {
+              schema: uploadResourceResponseBodyDTOSchema,
+              description: 'Resource uploaded.',
+            },
+          },
+        },
+        securityMode: SecurityMode.bearer,
+        tags: ['Resource'],
+        description: `Upload a Resource.`,
+      }),
       new HttpRoute({
         method: HttpMethodName.post,
         path: ':bucketName/resources/export',
@@ -290,6 +322,37 @@ export class ResourceHttpController implements HttpController {
     };
   }
 
+  private async uploadResource(
+    request: HttpRequest<undefined, undefined, UploadResourcePathParamsDTO>,
+  ): Promise<HttpCreatedResponse<UploadResourceResponseBodyDTO>> {
+    const { userId } = await this.accessControlService.verifyBearerToken({
+      authorizationHeader: request.headers['authorization'],
+    });
+
+    if (!request.file) {
+      throw new OperationNotValidError({
+        reason: 'File is required.',
+      });
+    }
+
+    const { bucketName } = request.pathParams;
+
+    const { name, type, data } = request.file;
+
+    await this.uploadResourceCommandHandler.execute({
+      userId,
+      resourceName: name,
+      bucketName,
+      contentType: type,
+      data,
+    });
+
+    return {
+      statusCode: HttpStatusCode.created,
+      body: null,
+    };
+  }
+
   private async downloadResource(
     request: HttpRequest<undefined, undefined, DownloadResourcePathParamsDTO>,
   ): Promise<HttpOkResponse<unknown>> {

diff --git a/...resourceModule/api/httpControllers/resourceHttpController/schemas/uploadResourceSchema.ts b/...resourceModule/api/httpControllers/resourceHttpController/schemas/uploadResourceSchema.ts
@@ -0,0 +1,18 @@
+import { Type, type Static } from '@sinclair/typebox';
+
+import type * as contracts from '@common/contracts';
+
+import { type TypeExtends } from '../../../../../../common/types/schemaExtends.js';
+
+export const uploadResourcePathParamsDTOSchema = Type.Object({
+  bucketName: Type.String({ minLength: 1 }),
+});
+
+export type UploadResourcePathParamsDTO = TypeExtends<
+  Static<typeof uploadResourcePathParamsDTOSchema>,
+  contracts.UploadResourcePathParams
+>;
+
+export const uploadResourceResponseBodyDTOSchema = Type.Any();
+
+export type UploadResourceResponseBodyDTO = Static<typeof uploadResourceResponseBodyDTOSchema>;
diff --git a/.../application/commandHandlers/uploadResourceCommandHandler/uploadResourceCommandHandler.ts b/.../application/commandHandlers/uploadResourceCommandHandler/uploadResourceCommandHandler.ts
@@ -0,0 +1,13 @@
+import { type Readable } from 'node:stream';
+
+import { type CommandHandler } from '../../../../../common/types/commandHandler.js';
+
+export interface UploadResourceCommandHandlerPayload {
+  readonly userId: string;
+  readonly resourceName: string;
+  readonly contentType: string;
+  readonly data: Readable;
+  readonly bucketName: string;
+}
+
+export type UploadResourceCommandHandler = CommandHandler<UploadResourceCommandHandlerPayload, void>;
diff --git a/...lication/commandHandlers/uploadResourceCommandHandler/uploadResourceCommandHandlerImpl.ts b/...lication/commandHandlers/uploadResourceCommandHandler/uploadResourceCommandHandlerImpl.ts
@@ -0,0 +1,66 @@
+import {
+  type UploadResourceCommandHandler,
+  type UploadResourceCommandHandlerPayload,
+} from './uploadResourceCommandHandler.js';
+import { OperationNotValidError } from '../../../../../common/errors/common/operationNotValidError.js';
+import { type LoggerService } from '../../../../../libs/logger/services/loggerService/loggerService.js';
+import { type FindUserBucketsQueryHandler } from '../../../../userModule/application/queryHandlers/findUserBucketsQueryHandler/findUserBucketsQueryHandler.js';
+import { type ResourceBlobService } from '../../../domain/services/resourceBlobService/resourceBlobService.js';
+
+export class UploadResourceCommandHandlerImpl implements UploadResourceCommandHandler {
+  public constructor(
+    private readonly resourceBlobSerice: ResourceBlobService,
+    private readonly loggerService: LoggerService,
+    private readonly findUserBucketsQueryHandler: FindUserBucketsQueryHandler,
+  ) {}
+
+  public async execute(payload: UploadResourceCommandHandlerPayload): Promise<void> {
+    const { userId, resourceName, bucketName, contentType, data } = payload;
+
+    const { buckets } = await this.findUserBucketsQueryHandler.execute({ userId });
+
+    if (!buckets.includes(bucketName)) {
+      throw new OperationNotValidError({
+        reason: 'Bucket does not exist.',
+        userId,
+        bucketName,
+      });
+    }
+
+    this.loggerService.debug({
+      message: 'Uploading Resource...',
+      userId,
+      bucketName,
+      resourceName,
+      contentType,
+    });
+
+    const existingResource = await this.resourceBlobSerice.resourceExists({
+      bucketName,
+      resourceName,
+    });
+
+    if (existingResource) {
+      throw new OperationNotValidError({
+        reason: 'Cannot create resource because it already exists.',
+        resourceName,
+        bucketName,
+      });
+    }
+
+    await this.resourceBlobSerice.uploadResource({
+      bucketName,
+      resourceName,
+      data,
+      contentType,
+    });
+
+    this.loggerService.debug({
+      message: 'Resource uploaded.',
+      userId,
+      bucketName,
+      resourceName,
+      contentType,
+    });
+  }
+}
diff --git a/...end/src/modules/resourceModule/domain/services/resourceBlobService/resourceBlobService.ts b/...end/src/modules/resourceModule/domain/services/resourceBlobService/resourceBlobService.ts
@@ -7,6 +7,7 @@ export interface UploadResourcePayload {
   readonly resourceName: string;
   readonly bucketName: string;
   readonly data: Readable;
+  readonly contentType: string;
 }
 
 export interface DownloadResourcePayload {

diff --git a/...e/infrastructure/services/resourceBlobService/resourceBlobServiceImpl.integration.test.ts b/...e/infrastructure/services/resourceBlobService/resourceBlobServiceImpl.integration.test.ts
@@ -306,26 +306,6 @@ describe('ResourceBlobServiceImpl', () => {
   });
 
   describe('upload', () => {
-    it('throws an error - when object already exists', async () => {
-      const filePath = path.join(resourcesDirectory, sampleFileName1);
-
-      await s3TestUtils.uploadObject(bucketName, sampleFileName1, filePath);
-
-      try {
-        await resourceBlobService.uploadResource({
-          bucketName,
-          resourceName: sampleFileName1,
-          data: createReadStream(filePath),
-        });
-      } catch (error) {
-        expect(error).toBeDefined();
-
-        return;
-      }
-
-      expect.fail();
-    });
-
     it('throws an error - when bucket does not exist', async () => {
       const filePath = path.join(resourcesDirectory, sampleFileName1);
 
@@ -336,6 +316,7 @@ describe('ResourceBlobServiceImpl', () => {
           bucketName: nonExistingBucketName,
           resourceName: sampleFileName1,
           data: createReadStream(filePath),
+          contentType: 'video/mp4',
         });
       } catch (error) {
         expect(error).toBeDefined();
@@ -353,6 +334,7 @@ describe('ResourceBlobServiceImpl', () => {
         bucketName,
         resourceName: sampleFileName1,
         data: createReadStream(filePath),
+        contentType: 'video/mp4',
       });
 
       const exists = await s3TestUtils.objectExists(bucketName, sampleFileName1);

diff --git a/...les/resourceModule/infrastructure/services/resourceBlobService/resourceBlobServiceImpl.ts b/...les/resourceModule/infrastructure/services/resourceBlobService/resourceBlobServiceImpl.ts
@@ -4,9 +4,9 @@ import {
   DeleteObjectCommand,
   GetObjectCommand,
   ListObjectsV2Command,
-  PutObjectCommand,
   type ListObjectsV2CommandInput,
 } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
 import { type Readable } from 'node:stream';
 
 import { OperationNotValidError } from '../../../../../common/errors/common/operationNotValidError.js';
@@ -30,26 +30,16 @@ export class ResourceBlobServiceImpl implements ResourceBlobService {
   public async uploadResource(payload: UploadResourcePayload): Promise<void> {
     const { bucketName, resourceName, data } = payload;
 
-    const exists = await this.resourceExists({
-      resourceName,
-      bucketName,
-    });
-
-    if (exists) {
-      throw new OperationNotValidError({
-        reason: 'Resource already exists in bucket.',
-        resourceName,
-        bucketName,
-      });
-    }
-
-    const command = new PutObjectCommand({
-      Bucket: bucketName,
-      Key: resourceName,
-      Body: data,
+    const upload = new Upload({
+      client: this.s3Client,
+      params: {
+        Bucket: bucketName,
+        Key: resourceName,
+        Body: data,
+      },
     });
 
-    await this.s3Client.send(command);
+    await upload.done();
   }
 
   public async downloadResource(payload: DownloadResourcePayload): Promise<Resource> {