@dalmore/api-contracts 0.0.0-dev.0c67bc1

package/contracts/clients/offerings/index.ts

@@ -0,0 +1,117 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  IOffering,
+  IPaginatedOffering,
+  NotFoundError,
+  OfferingFiltersZod,
+  offeringIdSchema,
+  OfferingsIncludeQuery,
+  OfferingSummaryFiltersZod,
+  PaginatedOfferingSummaryResponseZod,
+  PaginationOptionsZod,
+  PatchIssuerOffering,
+  PostIssuerOffering,
+  UnauthorizedError,
+} from '../../../common/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,
+      ),
+      responses: {
+        200: IPaginatedOffering,
+        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,
+      },
+    },
+    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: IOffering,
+        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: PatchIssuerOffering,
+      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: PostIssuerOffering,
+      responses: {
+        201: IOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'offerings',
+  },
+);

package/contracts/clients/payment-methods/index.ts

@@ -0,0 +1,85 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  userIdSchema,
+  BadRequestError,
+  InternalError,
+} from '../../../common/types';
+import {
+  PaymentMethodResponseArray,
+  PaymentMethodResponse,
+  PostPaymentMethod,
+  PostSetupIntentBody,
+  SetupIntentResponse,
+} from '../../../common/types/payment-methods.types';
+
+const c = initContract();
+
+export const paymentMethodsContract = c.router(
+  {
+    getPaymentMethods: {
+      summary: 'Get payment methods for a user',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: PaymentMethodResponseArray,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createPaymentMethod: {
+      summary: 'Create payment method for a user',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostPaymentMethod,
+      responses: {
+        201: PaymentMethodResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createSetupIntent: {
+      summary: 'Create payment method setup intent for a user',
+      method: 'POST',
+      path: '/intent',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostSetupIntentBody,
+      responses: {
+        201: SetupIntentResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'payment-methods',
+  },
+);

package/contracts/clients/secure-requests/index.ts

@@ -0,0 +1,34 @@
+import { initContract } from '@ts-rest/core';
+import {
+  NotFoundError,
+  UnauthorizedError,
+  InternalError,
+  BadRequestError,
+} from '../../../common/types';
+import {
+  PostSecureRequestBody,
+  SecureRequestZod,
+} from '../../../common/types/secure-request.types';
+
+const c = initContract();
+
+export const secureRequestContract = c.router(
+  {
+    postSecureRequest: {
+      summary: 'Create Secure Request',
+      method: 'POST',
+      path: '/',
+      body: PostSecureRequestBody,
+      responses: {
+        202: SecureRequestZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'secure-request',
+  },
+);

package/contracts/clients/sites/index.ts

@@ -0,0 +1,56 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  SitesFiltersZod,
+  SitesIncludeQuery,
+  SitesPaginated,
+  SitesParamSchema,
+  SiteZod,
+} from '../../../common/types/site.types';
+
+const c = initContract();
+
+export const sitesContract = c.router(
+  {
+    getSite: {
+      summary: 'get site by id',
+      method: 'GET',
+      path: '/:id',
+      pathParams: SitesParamSchema,
+      metadata: {
+        auth: true,
+      },
+      query: SitesIncludeQuery.merge(SitesFiltersZod),
+      responses: {
+        200: SiteZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getSites: {
+      summary: 'query sites by url',
+      method: 'GET',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(SitesFiltersZod).merge(SitesIncludeQuery),
+      responses: {
+        200: SitesPaginated,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'sites',
+  },
+);

package/contracts/clients/trade-line-items/index.ts

@@ -0,0 +1,66 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  userIdSchema,
+} from '../../../common/types';
+import {
+  PostTradeLineItem,
+  TradeLineItemParams,
+  TradeLineItemQuery,
+  TradeLineItemResponse,
+  TradeLineItemUpdate,
+} from '../../../common/types/trade-line-item.type';
+
+const c = initContract();
+
+export const tradeLineItemsContract = c.router(
+  {
+    postTradeLineItem: {
+      summary: 'Create Trade Line Item',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostTradeLineItem,
+      query: TradeLineItemQuery.merge(
+        z.object({
+          userId: userIdSchema,
+        }),
+      ),
+      responses: {
+        201: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    updateTradeLineItem: {
+      summary: 'Update Trade Line Item - Can delete if you pass quantity = 0',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: TradeLineItemParams,
+      body: TradeLineItemUpdate,
+      responses: {
+        200: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+        400: BadRequestError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trade-line-items',
+  },
+);

package/contracts/clients/trades/index.ts

@@ -0,0 +1,186 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  InvestorsTradeResponse,
+  IPaginatedTrade,
+  IssuersTradeFiltersZod,
+  PatchTradeStatus,
+  PostTradeBody,
+  tradeIdOrTidSchema,
+  TradesIncludeQuery,
+  TradeZod,
+  PostAttachSubdocBody,
+  PutAttachSubdocBody,
+  PatchSubdocSignatureBody,
+  AttachSubdocResponse,
+} from '../../../common/types/trade.types';
+import { z } from 'zod';
+import {
+  PostTradeLineItem,
+  TradeLineItemQuery,
+  TradeLineItemResponse,
+} from '../../../common/types/trade-line-item.type';
+
+const c = initContract();
+
+export const tradesContract = c.router(
+  {
+    getTrade: {
+      summary: 'Get trade by id - id could be either the entity id or tid',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z
+        .object({})
+        .merge(IssuersTradeFiltersZod)
+        .merge(TradesIncludeQuery),
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      responses: {
+        200: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getTrades: {
+      summary: 'Get trades',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IssuersTradeFiltersZod).merge(
+        TradesIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedTrade,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    createTrades: {
+      summary: 'Create Trades',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostTradeBody,
+      responses: {
+        201: InvestorsTradeResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    postLineItem: {
+      summary: 'Create a Line Item',
+      method: 'POST',
+      path: '/line-items',
+      metadata: {
+        auth: true,
+      },
+      query: TradeLineItemQuery,
+      body: PostTradeLineItem,
+      responses: {
+        201: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    patchTradeStatus: {
+      summary: 'Patch a trade status',
+      method: 'PATCH',
+      path: '/:id',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PatchTradeStatus,
+      responses: {
+        201: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    postAttachSubdoc: {
+      summary: 'Attach subdoc to trade',
+      method: 'POST',
+      path: '/:id/attach-subdoc',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PostAttachSubdocBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    putAttachSubdoc: {
+      summary: 'Update attached subdoc for trade',
+      method: 'PUT',
+      path: '/:id/attach-subdoc',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PutAttachSubdocBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchSubdocSign: {
+      summary: 'Update subdoc signature statuses for trade',
+      method: 'PATCH',
+      path: '/:id/sign',
+      pathParams: z.object({
+        id: tradeIdOrTidSchema,
+      }),
+      metadata: {
+        auth: true,
+      },
+      body: PatchSubdocSignatureBody,
+      responses: {
+        200: AttachSubdocResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trades',
+  },
+);

package/contracts/compliance/account-contacts/index.ts

@@ -0,0 +1,82 @@
+import { initContract } from '@ts-rest/core';
+import {
+  accountIdSchema,
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  accountContactIdSchema,
+  CompliancePatchAccountContactZod,
+  IAccountContact,
+} from '../../../common/types/account-contact.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const accountContactsContract = c.router(
+  {
+    getAccountContacts: {
+      summary: '[ADMIN] Get Account Contacts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        accountId: accountIdSchema,
+      }),
+      responses: {
+        200: z.array(IAccountContact),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAccountContact: {
+      summary: '[ADMIN] Get account contact by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountContactIdSchema,
+      }),
+      query: z.object({
+        accountId: accountIdSchema,
+      }),
+      responses: {
+        200: IAccountContact,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    patchAccountContact: {
+      summary: '[ADMIN] Update account contact',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountContactIdSchema,
+      }),
+      body: CompliancePatchAccountContactZod,
+      responses: {
+        200: IAccountContact,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'account-contacts',
+  },
+);