[LOCKLITE-104] Refactor backend

eslint.config.mjs

@@ -1,6 +1,6 @@
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-import { FlatCompat } from '@eslint/eslintrc';
+import {dirname} from 'path';
+import {fileURLToPath} from 'url';
+import {FlatCompat} from '@eslint/eslintrc';
 import js from '@eslint/js';
 import tseslint from 'typescript-eslint';
 import eslintPluginPrettier from 'eslint-plugin-prettier';
@@ -65,13 +65,13 @@ export default tseslint.config(
         'no-inline-comments': 'warn',
         'no-undefined': 'warn',
         'no-var': 'error',
-        'prefer-const': ['error', { destructuring: 'all' }],
+        'prefer-const': ['error', {destructuring: 'all'}],
         'require-await': 'error',
         'require-object-destructuring': 'off',
         'arrow-parens': ['error', 'as-needed'],
         /* Formatting */
-        'max-len': ['warn', { code: 300, ignoreUrls: true }],
-        'prettier/prettier': ['warn', { semi: true }],
+        'max-len': ['warn', {code: 300, ignoreUrls: true}],
+        'prettier/prettier': ['warn', {semi: true}],
         semi: ['error', 'always'],
 
         /* Naming conventions */
@@ -122,29 +122,29 @@ export default tseslint.config(
         ],
         '@typescript-eslint/explicit-function-return-type': [
           'error',
-          { allowExpressions: false },
+          {allowExpressions: false},
         ],
         '@typescript-eslint/explicit-member-accessibility': [
           'error',
-          { accessibility: 'explicit' },
+          {accessibility: 'explicit'},
         ],
         '@typescript-eslint/explicit-module-boundary-types': 'error',
         '@typescript-eslint/no-empty-function': ['warn'],
         '@typescript-eslint/no-extraneous-class': [
           'error',
-          { allowConstructorOnly: false },
+          {allowConstructorOnly: false},
         ],
         '@typescript-eslint/no-explicit-any': 'error',
         '@typescript-eslint/no-inferrable-types': 'off',
         '@typescript-eslint/no-magic-numbers': [
           'warn',
-          { ignoreEnums: true, ignore: [0, 1], enforceConst: true },
+          {ignoreEnums: true, ignore: [0, 1], enforceConst: true},
         ],
         '@typescript-eslint/no-namespace': 'off',
         '@typescript-eslint/no-unsafe-member-access': 'warn',
         '@typescript-eslint/no-unused-vars': [
           'error',
-          { argsIgnorePattern: '^_' },
+          {argsIgnorePattern: '^_'},
         ],
         '@typescript-eslint/prefer-function-type': 'warn',
         '@typescript-eslint/prefer-readonly': 'warn',
@@ -169,7 +169,7 @@ export default tseslint.config(
         'no-restricted-imports': [
           'error',
           {
-            patterns: ['@api/*'],
+            patterns: ['@api/*', '@prisma/*'],
           },
         ],
       },
@@ -187,11 +187,23 @@ export default tseslint.config(
       },
     },
 
+    {
+      files: ['src/modules/shared/**/*.{ts,tsx}'],
+      rules: {
+        'no-restricted-imports': [
+          'error',
+          {
+            patterns: ['@api/*', '@ui/*', '@prisma/*'],
+          },
+        ],
+      },
+    },
+
     {
       files: ['**/*.test.ts', '**/*.spec.ts', '**/*.test.tsx', '**/*.spec.tsx'],
-      plugins: { jest: eslintPluginJest },
+      plugins: {jest: eslintPluginJest},
       settings: {
-        jest: { version: 29 },
+        jest: {version: 29},
       },
     },
   ],

prisma/migrations/20250802221429_remove_secret_length_limit/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Vault" ALTER COLUMN "secret" SET DATA TYPE TEXT;

prisma/migrations/20250802234042_add_vault_creation_date/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Vault" ADD COLUMN     "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP;

prisma/schema.prisma

@@ -9,7 +9,8 @@ datasource db {
 }
 
 model Vault {
-  uuid   String @id @default(uuid())
-  label  String @db.VarChar(255)
-  secret String @db.VarChar(255)
+  uuid      String   @id @default(uuid())
+  label     String   @db.VarChar(255)
+  secret    String
+  createdAt DateTime @default(now())
 }

src/app/api/vaults/[id]/route.ts

@@ -1,10 +1,11 @@
 import 'reflect-metadata';
 import type { NextRequest, NextResponse } from 'next/server';
-import type { IdParam } from '@shared/dto/params/id.param';
 import { container } from 'tsyringe';
-import { handleApiRequest } from '@api/utils/handle-api-request';
+import { handleApiRequest } from '@api/helpers/handle-api-request';
 import { StatusCodes } from 'http-status-codes';
 import { DeleteVaultUseCase } from '@api/usecases/vaults/delete-vault.usecase';
+import type { CreateVaultParams } from '@shared/dto/input/params/create-vault.params';
+import type { HttpOptions } from '@shared/dto/input/options/abstract/http-options';
 
 /**
  * @swagger
@@ -24,22 +25,26 @@ import { DeleteVaultUseCase } from '@api/usecases/vaults/delete-vault.usecase';
  *       204:
  *         description: The vault has been successfully deleted
  *       404:
- *         description: Vault not found
+ *         description: Resource not found
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/HttpErrorDto'
  *       500:
  *         description: Internal Server Error
  *         content:
  *           application/json:
  *             schema:
- *               $ref: '#/components/schemas/HttpResponseDto'
+ *               $ref: '#/components/schemas/HttpErrorDto'
  */
 export async function DELETE(
   request: NextRequest,
-  params: IdParam
+  options: HttpOptions<CreateVaultParams>
 ): Promise<NextResponse> {
   const deleteVaultUseCase: DeleteVaultUseCase =
     container.resolve(DeleteVaultUseCase);
-  return await handleApiRequest(
-    () => deleteVaultUseCase.handle(params),
+  return await handleApiRequest<void>(
+    async () => deleteVaultUseCase.handle(await options.params),
     StatusCodes.NO_CONTENT
   );
 }

src/app/api/vaults/route.ts

@@ -1,14 +1,15 @@
 import 'reflect-metadata';
 import type { NextRequest, NextResponse } from 'next/server';
 import { container } from 'tsyringe';
-import { handleApiRequest } from '@api/utils/handle-api-request';
+import { handleApiRequest } from '@api/helpers/handle-api-request';
 import type { VaultModelDto } from '@shared/dto/models/vault.model.dto';
-import type { CreateVaultResponseDto } from '@shared/dto/responses/create-vault.response.dto';
 import { CreateVaultUseCase } from '@api/usecases/vaults/create-vault.usecase';
-import type { GetMyVaultsResponseDto } from '@shared/dto/responses/get-my-vaults.response.dto';
 import { GetMyVaultsUseCase } from '@api/usecases/vaults/get-my-vaults.usecase';
-import type { CreateVaultRequestDto } from '@shared/dto/requests/create-vault.request.dto';
+import type { CreateVaultRequestDto } from '@shared/dto/input/requests/create-vault.request.dto';
 import { StatusCodes } from 'http-status-codes';
+import type { CreateVaultDataDto } from '@shared/dto/output/data/create-vault.data.dto';
+import type { GetMyVaultsDataDto } from '@shared/dto/output/data/get-my-vaults.data.dto';
+import type { HttpResponseDto } from '@shared/dto/output/responses/abstract/http.response.dto';
 
 /**
  * @swagger
@@ -23,20 +24,22 @@ import { StatusCodes } from 'http-status-codes';
  *         content:
  *           application/json:
  *             schema:
- *               $ref: '#/components/schemas/GetMyVaultsResponseDto'
+ *               $ref: '#/components/schemas/GetMyVaultsBodyDto'
  *       500:
  *         description: Internal Server Error
  *         content:
  *           application/json:
  *             schema:
- *               $ref: '#/components/schemas/HttpResponseDto'
+ *               $ref: '#/components/schemas/HttpErrorDto'
  */
-export async function GET(): Promise<NextResponse> {
+export async function GET(): Promise<
+  NextResponse<HttpResponseDto<GetMyVaultsDataDto>>
+> {
   const getMyVaultsUseCase: GetMyVaultsUseCase =
     container.resolve(GetMyVaultsUseCase);
-  return await handleApiRequest(async () => {
+  return await handleApiRequest<GetMyVaultsDataDto>(async () => {
     const myVaults: VaultModelDto[] = await getMyVaultsUseCase.handle();
-    const response: GetMyVaultsResponseDto = { myVaults };
+    const response: GetMyVaultsDataDto = { myVaults };
     return response;
   });
 }
@@ -60,21 +63,29 @@ export async function GET(): Promise<NextResponse> {
  *         content:
  *           application/json:
  *             schema:
- *               $ref: '#/components/schemas/CreateVaultResponseDto'
+ *               $ref: '#/components/schemas/CreateVaultBodyDto'
+ *       400:
+ *         description: One of the requested values is too long
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/HttpErrorDto'
  *       500:
  *         description: Internal Server Error
  *         content:
  *           application/json:
  *             schema:
- *               $ref: '#/components/schemas/HttpResponseDto'
+ *               $ref: '#/components/schemas/HttpErrorDto'
  */
-export async function POST(request: NextRequest): Promise<NextResponse> {
+export async function POST(
+  request: NextRequest
+): Promise<NextResponse<HttpResponseDto<CreateVaultDataDto>>> {
   const params: CreateVaultRequestDto = await request.json();
   const createVaultUseCase: CreateVaultUseCase =
     container.resolve(CreateVaultUseCase);
-  return await handleApiRequest(async () => {
+  return await handleApiRequest<CreateVaultDataDto>(async () => {
     const vaultCreated: VaultModelDto = await createVaultUseCase.handle(params);
-    const response: CreateVaultResponseDto = { vaultCreated };
+    const response: CreateVaultDataDto = { vaultCreated };
     return response;
   }, StatusCodes.CREATED);
 }

src/app/ui/workspace/page.tsx

@@ -8,7 +8,6 @@ import ErrorMessage from '@ui/components/common/ErrorMessage';
 import CircularLoader from '@ui/components/common/CircularLoader';
 import { VaultsGateway } from '@ui/gateways/vaults.gateway';
 import { container } from 'tsyringe';
-import type { GetMyVaultsResponseDto } from '@shared/dto/responses/get-my-vaults.response.dto';
 import { useApi } from '@ui/hooks/useApi';
 import {
   Box,
@@ -23,6 +22,8 @@ import {
   Typography,
 } from '@mui/material';
 import AddVaultModal from '@ui/components/modals/AddVaultModal';
+import type { GetMyVaultsDataDto } from '@shared/dto/output/data/get-my-vaults.data.dto';
+import { UiLogger } from '@ui/logs/ui.logger';
 
 export default function WorkspacePage(): JSX.Element {
   const [vaults, setVaults] = useState<VaultModelDto[]>([]);
@@ -31,7 +32,7 @@ export default function WorkspacePage(): JSX.Element {
   const [deleteLoading, setDeleteLoading] = useState(false);
   const vaultsGateway: VaultsGateway = container.resolve(VaultsGateway);
 
-  const { loading } = useApi<GetMyVaultsResponseDto>({
+  const { loading } = useApi<GetMyVaultsDataDto>({
     request: () => vaultsGateway.getMyVaults(),
     onSuccess: data => setVaults(data.myVaults),
     onError: error => setError(error),
@@ -53,7 +54,7 @@ export default function WorkspacePage(): JSX.Element {
       await vaultsGateway.deleteVault(id);
     } catch (error) {
       if (error instanceof Error) setError(error);
-      else console.error('Unhandled API error:', error);
+      else UiLogger.error('Unhandled API error: ', error);
     } finally {
       setDeleteLoading(false);
     }

src/modules/api/errors/internal-server.error.ts

@@ -0,0 +1,8 @@
+import { HttpError } from '@api/errors/abstract/http-error';
+import { StatusCodes } from 'http-status-codes';
+
+export class InternalServerError extends HttpError {
+  public constructor() {
+    super('Internal Server Error', StatusCodes.INTERNAL_SERVER_ERROR);
+  }
+}

src/modules/api/errors/prisma/invalid-request-data.error.ts

@@ -0,0 +1,8 @@
+import { HttpError } from '@api/errors/abstract/http-error';
+import { StatusCodes } from 'http-status-codes';
+
+export class InvalidRequestDataError extends HttpError {
+  public constructor() {
+    super('Invalid request data', StatusCodes.BAD_REQUEST);
+  }
+}

src/modules/api/errors/prisma/requested-value-too-long.error.ts

@@ -0,0 +1,8 @@
+import { HttpError } from '@api/errors/abstract/http-error';
+import { StatusCodes } from 'http-status-codes';
+
+export class RequestedValueTooLongError extends HttpError {
+  public constructor() {
+    super('One of the requested values is too long', StatusCodes.BAD_REQUEST);
+  }
+}

src/modules/api/errors/prisma/resource-already-exists.error.ts

@@ -0,0 +1,8 @@
+import { HttpError } from '@api/errors/abstract/http-error';
+import { StatusCodes } from 'http-status-codes';
+
+export class ResourceAlreadyExistsError extends HttpError {
+  public constructor() {
+    super('Resource already exists', StatusCodes.CONFLICT);
+  }
+}

src/modules/api/errors/no-vault-found.error.ts → src/modules/api/errors/prisma/resource-not-found.error.ts

@@ -1,8 +1,8 @@
 import { HttpError } from '@api/errors/abstract/http-error';
 import { StatusCodes } from 'http-status-codes';
 
-export class NoVaultFoundError extends HttpError {
+export class ResourceNotFoundError extends HttpError {
   public constructor() {
-    super('Vault not found', StatusCodes.NOT_FOUND);
+    super('Resource not found', StatusCodes.NOT_FOUND);
   }
 }

src/modules/api/errors/vault-already-exists.error.ts

@@ -0,0 +1,8 @@
+import { HttpError } from '@api/errors/abstract/http-error';
+import { StatusCodes } from 'http-status-codes';
+
+export class VaultAlreadyExistsError extends HttpError {
+  public constructor(label: string) {
+    super(`Vault with label '${label}' already exists`, StatusCodes.CONFLICT);
+  }
+}

src/modules/api/utils/handle-api-request.ts → src/modules/api/helpers/handle-api-request.ts

@@ -1,29 +1,35 @@
 import { HttpError } from '@api/errors/abstract/http-error';
 import { StatusCodes } from 'http-status-codes';
 import { NextResponse } from 'next/server';
+import type { HttpResponseDto } from '@shared/dto/output/responses/abstract/http.response.dto';
+import { ApiLogger } from '@api/logs/api.logger';
 
-export async function handleApiRequest<T>(
-  callback: () => Promise<T>,
+export async function handleApiRequest<Data>(
+  callback: () => Promise<Data>,
   successStatusCode?: StatusCodes
-): Promise<NextResponse> {
+): Promise<NextResponse<HttpResponseDto<Data>>> {
   try {
-    const data: Awaited<T> = await callback();
+    const data: Awaited<Data> = await callback();
 
     if (successStatusCode === StatusCodes.NO_CONTENT) {
       return new NextResponse(null, { status: StatusCodes.NO_CONTENT });
     }
 
-    return NextResponse.json(data, {
-      status: successStatusCode || StatusCodes.OK,
-    });
-  } catch (error) {
+    return NextResponse.json(
+      { data },
+      {
+        status: successStatusCode || StatusCodes.OK,
+      }
+    );
+  } catch (error: unknown) {
     if (error instanceof HttpError) {
       return NextResponse.json(
         { error: error.message },
         { status: error.status }
       );
     }
-    console.error(error);
+
+    ApiLogger.error('Error while handling API errors: ', error);
     return NextResponse.json(
       { error: 'Internal Server Error' },
       { status: StatusCodes.INTERNAL_SERVER_ERROR }