@dalmore/api-contracts 1.0.3 → 1.0.5

package/src/contracts/compliance/assets/index.ts

@@ -1,122 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ConflictError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  AssetFiltersZod,
-  assetIdSchema,
-  AssetsIncludeQuery,
-  AssetSummaryFiltersZod,
-  IAsset,
-  IPaginatedAsset,
-  CompliancePostAsset,
-  CompliancePutAsset,
-  AssetSortZod,
-} from '../../../common/types/asset.types';
-import { z } from 'zod';
-
-const c = initContract();
-export const assetsContract = c.router(
-  {
-    getAssetsSummary: {
-      summary: 'Get assets summary',
-      method: 'GET',
-      path: '/summary',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(AssetSummaryFiltersZod),
-      responses: {
-        200: IPaginatedAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getAssets: {
-      summary: 'Get assets',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(AssetsIncludeQuery)
-        .merge(AssetFiltersZod)
-        .merge(AssetSortZod),
-      responses: {
-        200: IPaginatedAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getAsset: {
-      summary: 'Get asset by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(AssetsIncludeQuery),
-      pathParams: z.object({
-        id: assetIdSchema,
-      }),
-      responses: {
-        200: IAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postAssets: {
-      summary: 'Create an asset',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostAsset,
-      responses: {
-        201: IAsset,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        409: ConflictError,
-        500: InternalError,
-      },
-    },
-    updateAsset: {
-      summary: 'Update asset',
-      method: 'PUT',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: assetIdSchema,
-      }),
-      body: CompliancePutAsset,
-      responses: {
-        201: IAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-
-  {
-    pathPrefix: 'assets',
-  },
-);

package/src/contracts/compliance/auth/index.ts

@@ -1,134 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  AccessTokenResponse,
-  AdminForgotPasswordRequestZod,
-  BadRequestError,
-  IChangePasswordBodyZod,
-  InternalError,
-  IRegisterBodyZod,
-  LoginBody,
-  LoginBody2FA,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const authContract = c.router(
-  {
-    registerEmail: {
-      summary: 'Register with email',
-      method: 'POST',
-      path: 'register/email',
-      body: IRegisterBodyZod,
-      responses: {
-        201: AccessTokenResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    loginEmail: {
-      summary: 'Login with email',
-      method: 'POST',
-      path: 'login/email',
-      headers: z.object({
-        'user-agent': z.string(),
-      }),
-      body: LoginBody,
-      responses: {
-        200: AccessTokenResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    forgotPassword: {
-      summary: 'Forgot password',
-      method: 'POST',
-      path: 'forgot-password',
-      body: z.object({
-        email: z.string().email(),
-      }),
-      responses: {
-        200: null,
-        400: BadRequestError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    adminForgotPassword: {
-      summary: '[ADMIN] Forgot password',
-      method: 'POST',
-      path: 'forgot-password/admin',
-      body: AdminForgotPasswordRequestZod,
-      responses: {
-        200: z.string(),
-        400: BadRequestError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    resetPasswordVerify: {
-      summary: 'Reset password verify',
-      method: 'POST',
-      path: 'reset-password/verify',
-      body: z.object({
-        email: z.string().email(),
-        code: z.string(),
-      }),
-      responses: {
-        200: z.object({
-          valid: z.boolean(),
-        }),
-        400: BadRequestError,
-      },
-    },
-    resetPassword: {
-      summary: 'Reset password',
-      method: 'POST',
-      path: 'reset-password',
-      body: z.object({
-        email: z.string().email(),
-        code: z.string(),
-        password: z.string().min(6),
-      }),
-      responses: {
-        200: null,
-        400: BadRequestError,
-        500: InternalError,
-      },
-    },
-    changePassword: {
-      summary: 'Change password',
-      method: 'POST',
-      path: 'change-password',
-      body: IChangePasswordBodyZod,
-      responses: {
-        201: null,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    loginEmailTwoFactor: {
-      summary: 'Login with email and 2FA',
-      method: 'POST',
-      path: 'login/email/2fa',
-      headers: z.object({
-        'user-agent': z.string(),
-      }),
-      body: LoginBody2FA,
-      responses: {
-        200: AccessTokenResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'auth/',
-  },
-);

package/src/contracts/compliance/batch-jobs/index.ts

@@ -1,62 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  InternalError,
-} from '../../../common/types';
-import { z } from 'zod';
-import {
-  BatchJobFiltersZod,
-  batchJobIdSchema,
-  BatchJobsIncludeQuery,
-  BatchJobZod,
-  IPaginatedBatchJob,
-} from '../../../common/types/batch-jobs.types';
-
-const c = initContract();
-
-export const batchJobsContract = c.router(
-  {
-    getBatchJob: {
-      summary: 'Get batch job by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(BatchJobsIncludeQuery),
-      pathParams: z.object({
-        id: batchJobIdSchema,
-      }),
-      responses: {
-        200: BatchJobZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getBatchJobs: {
-      summary: 'Get batch jobs',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(BatchJobFiltersZod).merge(
-        BatchJobsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedBatchJob,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'batch-jobs',
-  },
-);

package/src/contracts/compliance/bonus-tiers/index.ts

@@ -1,55 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  CompliancePostBonusTierZod,
-  EstimateBonusTierCalculationResponseZod,
-  EstimateBonusTierCalculationZod,
-  IBonusTierList,
-} from '../../../common/types/bonus-tier.types';
-
-const c = initContract();
-
-export const bonusTiersContract = c.router(
-  {
-    estimateCalculation: {
-      summary: 'Estimate bonus tier calculation',
-      method: 'POST',
-      path: '/estimate-calculation',
-      metadata: {
-        auth: true,
-      },
-      body: EstimateBonusTierCalculationZod,
-      responses: {
-        200: EstimateBonusTierCalculationResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    postBonusTier: {
-      summary: 'Create a new bonus tier',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostBonusTierZod,
-      responses: {
-        201: IBonusTierList,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'bonus-tiers',
-  },
-);

package/src/contracts/compliance/checklist/index.ts

@@ -1,87 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  ChecklistFiltersZodSchema,
-  ChecklistIncludeQuerySchema,
-  ChecklistParamsZodSchema,
-  IPaginatedChecklistSchema,
-  PatchChecklistSchema,
-  PostChecklistSchema,
-  ResponseChecklistZodSchema,
-} from '../../../common/types/checklist.types';
-
-const c = initContract();
-
-export const checkListContract = c.router(
-  {
-    getChecklist: {
-      summary: 'Get checklist by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: ChecklistParamsZodSchema,
-      query: ChecklistIncludeQuerySchema,
-      responses: {
-        200: ResponseChecklistZodSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getChecklists: {
-      summary: 'Query checklist by name or type',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ChecklistFiltersZodSchema).merge(
-        ChecklistIncludeQuerySchema,
-      ),
-      responses: {
-        200: IPaginatedChecklistSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    createChecklist: {
-      summary: 'Create checklist ',
-      method: 'POST',
-      path: '',
-      body: PostChecklistSchema,
-      responses: {
-        201: ResponseChecklistZodSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateChecklist: {
-      summary: 'Update checklist ',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      body: PatchChecklistSchema,
-      pathParams: ChecklistParamsZodSchema,
-      responses: {
-        201: ResponseChecklistZodSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'checklists',
-  },
-);

package/src/contracts/compliance/checklist-items/index.ts

@@ -1,86 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  ChecklistItemsFiltersZodSchema,
-  IPaginatedChecklistItemSchema,
-  ParamsChecklistItemSchema,
-  PatchChecklistItemSchema,
-  PostChecklistItemSchema,
-  ResponseChecklistItemSchema,
-} from '../../../common/types/checklist-items.types';
-
-const c = initContract();
-
-export const checkListItemsContract = c.router(
-  {
-    createChecklistItem: {
-      summary: 'Create checklist Item ',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: PostChecklistItemSchema,
-      responses: {
-        201: ResponseChecklistItemSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    updateChecklistItem: {
-      summary: 'Update checklist item',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      body: PatchChecklistItemSchema,
-      pathParams: ParamsChecklistItemSchema,
-      responses: {
-        201: ResponseChecklistItemSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    queryChecklistItem: {
-      summary: 'GET checklist items by Checklist id',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(ChecklistItemsFiltersZodSchema),
-      responses: {
-        200: IPaginatedChecklistItemSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getChecklistItem: {
-      summary: 'GET checklist items by Checklist id',
-      method: 'GET',
-      pathParams: ParamsChecklistItemSchema,
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: ResponseChecklistItemSchema,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'checklist-items',
-  },
-);

package/src/contracts/compliance/covered-persons/index.ts

@@ -1,97 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  PatchCoveredPersonsZod,
-  ReviewCoveredPersons,
-  UnauthorizedError,
-} from '../../../common/types';
-
-import {
-  coveredPersonIdSchema,
-  CoveredPersonsIncludeQuery,
-  GetCoveredPersonsZod,
-  ICoveredPerson,
-  IPaginatedCoveredPerson,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const coveredPersonsContract = c.router(
-  {
-    getCoveredPersons: {
-      summary: 'Get Covered Persons',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(CoveredPersonsIncludeQuery).merge(
-        GetCoveredPersonsZod,
-      ),
-      responses: {
-        200: IPaginatedCoveredPerson,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getCoveredPerson: {
-      summary: 'Get covered person by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(CoveredPersonsIncludeQuery),
-      pathParams: z.object({ id: coveredPersonIdSchema }),
-      responses: {
-        200: ICoveredPerson,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchCoveredPerson: {
-      summary: 'Update covered person',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: coveredPersonIdSchema }),
-      body: PatchCoveredPersonsZod,
-      responses: {
-        201: ICoveredPerson,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    reviewCoveredPersons: {
-      summary: 'Review CoveredPersons',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: ReviewCoveredPersons,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'covered-persons',
-  },
-);