@dalmore/api-contracts 1.0.2 → 1.0.5

package/contracts/clients/individuals/index.ts

@@ -1,93 +0,0 @@
-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/contracts/clients/investor-accounts/index.ts

@@ -1,93 +0,0 @@
-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/contracts/clients/issuers/index.ts

@@ -1,94 +0,0 @@
-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/contracts/clients/legal-entities/index.ts

@@ -1,93 +0,0 @@
-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/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/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/trades/index.ts

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