@jumentix/cli-init 0.0.0

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

@@ -0,0 +1,40 @@
+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 { UserController, UserEmailDeleteRequestEvent } from '@src/modules/Users';
+
+const deleteEmail: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}/deleteEmail/{emailId}',
+    method: 'delete',
+
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await (controller! as UserController)
+          .deleteEmail(new UserEmailDeleteRequestEvent({
+            authorization: req.headers.authorization ?? '',
+            params,
+            schemaOAS: endPointConfig
+          }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default deleteEmail;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/deleteOne.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 { UserDeleteRequestEvent } from '@src/modules/Users/events/UserDeleteRequestEvent';
+
+const deleteOne: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}',
+    method: 'delete',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await controller!.delete!(new UserDeleteRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          schemaOAS: endPointConfig,
+          params
+        }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default deleteOne;

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

@@ -0,0 +1,39 @@
+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 { OrganizationDeleteRequestEvent } from '@src/modules/Users/events/OrganizationDeleteRequestEvent';
+
+const deleteOrganization: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/organizations/{id}',
+    method: 'delete',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const domainEvent = new OrganizationDeleteRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          schemaOAS: endPointConfig,
+          params
+        });
+        const { result, error } = await controller!.deleteOrganization!(domainEvent);
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default deleteOrganization;

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

@@ -0,0 +1,11 @@
+import { OrganizationAddressDeleteRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/deleteAddress/{addressId}',
+  method: 'delete',
+  statusCode: 200,
+  EventClass: OrganizationAddressDeleteRequestEvent,
+  controllerMethod: 'deleteOrganizationAddress',
+  withBody: false
+});

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

@@ -0,0 +1,11 @@
+import { OrganizationEmailDeleteRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/deleteEmail/{emailId}',
+  method: 'delete',
+  statusCode: 200,
+  EventClass: OrganizationEmailDeleteRequestEvent,
+  controllerMethod: 'deleteOrganizationEmail',
+  withBody: false
+});

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

@@ -0,0 +1,11 @@
+import { OrganizationPhoneDeleteRequestEvent } from '@src/modules/Users';
+import { createOrganizationMutationHandler } from './_organizationMutationHandlerFactory';
+
+export default createOrganizationMutationHandler({
+  path: '/organizations/{id}/deletePhone/{phoneId}',
+  method: 'delete',
+  statusCode: 200,
+  EventClass: OrganizationPhoneDeleteRequestEvent,
+  controllerMethod: 'deleteOrganizationPhone',
+  withBody: false
+});

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

@@ -0,0 +1,40 @@
+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 { UserController, UserPhoneDeleteRequestEvent } from '@src/modules/Users';
+
+const deletePhone: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}/deletePhone/{phoneId}',
+    method: 'delete',
+
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await (controller! as UserController)
+          .deletePhone(new UserPhoneDeleteRequestEvent({
+            authorization: req.headers.authorization ?? '',
+            params,
+            schemaOAS: endPointConfig
+          }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default deletePhone;

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

@@ -0,0 +1,45 @@
+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 { UserGetAllRequestEvent } from '@src/modules/Users/events/UserGetAllRequestEvent';
+
+const getAll: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users',
+    method: 'get',
+
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const queryString = req.query as Record<string, any> || {};
+        if (!queryString.page) queryString.page = 1;
+        const {
+          result, error, page, size, total
+        } = await controller!.getAll!(new UserGetAllRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          schemaOAS: endPointConfig,
+          queryString
+        }));
+        // console.log({ error });
+        if (error) throw error;
+        return res.status(200).json({
+          result, error, page, size, total
+        });
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default getAll;

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

@@ -0,0 +1,43 @@
+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 { OrganizationGetAllRequestEvent } from '@src/modules/Users/events/OrganizationGetAllRequestEvent';
+
+const getAllOrganizations: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/organizations',
+    method: 'get',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const queryString = req.query as Record<string, any> || {};
+        if (!queryString.page) queryString.page = 1;
+        const {
+          result, error, page, size, total
+        } = await controller!.getAllOrganizations!(new OrganizationGetAllRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          schemaOAS: endPointConfig,
+          queryString
+        }));
+        if (error) throw error;
+        return res.status(200).json({
+          result, error, page, size, total
+        });
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default getAllOrganizations;

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

@@ -0,0 +1,39 @@
+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 { UserGetOneRequestEvent } from '@src/modules/Users/events/UserGetOneRequestEvent';
+
+const getOneById: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}',
+    method: 'get',
+
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const { result, error } = await controller!.getOneById!(new UserGetOneRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          schemaOAS: endPointConfig,
+          params
+        }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default getOneById;

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

@@ -0,0 +1,39 @@
+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 { OrganizationGetOneRequestEvent } from '@src/modules/Users/events/OrganizationGetOneRequestEvent';
+
+const getOrganizationById: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/organizations/{id}',
+    method: 'get',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const params = req.params as Record<string, any>;
+        const domainEvent = new OrganizationGetOneRequestEvent({
+          authorization: req.headers.authorization ?? '',
+          schemaOAS: endPointConfig,
+          params
+        });
+        const { result, error } = await controller!.getOrganizationById!(domainEvent);
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default getOrganizationById;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/login.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 type { ILoginRequest } from '@src/modules/Users';
+import { LoginRequestEvent } from '@src/modules/Users';
+
+const login: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/auth/login',
+    method: 'post',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const { result, error } = await controller!.login!(new LoginRequestEvent<ILoginRequest>({
+          input: req.body as ILoginRequest,
+          schemaOAS: endPointConfig
+        }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default login;

package/templates/backend/src/modules/Users/interface/restapi/frameworks/vercel-functions/handlers/logout.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 type { ILogoutRequest } from '@src/modules/Users';
+import { LogoutRequestEvent } from '@src/modules/Users';
+
+const logout: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/auth/logout',
+    method: 'post',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const { result, error } = await controller!.logout!(new LogoutRequestEvent<ILogoutRequest>({
+          authorization: req.headers.authorization ?? '',
+          input: req.body as ILogoutRequest,
+          schemaOAS: endPointConfig
+        }));
+        if (error) throw error;
+        return res.status(200).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default logout;

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

@@ -0,0 +1,39 @@
+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 { IRegisterRequest } from '@src/modules/Users';
+import { RegisterRequestEvent } from '@src/modules/Users';
+
+const register: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/auth/register',
+    method: 'post',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      try {
+        const { result, error } = await controller!.register!(
+          new RegisterRequestEvent<IRegisterRequest>({
+            input: req.body as IRegisterRequest,
+            schemaOAS: endPointConfig
+          })
+        );
+        if (error) throw error;
+        return res.status(201).json(result);
+      } catch (error: any) {
+        return sendErrorResponse(error, res);
+      }
+    }
+  };
+};
+
+export default register;

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

@@ -0,0 +1,39 @@
+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 { UserUpdateRequestEvent } from '@src/modules/Users/events/UserUpdateRequestEvent';
+
+const update: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/users/{id}',
+    method: 'put',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      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/vercel-functions/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/vercel-functions/handlers/updateEmail.ts

@@ -0,0 +1,42 @@
+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 { 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: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      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/vercel-functions/handlers/updateOrganization.ts

@@ -0,0 +1,40 @@
+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 { OrganizationUpdateRequestEvent } from '@src/modules/Users/events/OrganizationUpdateRequestEvent';
+
+const updateOrganization: EndPointFactory = (
+  {
+    endPointConfig,
+    controller
+  }: IHandlerFactory
+): IbaseHandler => {
+  return {
+    path: '/organizations/{id}',
+    method: 'put',
+    async handler(req: VercelFunctionsRequest, res: VercelFunctionsResponse) {
+      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/vercel-functions/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/vercel-functions/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/vercel-functions/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'
+});