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

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

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

@@ -0,0 +1,149 @@
+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/contracts/compliance/offerings/index.ts

@@ -0,0 +1,233 @@
+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/contracts/compliance/pages/index.ts

@@ -0,0 +1,178 @@
+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/contracts/compliance/payment-methods/index.ts

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