@dalmore/api-contracts 0.0.0-dev.2dc8e92

package/contracts/compliance/user-manuals/index.ts

@@ -0,0 +1,271 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  GetUserManualCategoryZod,
+  IPaginatedUserManualCategory,
+  IUserManualCategory,
+  IUserManualPage,
+  userManualCategoriesIncludeQuery,
+  userManualCategorySchema,
+  userManualPageSchema,
+  PostUserManualCategoryZod,
+  PostUserManualPageZod,
+  PatchUserManualCategoryZod,
+  PatchUserManualPageZod,
+  IUserManualPageUrl,
+  PatchUserManualPageUrlZod,
+  OrderUserManualCategoriesZod,
+  UserManualOrderResponseZod,
+  OrderUserManualPagesZod,
+  userManualPageUrlSchema,
+  PostUserManualPageUrlZod,
+  UserManualsPaginationOptionsZod,
+} from '../../../common/types/user-manual.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const userManualsContract = c.router(
+  {
+    getUserManualCategories: {
+      summary: 'Get user manual Categories',
+      method: 'GET',
+      path: '/categories',
+      metadata: {
+        auth: true,
+      },
+      query: UserManualsPaginationOptionsZod.merge(
+        userManualCategoriesIncludeQuery,
+      ).merge(GetUserManualCategoryZod),
+      responses: {
+        200: IPaginatedUserManualCategory,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getUserManualCategory: {
+      summary: 'Get user manual category',
+      method: 'GET',
+      path: '/categories/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualCategorySchema,
+      }),
+      query: z.object({}).merge(userManualCategoriesIncludeQuery),
+      responses: {
+        200: IUserManualCategory,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    postUserManualCategory: {
+      summary: '[ADMIN] Create user manual category',
+      method: 'POST',
+      path: '/categories',
+      metadata: {
+        auth: true,
+      },
+      body: PostUserManualCategoryZod,
+      responses: {
+        201: IUserManualCategory,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    patchUserManualCategory: {
+      summary: '[ADMIN] Update user manual category',
+      method: 'PATCH',
+      path: '/categories/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualCategorySchema,
+      }),
+      body: PatchUserManualCategoryZod,
+      responses: {
+        200: IUserManualCategory,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deleteUserManualCategory: {
+      summary: '[ADMIN] Delete user manual category',
+      method: 'DELETE',
+      path: '/categories/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualCategorySchema,
+      }),
+      responses: {
+        200: UserManualOrderResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    patchUserManualCategoriesOrder: {
+      summary: '[ADMIN] Update user manual categories order',
+      method: 'PATCH',
+      path: '/categories/order',
+      metadata: {
+        auth: true,
+      },
+      body: OrderUserManualCategoriesZod,
+      responses: {
+        200: UserManualOrderResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    postUserManualPage: {
+      summary: '[ADMIN] Create user manual page',
+      method: 'POST',
+      path: '/pages',
+      metadata: {
+        auth: true,
+      },
+      body: PostUserManualPageZod,
+      responses: {
+        201: IUserManualPage,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+
+    deleteUserManualPage: {
+      summary: '[ADMIN] Delete user manual page',
+      method: 'DELETE',
+      path: '/pages/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualPageSchema,
+      }),
+      responses: {
+        200: UserManualOrderResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    patchUserManualPagesOrder: {
+      summary: '[ADMIN] Update user manual pages order',
+      method: 'PATCH',
+      path: '/pages/order',
+      metadata: {
+        auth: true,
+      },
+      body: OrderUserManualPagesZod,
+      responses: {
+        200: UserManualOrderResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    patchUserManualPage: {
+      summary: '[ADMIN] Update user manual page',
+      method: 'PATCH',
+      path: '/pages/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualPageSchema,
+      }),
+      body: PatchUserManualPageZod,
+      responses: {
+        200: IUserManualPage,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchUserManualPageUrl: {
+      summary: '[ADMIN] Update user manual page url',
+      method: 'PATCH',
+      path: '/page-urls/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualPageUrlSchema,
+      }),
+      body: PatchUserManualPageUrlZod,
+      responses: {
+        200: IUserManualPageUrl,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postUserManualPageUrl: {
+      summary: '[ADMIN] Create user manual page url',
+      method: 'POST',
+      path: '/page-urls',
+      metadata: {
+        auth: true,
+      },
+      body: PostUserManualPageUrlZod,
+      responses: {
+        201: IUserManualPageUrl,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    deleteUserManualPageUrl: {
+      summary: '[ADMIN] Delete user manual page url',
+      method: 'DELETE',
+      path: '/page-urls/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualPageUrlSchema,
+      }),
+      responses: {
+        200: UserManualOrderResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'user-manuals',
+  },
+);

package/contracts/compliance/user-settings/index.ts

@@ -0,0 +1,189 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  UserZod,
+} from '../../../common/types';
+import {
+  disableTwoFactorBody,
+  sendEmailVerificationBody,
+  sendEmailVerificationResponse,
+  sendVerificationCodeBody,
+  sendVerificationCodeResponse,
+  setupPhoneNumberBody,
+  setupPhoneNumberResponse,
+  setupTwoFactorResponse,
+  userSettingsZod,
+  validPhoneNumberBody,
+  validPhoneNumberResponse,
+  verifyEmailBody,
+  verifyEmailResponse,
+  verifyPhoneNumberBody,
+  verifyPhoneNumberResponse,
+  verifyTwoFactorBody,
+  verifyTwoFactorResponse,
+} from '../../../common/types/user-setting.types';
+
+const c = initContract();
+
+export const userSettingsContract = c.router(
+  {
+    getUserSettings: {
+      summary: 'Get current user settings',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: userSettingsZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    validPhoneNumber: {
+      summary: 'Validate phone number',
+      method: 'POST',
+      path: '/valid-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: validPhoneNumberBody,
+      responses: {
+        200: validPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    setupPhoneNumber: {
+      summary: 'Setup phone number',
+      method: 'POST',
+      path: '/setup-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: setupPhoneNumberBody,
+      responses: {
+        200: setupPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    verifyPhoneNumber: {
+      summary: 'Verify phone number',
+      method: 'POST',
+      path: '/verify-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: verifyPhoneNumberBody,
+      responses: {
+        200: verifyPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    sendVerificationCode: {
+      summary: 'Send verification code',
+      method: 'POST',
+      path: '/send-verification-code',
+      metadata: {
+        auth: true,
+      },
+      body: sendVerificationCodeBody,
+      responses: {
+        200: sendVerificationCodeResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    setupTwoFactorAuthenticator: {
+      summary: 'Setup 2FA',
+      method: 'GET',
+      path: '/setup-authenticator',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: setupTwoFactorResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    verifyTwoFactorAuthenticator: {
+      summary: 'Verify 2FA',
+      method: 'POST',
+      path: '/verify-authenticator',
+      body: verifyTwoFactorBody,
+      responses: {
+        201: verifyTwoFactorResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    sendEmailVerification: {
+      summary: 'Send email verification code',
+      method: 'POST',
+      path: '/send-email-verification',
+      metadata: {
+        auth: true,
+      },
+      body: sendEmailVerificationBody,
+      responses: {
+        200: sendEmailVerificationResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        429: BadRequestError,
+        500: InternalError,
+      },
+    },
+    verifyEmail: {
+      summary: 'Verify email with code',
+      method: 'POST',
+      path: '/verify-email',
+      metadata: {
+        auth: true,
+      },
+      body: verifyEmailBody,
+      responses: {
+        200: verifyEmailResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    disableTwoFactor: {
+      summary: '[ADMIN] Disable 2FA for user',
+      method: 'POST',
+      path: '/disable-2fa',
+      metadata: {
+        auth: true,
+      },
+      body: disableTwoFactorBody,
+      responses: {
+        201: UserZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'user-settings',
+  },
+);

package/contracts/compliance/users/index.ts

@@ -0,0 +1,200 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  GetMeResponse,
+  InternalError,
+  IPaginatedUser,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  UserFiltersZod,
+  UserMeUpdateZod,
+  UsersIncludeQuery,
+  UserUpdateZod,
+  UserWithoutPasswordZod,
+  UserZod,
+  UsersSummaryFilterZod,
+  IPaginatedUsersSummaryResponse,
+  BadRequestError,
+  userIdSchema,
+  UserDeleteResponse,
+  IssuersActiveStatusUpdateZod,
+  UpdateLockedStatus,
+  UpdateUserRoleZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const usersContract = c.router(
+  {
+    me: {
+      summary: 'Get current user',
+      method: 'GET',
+      path: '/me',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: GetMeResponse,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateMe: {
+      summary: 'Update current user',
+      method: 'PATCH',
+      path: '/me',
+      metadata: {
+        auth: true,
+      },
+      body: UserMeUpdateZod,
+      responses: {
+        201: UserWithoutPasswordZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getUsersSummary: {
+      summary: 'Get users summary with pagination',
+      method: 'GET',
+      path: '/summary',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(UsersSummaryFilterZod),
+      responses: {
+        200: IPaginatedUsersSummaryResponse,
+        404: NotFoundError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getUsers: {
+      summary: 'Get users',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(UserFiltersZod).merge(UsersIncludeQuery),
+      responses: {
+        200: IPaginatedUser,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getUser: {
+      summary: 'Get user by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(UsersIncludeQuery),
+      pathParams: z.object({
+        id: z.string(),
+      }),
+      responses: {
+        200: UserZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    updateUser: {
+      summary: 'Update user by id',
+      method: 'PATCH',
+      path: '/admin/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: z.string(),
+      }),
+      body: UserUpdateZod,
+      responses: {
+        200: UserWithoutPasswordZod,
+        404: NotFoundError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    deleteUser: {
+      summary: 'Delete user by id',
+      method: 'DELETE',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userIdSchema,
+      }),
+      responses: {
+        200: UserDeleteResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateActiveStatus: {
+      summary: '[Admin] Update user active status',
+      method: 'PATCH',
+      path: '/active/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: userIdSchema }),
+      body: IssuersActiveStatusUpdateZod,
+      responses: {
+        201: z.object({ message: z.string() }),
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateRole: {
+      summary:
+        '[Admin] Update user role for compliance as well as other portals ',
+      method: 'PATCH',
+      path: '/role',
+      metadata: {
+        auth: true,
+      },
+      body: UpdateUserRoleZod,
+      responses: {
+        201: UserWithoutPasswordZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateLockedStatus: {
+      summary: '[Admin] Update user locked status',
+      method: 'PATCH',
+      path: '/:id/locked',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: userIdSchema }),
+      body: UpdateLockedStatus,
+      responses: {
+        201: z.object({ message: z.string() }),
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'users',
+  },
+);

package/contracts/compliance/webhooks/index.ts

@@ -0,0 +1,41 @@
+import { initContract } from '@ts-rest/core';
+import { StripeWebhookEvent } from '../../../common/types/webhook.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const webhooksContract = c.router(
+  {
+    postWebHookStripe: {
+      summary: '[Stripe] webhook',
+      method: 'POST',
+      path: '/stripe',
+      metadata: {
+        auth: true,
+      },
+      body: StripeWebhookEvent, // TODO: remove schema validation instead do it in the service
+      responses: {
+        200: z.object({
+          received: z.boolean(),
+        }),
+      },
+    },
+    postWebHookPersona: {
+      summary: '[Persona] webhook',
+      method: 'POST',
+      path: '/persona',
+      metadata: {
+        auth: true,
+      },
+      body: z.any(), // schema is validated in the service to prevent 400 response to sender
+      responses: {
+        200: z.object({
+          received: z.boolean(),
+        }),
+      },
+    },
+  },
+  {
+    pathPrefix: 'webhooks',
+  },
+);