@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/contracts/clients/individuals/index.ts

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedIndividual,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  IndividualFiltersZod,
+  IndividualsIncludeQuery,
+  individualIdSchema,
+  PostIndividualBodySchema,
+  UpdateIndividualBodySchema,
+  IndividualResponseSchema,
+  IIndividualZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const individualsContract = c.router(
+  {
+    createIndividual: {
+      summary: 'Create individual',
+      method: 'POST',
+      path: '/',
+      body: PostIndividualBodySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: IndividualResponseSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateIndividual: {
+      summary: 'Update individual',
+      method: 'PATCH',
+      path: '/:id',
+      pathParams: z.object({
+        id: individualIdSchema,
+      }),
+      body: UpdateIndividualBodySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: IndividualResponseSchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getIndividual: {
+      summary: 'Get individual by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(IndividualsIncludeQuery),
+      pathParams: z.object({
+        id: individualIdSchema,
+      }),
+      responses: {
+        200: IIndividualZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getIndividuals: {
+      summary: 'Get individuals',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IndividualFiltersZod).merge(
+        IndividualsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedIndividual,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'individuals',
+  },
+);

package/src/contracts/clients/investor-accounts/index.ts

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  IInvestorAccount,
+  investorAccountIdSchema,
+  InvestorAccountsFiltersZod,
+  InvestorAccountsIncludeQuery,
+  InvestorUpdatePathParamsSchema,
+  IPaginatedInvestorAccounts,
+  PostClientInvestorAccountBodySchema,
+  UpdateInvestorAccountBodySchema,
+} from '../../../common/types/investor-account.types';
+
+const c = initContract();
+
+export const investorAccountsContract = c.router(
+  {
+    createInvestorAccount: {
+      summary: 'Create investor account ',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostClientInvestorAccountBodySchema,
+      responses: {
+        201: IInvestorAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateInvestorAccount: {
+      summary: 'Update investor account ',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: InvestorUpdatePathParamsSchema,
+      body: UpdateInvestorAccountBodySchema,
+      responses: {
+        201: IInvestorAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getInvestorAccount: {
+      summary: 'Get investor account by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(InvestorAccountsIncludeQuery),
+      pathParams: z.object({
+        id: investorAccountIdSchema,
+      }),
+      responses: {
+        200: IInvestorAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getInvestorAccounts: {
+      summary: 'Get investor accounts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(InvestorAccountsIncludeQuery).merge(
+        InvestorAccountsFiltersZod,
+      ),
+      responses: {
+        200: IPaginatedInvestorAccounts,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'investor-accounts',
+  },
+);

package/src/contracts/clients/issuers/index.ts

@@ -0,0 +1,94 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  GetIssuersZod,
+  IIssuer,
+  IPaginatedIssuer,
+  IssuersIncludeQuery,
+  issuerIdSchema,
+  PostIssuerZod,
+  PutIssuerZod,
+} from '../../../common/types/issuer.types';
+const c = initContract();
+
+export const issuersContract = c.router(
+  {
+    getIssuers: {
+      summary: 'Get Issuers',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(IssuersIncludeQuery).merge(GetIssuersZod),
+      responses: {
+        200: IPaginatedIssuer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    postIssuer: {
+      summary: 'Create an issuer',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostIssuerZod,
+      responses: {
+        201: IIssuer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getIssuer: {
+      summary: 'Get issuer by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(IssuersIncludeQuery),
+      pathParams: z.object({ id: issuerIdSchema }),
+      responses: {
+        200: IIssuer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateIssuer: {
+      summary: 'Update issuer',
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: issuerIdSchema,
+      }),
+      body: PutIssuerZod,
+      responses: {
+        201: IIssuer,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuers',
+  },
+);

package/src/contracts/clients/legal-entities/index.ts

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import {
+  PostLegalEntitySchema,
+  ResponseLegalEntitySchema,
+  UnauthorizedError,
+  ForbiddenError,
+  legalEntityIdSchema,
+  UpdateLegalEntitySchema,
+  LegalEntitiesIncludeQuery,
+  LegalEntityZod,
+  PaginationOptionsZod,
+  LegalEntityFiltersZod,
+  IPaginatedLegalEntity,
+  NotFoundError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const legalEntityContract = c.router(
+  {
+    createLegalEntity: {
+      summary: 'Create Legal Entity',
+      method: 'POST',
+      path: '/',
+      body: PostLegalEntitySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: ResponseLegalEntitySchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    updateLegalEntity: {
+      summary: 'Update Legal Entity',
+      method: 'PATCH',
+      path: '/:id',
+      pathParams: z.object({
+        id: legalEntityIdSchema,
+      }),
+      body: UpdateLegalEntitySchema,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: ResponseLegalEntitySchema,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getLegalEntity: {
+      summary: 'Get legalEntity by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(LegalEntitiesIncludeQuery),
+      pathParams: z.object({
+        id: legalEntityIdSchema,
+      }),
+      responses: {
+        200: LegalEntityZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getLegalEntities: {
+      summary: 'Get legalEntities',
+      method: 'GET',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(LegalEntityFiltersZod).merge(
+        LegalEntitiesIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedLegalEntity,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'legal-entities',
+  },
+);

package/src/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/src/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/src/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/src/contracts/clients/trades/index.ts

@@ -0,0 +1,122 @@
+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,
+} 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,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trades',
+  },
+);