@dalmore/api-contracts 0.0.0-dev.d07da18 → 0.0.0-dev.d29fb02

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

@@ -1,271 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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

@@ -1,200 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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',
-  },
-);