@dalmore/api-contracts 0.0.0-dev.988f3c3 → 0.0.0-dev.9c066a6

package/contracts/clients/offerings/index.ts

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

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

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

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

@@ -1,66 +0,0 @@
-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.types';
-
-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

@@ -1,186 +0,0 @@
-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.types';
-
-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/clients/transactions/index.ts

@@ -1,37 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  ClientPostTransactionZod,
-  TransactionZod,
-} from '../../../common/types/transaction.types';
-
-const c = initContract();
-
-export const clientsTransactionsContract = c.router(
-  {
-    postTransaction: {
-      summary: 'Create a transaction',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: ClientPostTransactionZod,
-      responses: {
-        201: TransactionZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'transactions',
-  },
-);

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

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