@dalmore/api-contracts 1.0.3 → 1.0.5

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

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

@@ -1,233 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  IOffering,
-  NotFoundError,
-  OfferingFiltersZod,
-  offeringIdSchema,
-  OfferingsIncludeQuery,
-  OfferingSummaryFiltersZod,
-  PaginatedOfferingSummaryResponseZod,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  IComplianceOffering,
-  IPaginatedComplianceOffering,
-  PatchComplianceOffering,
-  ReviewOfferings,
-  PostComplianceOffering,
-  OfferingSortZod,
-  PaginatedPendingOfferingSummaryResponseZod,
-  ReviewOfferingOnboarding,
-} from '../../../common/types';
-import {
-  CreateSubDocPreview,
-  CreateSubDocPreviewResponse,
-  ISubDocPreview,
-  SubDocPreviewFormFields,
-} from '../../../common/types/subdoc-preview.types';
-
-const c = initContract();
-
-export const offeringsContract = c.router(
-  {
-    getOfferings: {
-      summary: 'Get offerings',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(OfferingsIncludeQuery)
-        .merge(OfferingFiltersZod)
-        .merge(OfferingSortZod),
-      responses: {
-        200: IPaginatedComplianceOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getOfferingsSummary: {
-      summary: 'Get offerings summary',
-      method: 'GET',
-      path: '/summary',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(OfferingSummaryFiltersZod),
-      responses: {
-        200: PaginatedOfferingSummaryResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getPendingOfferingsSummary: {
-      summary: 'Get pending offerings summary',
-      method: 'GET',
-      path: '/summary/pending',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: PaginatedPendingOfferingSummaryResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getOffering: {
-      summary: 'Get offering by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(OfferingsIncludeQuery),
-      pathParams: z.object({
-        id: offeringIdSchema,
-      }),
-      responses: {
-        200: IComplianceOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchOffering: {
-      summary: 'Update offering by id',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: offeringIdSchema,
-      }),
-      body: PatchComplianceOffering,
-      responses: {
-        201: IOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postOffering: {
-      summary: '[ADMIN] Create offering',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostComplianceOffering,
-      responses: {
-        201: IOffering,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    reviewOfferings: {
-      summary: 'Review Offerings',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: ReviewOfferings,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    reviewOfferingOnboarding: {
-      summary: 'Review Offering Onboarding',
-      method: 'PATCH',
-      path: '/onboarding/review/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: offeringIdSchema,
-      }),
-      body: ReviewOfferingOnboarding,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-
-    offeringSubDocTemplateFields: {
-      summary: 'Get Sub Doc Template Form Fields',
-      method: 'GET',
-      path: '/templates/:templateId/form-fields',
-      pathParams: z.object({
-        templateId: z.string().min(1).max(36),
-      }),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: SubDocPreviewFormFields,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createOfferingSubDocPreview: {
-      summary: 'Create Offering Sub Doc Preview',
-      method: 'POST',
-      path: '/sub-doc/preview',
-      metadata: {
-        auth: true,
-      },
-      body: CreateSubDocPreview,
-      responses: {
-        201: CreateSubDocPreviewResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    offeringSubDocPreview: {
-      summary: 'Get Offering Sub Doc Preview',
-      method: 'GET',
-      path: '/sub-doc/:documentId/preview',
-      pathParams: z.object({
-        documentId: z.string().min(1).max(36),
-      }),
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: ISubDocPreview,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'offerings',
-  },
-);

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

@@ -1,178 +0,0 @@
-import { initContract } from '@ts-rest/core';
-
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  IPaginatedPages,
-  NotFoundError,
-  pageIdSchema,
-  PagesIncludeQuery,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  ReviewPagesZod,
-  IPage,
-  ComplianceGetPagesZod,
-  PatchPageZod,
-  ConflictError,
-  IPendingPagesSummary,
-  GetLandingPageCandidatesResponse,
-  accountIdSchema,
-  pageRevisionIdSchema,
-  IPageRevision,
-  CompliancePostPageZod,
-  PagesSortZod,
-} from '../../../common/types';
-
-import { z } from 'zod';
-const c = initContract();
-
-export const pagesContract = c.router(
-  {
-    getPages: {
-      summary: 'Get Pages',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(PagesIncludeQuery)
-        .merge(ComplianceGetPagesZod)
-        .merge(PagesSortZod),
-      responses: {
-        200: IPaginatedPages,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getLandingPageCandidates: {
-      summary: 'Get pages that are qualified to be presented as landing page',
-      method: 'GET',
-      path: '/landing-page-candidates',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({
-        accountId: accountIdSchema,
-      }),
-      responses: {
-        200: GetLandingPageCandidatesResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getPage: {
-      summary: 'Get Page',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(PagesIncludeQuery),
-      pathParams: z.object({
-        id: pageIdSchema,
-      }),
-      responses: {
-        200: IPage,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    reviewPages: {
-      summary: 'Review Pages',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: ReviewPagesZod,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postPage: {
-      summary: '[ADMIN] Post Pages',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostPageZod,
-      responses: {
-        201: IPage,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        409: ConflictError,
-        500: InternalError,
-      },
-    },
-    updatePublishedVersion: {
-      summary: '[ADMIN] Update the current published version',
-      method: 'PATCH',
-      path: '/published-version',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({
-        id: pageRevisionIdSchema,
-      }),
-      responses: {
-        201: IPageRevision,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchPage: {
-      summary: '[ADMIN] Patch Pages',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: pageIdSchema,
-      }),
-      body: PatchPageZod,
-      responses: {
-        201: IPage,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        409: ConflictError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getPendingPagesSummary: {
-      summary: 'Get Pending Pages Summary',
-      method: 'GET',
-      path: '/summary',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod,
-      responses: {
-        200: IPendingPagesSummary,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'pages',
-  },
-);

package/src/contracts/compliance/payment-methods/index.ts

@@ -1,57 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  CompliancePostPaymentMethod,
-  PaymentMethodFilterQuery,
-  PaymentMethodResponse,
-  PaymentMethodResponseArray,
-} from '../../../common/types/payment-methods.types';
-
-const c = initContract();
-
-export const paymentMethodsContract = c.router(
-  {
-    getPaymentMethods: {
-      summary: 'get payment methods',
-      method: 'GET',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      query: PaymentMethodFilterQuery,
-      responses: {
-        200: PaymentMethodResponseArray,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    createPaymentMethod: {
-      summary: 'POST payment methods',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: CompliancePostPaymentMethod,
-      responses: {
-        201: PaymentMethodResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'payment-methods',
-  },
-);