@dalmore/api-contracts 0.0.0-dev.d8ef117 → 0.0.0-dev.e325dbb

package/contracts/compliance/kyc/index.ts

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

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

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

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

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

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

@@ -1,105 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  NotionPageZod,
-  IPaginatedNotionPages,
-  NotionPageFiltersZod,
-  UpdateNotionPageSchema,
-  notionPageIdSchema,
-  NotionPageIncludeQuery,
-  NotionPageDropdownZod,
-  NotionPageContentResponseSchema,
-} from '../../../common/types/notion-page.types';
-
-const c = initContract();
-
-export const notionPagesContract = c.router(
-  {
-    getNotionPages: {
-      summary: 'Get all notion pages',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(NotionPageFiltersZod).merge(
-        NotionPageIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedNotionPages,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    getNotionPagesDropdown: {
-      summary: 'Get notion pages dropdown data',
-      method: 'GET',
-      path: '/dropdown',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: z.array(NotionPageDropdownZod),
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    updateNotionPage: {
-      summary: 'Update a notion page',
-      method: 'PUT',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notionPageIdSchema,
-      }),
-      body: UpdateNotionPageSchema,
-      responses: {
-        200: NotionPageZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    getNotionPageContent: {
-      summary: 'Get a notion page content',
-      method: 'GET',
-      path: '/:id/content',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notionPageIdSchema,
-      }),
-      responses: {
-        200: NotionPageContentResponseSchema,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'notion-pages',
-  },
-);

package/contracts/compliance/offering-reports/index.ts

@@ -1,149 +0,0 @@
-import { StreamableFile } from '@nestjs/common';
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ExportOfferingReportsGroupedByIssuerFiltersZod,
-  ExportOfferingReportsResponse,
-  ForbiddenError,
-  GetGrowthMetricsFiltersZod,
-  GetTimeSeriesMetricsFiltersZod,
-  IGrowthMetrics,
-  InternalError,
-  IOfferingReports,
-  IPaginatedComplianceOfferingReports,
-  IPaginatedComplianceOfferingReportsGroupedByIssuer,
-  ITimeSeriesMetrics,
-  NotFoundError,
-  offeringReportIdSchema,
-  OfferingReportsFiltersZod,
-  OfferingReportsGroupedByIssuerFiltersZod,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-
-const c = initContract();
-export const offeringReportsContract = c.router(
-  {
-    getOfferingReports: {
-      summary: 'Get offering reports',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(OfferingReportsFiltersZod),
-
-      responses: {
-        200: IPaginatedComplianceOfferingReports,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getOfferingReport: {
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: offeringReportIdSchema,
-      }),
-      summary: 'Get a offering report by id',
-      responses: {
-        200: IOfferingReports,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getOfferingReportGroupedByIssuer: {
-      summary: 'Get offering reports grouped by issuer',
-      method: 'GET',
-      path: '/grouped-by-issuer',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(
-        OfferingReportsGroupedByIssuerFiltersZod,
-      ),
-
-      responses: {
-        200: IPaginatedComplianceOfferingReportsGroupedByIssuer,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getGrowthMetrics: {
-      summary: 'Get Growth Metrics',
-      method: 'GET',
-      path: '/growth-metrics',
-      metadata: {
-        auth: true,
-      },
-      query: GetGrowthMetricsFiltersZod,
-
-      responses: {
-        200: z.array(IGrowthMetrics),
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getTimeSeriesMetrics: {
-      summary: 'Get Time Series Metrics',
-      method: 'GET',
-      path: '/time-series-metrics',
-      metadata: {
-        auth: true,
-      },
-      query: GetTimeSeriesMetricsFiltersZod,
-
-      responses: {
-        200: z.array(ITimeSeriesMetrics),
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    exportOfferingReportsGroupedByIssuer: {
-      summary: 'Export Offering Reports Grouped By Issuer to CSV',
-      method: 'GET',
-      path: '/export-grouped-by-issuer',
-      metadata: {
-        auth: true,
-      },
-      query: ExportOfferingReportsGroupedByIssuerFiltersZod,
-      responses: {
-        200: z.union([
-          ExportOfferingReportsResponse,
-          z.instanceof(StreamableFile),
-        ]),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    triggerOfferingReports: {
-      summary: 'Manually trigger the offering reports',
-      method: 'POST',
-      path: '/generate-reports',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({}),
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-
-  {
-    pathPrefix: 'offering-reports',
-  },
-);