@dalmore/api-contracts 0.0.0-dev.d6badc9 → 0.0.0-dev.dc7fdf8

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/notification-channels/index.ts

@@ -1,251 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  CreateChannelInputSchema,
-  CreateTriggerInputSchema,
-  IAvailableTriggersResponse,
-  INotificationChannelTriggerZod,
-  INotificationChannelZod,
-  INotificationRecordZod,
-  IPaginatedNotificationChannel,
-  IPaginatedNotificationRecord,
-  NotificationChannelFilters,
-  NotificationChannelsIncludeQuery,
-  notificationChannelIdSchema,
-  notificationChannelTriggerIdSchema,
-  NotificationRecordFilters,
-  NotificationRecordsIncludeQuery,
-  notificationRecordIdSchema,
-  UpdateChannelInputSchema,
-} from '../../../common/types/notification.types';
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-
-const c = initContract();
-
-export const notificationChannelsContract = c.router(
-  {
-    getChannels: {
-      summary: 'Get notification channels',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(NotificationChannelFilters).merge(
-        NotificationChannelsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedNotificationChannel,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    getChannel: {
-      summary: 'Get notification channel by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      query: z.object({}).merge(NotificationChannelsIncludeQuery),
-      responses: {
-        200: INotificationChannelZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createChannel: {
-      summary: 'Create notification channel',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CreateChannelInputSchema,
-      responses: {
-        201: INotificationChannelZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    updateChannel: {
-      summary: 'Update notification channel',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      body: UpdateChannelInputSchema,
-      responses: {
-        200: INotificationChannelZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteChannel: {
-      summary: 'Delete notification channel',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createTrigger: {
-      summary: 'Create notification channel trigger',
-      method: 'POST',
-      path: '/:id/triggers',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      body: CreateTriggerInputSchema.omit({ notificationChannelId: true }),
-      responses: {
-        201: INotificationChannelTriggerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getAvailableTriggers: {
-      summary: 'Get all available triggers for a channel',
-      method: 'GET',
-      path: '/:id/triggers/available',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-      }),
-      responses: {
-        200: IAvailableTriggersResponse,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    updateTrigger: {
-      summary: 'Update notification channel trigger',
-      method: 'PATCH',
-      path: '/:id/triggers/:triggerId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-        triggerId: notificationChannelTriggerIdSchema,
-      }),
-      body: z.object({ enabled: z.boolean() }),
-      responses: {
-        200: INotificationChannelTriggerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteTrigger: {
-      summary: 'Delete notification channel trigger',
-      method: 'DELETE',
-      path: '/:id/triggers/:triggerId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: notificationChannelIdSchema,
-        triggerId: notificationChannelTriggerIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getRecords: {
-      summary: 'Get notification records',
-      method: 'GET',
-      path: '/records',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(NotificationRecordFilters).merge(
-        NotificationRecordsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedNotificationRecord,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    getRecord: {
-      summary: 'Get notification record by id',
-      method: 'GET',
-      path: '/records/:recordId',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        recordId: notificationRecordIdSchema,
-      }),
-      query: z.object({}).merge(NotificationRecordsIncludeQuery),
-      responses: {
-        200: INotificationRecordZod,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    retryRecord: {
-      summary: 'Retry failed notification record',
-      method: 'POST',
-      path: '/records/:recordId/retry',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        recordId: notificationRecordIdSchema,
-      }),
-      body: z.object({}),
-      responses: {
-        200: INotificationRecordZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'notification-channels',
-  },
-);

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',
-  },
-);