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

package/contracts/compliance/issuers/index.ts

@@ -0,0 +1,97 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  CompliancePostIssuerZod,
+  IIssuer,
+  IPaginatedIssersSummary,
+  issuerIdSchema,
+  IssuersIncludeQuery,
+  IssuersSortZod,
+  IssuersSummaryFilterZod,
+  PutIssuerZod,
+} from '../../../common/types/issuer.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const issuersContract = c.router(
+  {
+    getIssuersSummary: {
+      summary: 'Get Issuers Summary',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IssuersSummaryFilterZod).merge(
+        IssuersSortZod,
+      ),
+      responses: {
+        200: IPaginatedIssersSummary,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getIssuer: {
+      summary: 'Get issuer by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(IssuersIncludeQuery),
+      pathParams: z.object({ id: issuerIdSchema }),
+      responses: {
+        200: IIssuer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    postIssuer: {
+      summary: '[ADMIN] Create an issuer for a specific account',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: CompliancePostIssuerZod,
+      responses: {
+        201: IIssuer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    updateIssuer: {
+      summary: 'Update issuer',
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: issuerIdSchema,
+      }),
+      body: PutIssuerZod,
+      responses: {
+        200: IIssuer,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuers',
+  },
+);

package/contracts/compliance/job-items/index.ts

@@ -0,0 +1,58 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  IPaginatedJobItem,
+  JobItemFiltersZod,
+  JobItemIdSchema,
+  JobItemZod,
+} from '../../../common/types/job-item.types';
+
+const c = initContract();
+
+export const jobItemsContract = c.router(
+  {
+    getJobItems: {
+      summary: 'Get job items',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(JobItemFiltersZod),
+      responses: {
+        200: IPaginatedJobItem,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getJobItem: {
+      summary: 'Get job item by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: JobItemIdSchema,
+      }),
+      responses: {
+        200: JobItemZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'job-items',
+  },
+);

package/contracts/compliance/jobs/index.ts

@@ -0,0 +1,59 @@
+import { initContract } from '@ts-rest/core';
+import {
+  CheckInvestorParamsSchema,
+  ForbiddenError,
+  QueueTradeSaLogSchema,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const jobsContract = c.router(
+  {
+    postInvestorCheck: {
+      summary: 'Create a investor check',
+      method: 'POST',
+      path: '/investor-check',
+      metadata: {
+        auth: true,
+      },
+      body: CheckInvestorParamsSchema,
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    queueInvestorCheck: {
+      summary: 'Manually trigger the queue check',
+      method: 'GET',
+      path: '/queue-investor-check',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    queueTradeSaLog: {
+      summary: 'Manually trigger the queue trade sa log',
+      method: 'POST',
+      path: '/queue-trade-salog',
+      metadata: {
+        auth: true,
+      },
+      body: QueueTradeSaLogSchema,
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'jobs',
+  },
+);

package/contracts/compliance/kyb/index.ts

@@ -0,0 +1,54 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedKyb,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  KybZod,
+  KybFiltersZod,
+  kybIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const kybsContract = c.router(
+  {
+    getKyb: {
+      summary: 'Get kyb by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(KybFiltersZod),
+      pathParams: z.object({
+        id: kybIdSchema,
+      }),
+      responses: {
+        200: KybZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getKybs: {
+      summary: 'Get kybs',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(KybFiltersZod),
+      responses: {
+        200: IPaginatedKyb,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'kybs',
+  },
+);

package/contracts/compliance/kyc/index.ts

@@ -0,0 +1,77 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedKyc,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  KycZod,
+  KycFiltersZod,
+  kycIdSchema,
+  InternalError,
+  inquiryIdSchema,
+  ServiceUnavailableError,
+  KycTimelineResponse,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const kycsContract = c.router(
+  {
+    getKyc: {
+      summary: 'Get kyc by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(KycFiltersZod),
+      pathParams: z.object({
+        id: kycIdSchema,
+      }),
+      responses: {
+        200: KycZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getKycs: {
+      summary: 'Get kycs',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(KycFiltersZod),
+      responses: {
+        200: IPaginatedKyc,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getInquiry: {
+      summary: 'Get KYC inquiry',
+      method: 'GET',
+      path: '/inquiries/:inquiryId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        inquiryId: inquiryIdSchema,
+      }),
+      responses: {
+        200: KycTimelineResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+        503: ServiceUnavailableError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'kycs',
+  },
+);

package/contracts/compliance/legal-entities/index.ts

@@ -0,0 +1,57 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedLegalEntity,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  LegalEntityFiltersZod,
+  LegalEntitiesIncludeQuery,
+  LegalEntityZod,
+  legalEntityIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const legalEntitiesContract = c.router(
+  {
+    getLegalEntity: {
+      summary: 'Get legalEntity by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(LegalEntitiesIncludeQuery),
+      pathParams: z.object({
+        id: legalEntityIdSchema,
+      }),
+      responses: {
+        200: LegalEntityZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getLegalEntities: {
+      summary: 'Get legalEntities',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(LegalEntityFiltersZod).merge(
+        LegalEntitiesIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedLegalEntity,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'legal-entities',
+  },
+);

package/contracts/compliance/login-histories/index.ts

@@ -0,0 +1,37 @@
+import { initContract } from '@ts-rest/core';
+
+import {
+  BadRequestError,
+  ForbiddenError,
+  UnauthorizedError,
+  IListLoginHistories,
+  userIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const loginHistoriesContract = c.router(
+  {
+    getLoginHistoriesByUserId: {
+      summary: 'Get Login Histories by User id',
+      method: 'GET',
+      path: '/:userId',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: IListLoginHistories,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'login-histories',
+  },
+);

package/contracts/compliance/notes/index.ts

@@ -0,0 +1,69 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  CompliancePostNoteBody,
+  InternalError,
+  IPaginatedNote,
+  noteIdSchema,
+  NotesFilters,
+  NoteZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const notesContract = c.router(
+  {
+    postNote: {
+      summary: 'Create a note',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: CompliancePostNoteBody,
+      responses: {
+        201: NoteZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getNotes: {
+      summary: 'Get notes',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(NotesFilters),
+      responses: {
+        200: IPaginatedNote,
+        401: UnauthorizedError,
+      },
+    },
+    getNote: {
+      summary: 'Get note by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: noteIdSchema,
+      }),
+      responses: {
+        200: NoteZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'notes',
+  },
+);

package/contracts/compliance/notion-databases/index.ts

@@ -0,0 +1,107 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  NotionDatabaseZod,
+  IPaginatedNotionDatabases,
+  NotionDatabaseFiltersZod,
+  NotionDatabaseIncludeQuery,
+  PostNotionDatabaseSchema,
+  UpdateNotionDatabaseSchema,
+  notionDatabaseIdSchema,
+  TriggerNotionDatabaseSync,
+} from '../../../common/types/notion-database.types';
+
+const c = initContract();
+
+export const notionDatabasesContract = c.router(
+  {
+    getNotionDatabases: {
+      summary: 'Get all notion databases',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(NotionDatabaseFiltersZod).merge(
+        NotionDatabaseIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedNotionDatabases,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+
+    createNotionDatabase: {
+      summary: 'Create a new notion database',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostNotionDatabaseSchema,
+      responses: {
+        201: NotionDatabaseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+
+    updateNotionDatabase: {
+      summary: 'Update a notion database',
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: notionDatabaseIdSchema,
+      }),
+      body: UpdateNotionDatabaseSchema,
+      responses: {
+        200: NotionDatabaseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+
+    triggerNotionDatabaseSync: {
+      summary: '[ADMIN] Trigger sync for a notion database',
+      method: 'POST',
+      path: '/:id/sync',
+      metadata: {
+        auth: true,
+      },
+      body: TriggerNotionDatabaseSync,
+      pathParams: z.object({
+        id: notionDatabaseIdSchema,
+      }),
+      responses: {
+        200: NotionDatabaseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'notion-databases',
+  },
+);