@jumentix/cli-init 0.0.0

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/update.ts

@@ -0,0 +1,39 @@
+import type { TotalJsRequest, TotalJsResponse } from '@src/interface/HTTP/adapters/total-js/TotalJsServer';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/total-js/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import { UserUpdateRequestEvent } from '@src/modules/Users/events/UserUpdateRequestEvent';
+
+const update: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}',
+    method: 'put',
+    async handler(req: TotalJsRequest, res: TotalJsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await controller!.update!(new UserUpdateRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          input: req.body,
+          schemaOAS: endPointConfig,
+          params
+        }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default update;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updateDocument.ts

@@ -0,0 +1,10 @@
+import { UserDocumentUpdateRequestEvent } from '@src/modules/Users';
+import { createDocumentMutationHandler } from './_documentMutationHandlerFactory';
+
+export default createDocumentMutationHandler({
+  path: '/users/{id}/updateDocument/{documentId}',
+  method: 'put',
+  statusCode: 200,
+  EventClass: UserDocumentUpdateRequestEvent,
+  controllerMethod: 'updateDocument'
+});

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updateEmail.ts

@@ -0,0 +1,42 @@
+import type { TotalJsRequest, TotalJsResponse } from '@src/interface/HTTP/adapters/total-js/TotalJsServer';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/total-js/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import type { RequestUpdateEmail } from '@src/modules/Users';
+import { UserController, UserEmailUpdateRequestEvent } from '@src/modules/Users';
+
+const updateEmail: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}/updateEmail/{emailId}',
+    method: 'put',
+
+    async handler(req: TotalJsRequest, res: TotalJsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await (controller! as UserController)
+          .updateEmail(new UserEmailUpdateRequestEvent({
+            authorization: req.headers.authorization ?? '',
+            params,
+            input: req.body as RequestUpdateEmail,
+            schemaOAS: endPointConfig
+          }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default updateEmail;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updateOrganization.ts

@@ -0,0 +1,40 @@
+import type { TotalJsRequest, TotalJsResponse } from '@src/interface/HTTP/adapters/total-js/TotalJsServer';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/total-js/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import { OrganizationUpdateRequestEvent } from '@src/modules/Users/events/OrganizationUpdateRequestEvent';
+
+const updateOrganization: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/organizations/{id}',
+    method: 'put',
+    async handler(req: TotalJsRequest, res: TotalJsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const domainEvent = new OrganizationUpdateRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          input: req.body,
+          schemaOAS: endPointConfig,
+          params
+        });
+        const { result, error } = await controller!.updateOrganization!(domainEvent);
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default updateOrganization;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updateOrganizationAddress.ts

@@ -0,0 +1,10 @@
+import { OrganizationAddressUpdateRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/updateAddress/{addressId}',
+  method: 'put',
+  statusCode: 200,
+  EventClass: OrganizationAddressUpdateRequestEvent,
+  controllerMethod: 'updateOrganizationAddress'
+});

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updateOrganizationEmail.ts

@@ -0,0 +1,10 @@
+import { OrganizationEmailUpdateRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/updateEmail/{emailId}',
+  method: 'put',
+  statusCode: 200,
+  EventClass: OrganizationEmailUpdateRequestEvent,
+  controllerMethod: 'updateOrganizationEmail'
+});

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updateOrganizationPhone.ts

@@ -0,0 +1,10 @@
+import { OrganizationPhoneUpdateRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/updatePhone/{phoneId}',
+  method: 'put',
+  statusCode: 200,
+  EventClass: OrganizationPhoneUpdateRequestEvent,
+  controllerMethod: 'updateOrganizationPhone'
+});

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updatePassword.ts

@@ -0,0 +1,42 @@
+import type { TotalJsRequest, TotalJsResponse } from '@src/interface/HTTP/adapters/total-js/TotalJsServer';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/total-js/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import type { RequestUpdatePassword } from '@src/modules/Users';
+import { UserController, UserPasswordUpdateRequestEvent } from '@src/modules/Users';
+
+const updatePassword: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}/updatePassword',
+    method: 'put',
+
+    async handler(req: TotalJsRequest, res: TotalJsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await (controller! as UserController)
+          .updatePassword(new UserPasswordUpdateRequestEvent({
+            authorization: req.headers.authorization ?? '',
+            params,
+            input: req.body as RequestUpdatePassword,
+            schemaOAS: endPointConfig
+          }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default updatePassword;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updatePhone.ts

@@ -0,0 +1,42 @@
+import type { TotalJsRequest, TotalJsResponse } from '@src/interface/HTTP/adapters/total-js/TotalJsServer';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/total-js/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import type { RequestUpdatePhone } from '@src/modules/Users';
+import { UserController, UserPhoneUpdateRequestEvent } from '@src/modules/Users';
+
+const updatePhone: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}/updatePhone/{phoneId}',
+    method: 'put',
+
+    async handler(req: TotalJsRequest, res: TotalJsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await (controller! as UserController)
+          .updatePhone(new UserPhoneUpdateRequestEvent({
+            authorization: req.headers.authorization ?? '',
+            params,
+            input: req.body as RequestUpdatePhone,
+            schemaOAS: endPointConfig
+          }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default updatePhone;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/total-js/handlers/updateUserPassword.ts

@@ -0,0 +1,40 @@
+import type { TotalJsRequest, TotalJsResponse } from '@src/interface/HTTP/adapters/total-js/TotalJsServer';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/total-js/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import type { IUpdatePasswordRequest } from '@src/modules/Users';
+import { UpdatePasswordRequestEvent } from '@src/modules/Users';
+
+const updateUserPassword: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/auth/updateUserPassword',
+    method: 'post',
+    async handler(req: TotalJsRequest, res: TotalJsResponse) {
+      try {
+        const { result, error } = await controller!.updatePassword!(
+          new UpdatePasswordRequestEvent<IUpdatePasswordRequest>({
+            authorization: req.headers.authorization ?? '',
+            input: req.body as IUpdatePasswordRequest,
+            schemaOAS: endPointConfig
+          })
+        );
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default updateUserPassword;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/_documentMutationHandlerFactory.ts

@@ -0,0 +1,70 @@
+import { BaseError, EErrorStringCodes } from '@src/infra/exceptions';
+import { formatErrorMessage, toHttpStatus } from '@src/shared/utils';
+import { BaseDomainEvent } from '@src/modules/port/BaseDomainEvent';
+import { UserController } from '@src/modules/Users';
+import type {
+  IHandlerFactory,
+  EndPointFactory,
+  IbaseHandler
+} from '@src/interface/HTTP/ports';
+
+import type { VercelFunctionsRequest, VercelFunctionsResponse } from '@src/interface/HTTP/adapters/vercel-functions/vercel-functions';
+
+type ControllerMethod =
+  | 'createDocument'
+  | 'updateDocument'
+  | 'deleteDocument';
+
+type DocumentMutationHandlerFactoryConfig = {
+  path: string;
+  method: IbaseHandler['method'];
+  statusCode: number;
+  EventClass: new (message: Record<string, any>) => BaseDomainEvent;
+  controllerMethod: ControllerMethod;
+  withBody?: boolean;
+};
+
+function sendErrorResponse(error: BaseError, res: VercelFunctionsResponse) {
+  return res.status(toHttpStatus(error.code as EErrorStringCodes) || 500).json({
+    message: formatErrorMessage(error),
+    error
+  });
+}
+
+export const createDocumentMutationHandler = (
+  config: DocumentMutationHandlerFactoryConfig
+): EndPointFactory => {
+  const {
+    path,
+    method,
+    statusCode,
+    EventClass,
+    controllerMethod,
+    withBody = true
+  } = config;
+
+  return ({ endPointConfig, controller }: IHandlerFactory): IbaseHandler => {
+    return {
+      path,
+      method,
+      async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+        try {
+          const params = (req.params || {}) as Record<string, any>;
+          const domainEvent = new EventClass({
+            authorization: req.headers?.authorization ?? '',
+            params,
+            input: withBody ? req.body : undefined,
+            schemaOAS: endPointConfig
+          });
+          const { result, error } = await (controller! as UserController)[controllerMethod](
+            domainEvent
+          );
+          if (error) throw error;
+          return res.status(statusCode).json(result);
+        } catch (error: any) {
+          return sendErrorResponse(error, res);
+        }
+      }
+    };
+  };
+};

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/_organizationMutationHandlerFactory.ts

@@ -0,0 +1,76 @@
+import { BaseError, EErrorStringCodes } from '@src/infra/exceptions';
+import { formatErrorMessage, toHttpStatus } from '@src/shared/utils';
+import { BaseDomainEvent } from '@src/modules/port/BaseDomainEvent';
+import { OrganizationController } from '@src/modules/Users';
+import type {
+  IHandlerFactory,
+  EndPointFactory,
+  IbaseHandler
+} from '@src/interface/HTTP/ports';
+
+import type { VercelFunctionsRequest, VercelFunctionsResponse } from '@src/interface/HTTP/adapters/vercel-functions/vercel-functions';
+
+type ControllerMethod =
+  | 'createOrganizationAddress'
+  | 'updateOrganizationAddress'
+  | 'deleteOrganizationAddress'
+  | 'createOrganizationPhone'
+  | 'updateOrganizationPhone'
+  | 'deleteOrganizationPhone'
+  | 'createOrganizationEmail'
+  | 'updateOrganizationEmail'
+  | 'deleteOrganizationEmail';
+
+type OrganizationMutationHandlerFactoryConfig = {
+  path: string;
+  method: IbaseHandler['method'];
+  statusCode: number;
+  EventClass: new (message: Record<string, any>) => BaseDomainEvent;
+  controllerMethod: ControllerMethod;
+  withBody?: boolean;
+};
+
+function sendErrorResponse(error: BaseError, res: VercelFunctionsResponse) {
+  return res.status(toHttpStatus(error.code as EErrorStringCodes) || 500).json({
+    message: formatErrorMessage(error),
+    error
+  });
+}
+
+export const createOrganizationMutationHandler = (
+  config: OrganizationMutationHandlerFactoryConfig
+): EndPointFactory => {
+  const {
+    path,
+    method,
+    statusCode,
+    EventClass,
+    controllerMethod,
+    withBody = true
+  } = config;
+
+  return ({ endPointConfig, controller }: IHandlerFactory): IbaseHandler => {
+    return {
+      path,
+      method,
+      async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+        try {
+          const params = (req.params || {}) as Record<string, any>;
+          const domainEvent = new EventClass({
+            authorization: req.headers?.authorization ?? '',
+            params,
+            input: withBody ? req.body : undefined,
+            schemaOAS: endPointConfig
+          });
+          const { result, error } = await (controller! as OrganizationController)[controllerMethod](
+            domainEvent
+          );
+          if (error) throw error;
+          return res.status(statusCode).json(result);
+        } catch (error: any) {
+          return sendErrorResponse(error, res);
+        }
+      }
+    };
+  };
+};

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/create.ts

@@ -0,0 +1,37 @@
+import type { VercelFunctionsRequest, VercelFunctionsResponse } from '@src/interface/HTTP/adapters/vercel-functions/vercel-functions';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/vercel-functions/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import { UserCreateRequestEvent } from '@src/modules/Users/events/UserCreateRequestEvent';
+
+const create: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users',
+    method: 'post',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const { result, error } = await controller!.create!(new UserCreateRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          input: req.body,
+          schemaOAS: endPointConfig
+        }));
+        if (error) throw error;
+        return res.status(201).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default create;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/createDocument.ts

@@ -0,0 +1,10 @@
+import { UserDocumentCreateRequestEvent } from '@src/modules/Users';
+import { createDocumentMutationHandler } from './_documentMutationHandlerFactory';
+
+export default createDocumentMutationHandler({
+  path: '/users/{id}/createDocument',
+  method: 'post',
+  statusCode: 201,
+  EventClass: UserDocumentCreateRequestEvent,
+  controllerMethod: 'createDocument'
+});

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/createEmail.ts

@@ -0,0 +1,41 @@
+import type { VercelFunctionsRequest, VercelFunctionsResponse } from '@src/interface/HTTP/adapters/vercel-functions/vercel-functions';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/vercel-functions/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import type { RequestCreateEmail } from '@src/modules/Users';
+import { UserController, UserEmailCreateRequestEvent } from '@src/modules/Users';
+
+const createEmail: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}/createEmail',
+    method: 'post',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await (controller! as UserController)
+          .createEmail(new UserEmailCreateRequestEvent({
+            authorization: req.headers.authorization ?? '',
+            params,
+            input: req.body as RequestCreateEmail,
+            schemaOAS: endPointConfig
+          }));
+        if (error) throw error;
+        return res.status(201).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default createEmail;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/createOrganization.ts

@@ -0,0 +1,38 @@
+import type { VercelFunctionsRequest, VercelFunctionsResponse } from '@src/interface/HTTP/adapters/vercel-functions/vercel-functions';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/vercel-functions/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import { OrganizationCreateRequestEvent } from '@src/modules/Users/events/OrganizationCreateRequestEvent';
+
+const createOrganization: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/organizations',
+    method: 'post',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const domainEvent = new OrganizationCreateRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          input: req.body,
+          schemaOAS: endPointConfig
+        });
+        const { result, error } = await controller!.createOrganization!(domainEvent);
+        if (error) throw error;
+        return res.status(201).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default createOrganization;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/createOrganizationAddress.ts

@@ -0,0 +1,10 @@
+import { OrganizationAddressCreateRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/createAddress',
+  method: 'post',
+  statusCode: 201,
+  EventClass: OrganizationAddressCreateRequestEvent,
+  controllerMethod: 'createOrganizationAddress'
+});

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/createOrganizationEmail.ts

@@ -0,0 +1,10 @@
+import { OrganizationEmailCreateRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/createEmail',
+  method: 'post',
+  statusCode: 201,
+  EventClass: OrganizationEmailCreateRequestEvent,
+  controllerMethod: 'createOrganizationEmail'
+});

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/createOrganizationPhone.ts

@@ -0,0 +1,10 @@
+import { OrganizationPhoneCreateRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/createPhone',
+  method: 'post',
+  statusCode: 201,
+  EventClass: OrganizationPhoneCreateRequestEvent,
+  controllerMethod: 'createOrganizationPhone'
+});

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/createPhone.ts

@@ -0,0 +1,41 @@
+import type { VercelFunctionsRequest, VercelFunctionsResponse } from '@src/interface/HTTP/adapters/vercel-functions/vercel-functions';
+import { sendErrorResponse } from '@src/interface/HTTP/adapters/vercel-functions/responses/sendErrorResponse';
+
+import type {
+  IHandlerFactory,
+  IbaseHandler,
+  EndPointFactory
+} from '@src/interface/HTTP/ports';
+
+import type { RequestCreatePhone } from '@src/modules/Users';
+import { UserController, UserPhoneCreateRequestEvent } from '@src/modules/Users';
+
+const createPhone: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}/createPhone',
+    method: 'post',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await (controller! as UserController)
+          .createPhone(new UserPhoneCreateRequestEvent({
+            authorization: req.headers.authorization ?? '',
+            params,
+            input: req.body as RequestCreatePhone,
+            schemaOAS: endPointConfig
+          }));
+        if (error) throw error;
+        return res.status(201).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default createPhone;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/deleteDocument.ts

@@ -0,0 +1,11 @@
+import { UserDocumentDeleteRequestEvent } from '@src/modules/Users';
+import { createDocumentMutationHandler } from './_documentMutationHandlerFactory';
+
+export default createDocumentMutationHandler({
+  path: '/users/{id}/deleteDocument/{documentId}',
+  method: 'delete',
+  statusCode: 200,
+  EventClass: UserDocumentDeleteRequestEvent,
+  controllerMethod: 'deleteDocument',
+  withBody: false
+});