feat: add customizable preset limit

apps/api/src/app.ts

@@ -18,6 +18,7 @@ declare module 'fastify' {
       CLIENT_SECRET_AUTH?: string;
       GRANT_TYPE_AUTH0?: string;
       ALLOWED_ORIGINS?: string;
+      PRESETS_LIMIT?: number;
     };
   }
 }
@@ -45,6 +46,7 @@ const app: FastifyPluginAsync<AppOptions> = async (
       AUDIENCE_AUTH0: Type.RegEx(/^https?:/),
       GRANT_TYPE_AUTH0: Type.String(),
       ALLOWED_ORIGINS: Type.String(),
+      PRESETS_LIMIT: Type.Number({default: Number.MAX_SAFE_INTEGER}),
     }),
   });
 

apps/api/src/common/exceptions/UnprocessableEntityException.ts

@@ -0,0 +1,10 @@
+import {HandlerError} from './HandlerError';
+
+export abstract class UnprocessableEntityException<
+  Args extends Record<string, string | number> | void = void,
+> extends HandlerError<Args> {
+  statusCode = HandlerError.httpStatusCode.HTTP_STATUS_UNPROCESSABLE_ENTITY;
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  abstract createMessage(args: Args): string;
+}

apps/api/src/modules/preset/exceptions/ExceedPresetLimitException.ts

@@ -0,0 +1,16 @@
+import {UnprocessableEntityException} from '../../../common/exceptions/UnprocessableEntityException';
+
+export class ExceedPresetLimitException extends UnprocessableEntityException<{
+  limit: number;
+}> {
+  limit: number;
+
+  constructor(options: {limit: number}) {
+    super();
+    this.limit = options.limit;
+  }
+
+  createMessage(): string {
+    return `Preset limit per account exceeded`;
+  }
+}

apps/api/src/modules/preset/handlers/create.ts

@@ -1,16 +1,22 @@
 import {HandlerBuilder} from '../../../common/domainFunctions/builder';
+import {ExceedPresetLimitException} from '../exceptions/ExceedPresetLimitException';
 import {PresetCreateDto} from '../schema/preset-create-dto.schema';
 import {PresetDto} from '../schema/preset-dto.schema';
 import {PresetHandlerDependencies} from './';
 
 export const create =
   HandlerBuilder.withDependencies<PresetHandlerDependencies>()
     .withName('createPreset')
-    .withImplementation(({repository, mapper}) => {
+    .withImplementation(({repository, mapper, config, logger}) => {
       return async (
         ownerId: string,
         data: PresetCreateDto,
       ): Promise<PresetDto> => {
+        const count = repository.countByOwnerId(ownerId);
+        if (config.PRESETS_LIMIT && (await count) > config.PRESETS_LIMIT) {
+          throw new ExceedPresetLimitException({limit: config.PRESETS_LIMIT});
+        }
+
         const createdPreset = await repository.create({
           name: data.name,
           data: data.data,

apps/api/src/modules/preset/handlers/index.ts

@@ -1,7 +1,10 @@
+import {FastifyInstance} from 'fastify';
 import {PresetMapper} from '../mapper';
 import {PresetRepository} from '../repository';
 
 export type PresetHandlerDependencies = {
   repository: PresetRepository;
   mapper: PresetMapper;
+  config: FastifyInstance['config'];
+  logger: FastifyInstance['log'];
 };

apps/api/src/modules/preset/index.ts

@@ -23,7 +23,12 @@ const preset: FastifyPluginAsync = async fastify => {
     'presetService',
     registerHandlers(
       handlers,
-      {repository: fastify.presetRepository, mapper},
+      {
+        repository: fastify.presetRepository,
+        mapper,
+        config: fastify.config,
+        logger: fastify.log,
+      },
       fastify.handlerRegistry,
     ),
   );

apps/api/src/modules/preset/repository/preset.repository.ts

@@ -6,6 +6,8 @@ export interface PresetRepository {
 
   findAllByOwnerId(ownerId: string): Promise<readonly Preset[]>;
 
+  countByOwnerId(ownerId: string): Promise<number>;
+
   create(data: PresetCreateRequest): Promise<Preset>;
 
   update(id: string, data: PresetUpdateRequest): Promise<Preset>;

apps/api/src/modules/preset/repository/prisma-preset.repository.ts

@@ -44,6 +44,10 @@ export class PrismaPresetRepository implements PresetRepository {
     });
   }
 
+  countByOwnerId(ownerId: string): Promise<number> {
+    return this.client.preset.count({where: {ownerId}});
+  }
+
   update(id: string, data: PresetCreateRequest): Promise<Preset> {
     return this.client.preset.update({
       where: {

apps/api/src/plugins/errorHandler.ts

@@ -4,7 +4,7 @@ import {NotFoundEntityException} from '../common/exceptions/NotFoundEntityExcept
 
 export default fp(
   async fastify => {
-    fastify.setErrorHandler(error => {
+    fastify.setErrorHandler((error, request, reply) => {
       let httpError: HttpError | null = null;
 
       if (error.statusCode) {
@@ -22,13 +22,11 @@ export default fp(
         httpError.stack = error.stack;
         httpError.code = error.code;
 
-        return httpError;
+        return reply.send(httpError);
       }
 
-      return error;
+      reply.send(error);
     });
-
-    return;
   },
   {name: 'appErrorsHandler'},
 );