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

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

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