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

package/contracts/investors/investor-accounts/index.ts

@@ -0,0 +1,110 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  GetInvestorAccountsFilters,
+  IInvestorAccount,
+  IInvestorAccountSummary,
+  investorAccountIdSchema,
+  InvestorAccountsIncludeQuery,
+  InvestorUpdatePathParamsSchema,
+  IPaginatedInvestorAccounts,
+  PostInvestorAccountBodySchema,
+  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: PostInvestorAccountBodySchema,
+      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: GetInvestorAccountsFilters,
+      responses: {
+        200: IPaginatedInvestorAccounts,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getInvestorAccountSummary: {
+      summary: 'Get investor account summary',
+      method: 'GET',
+      path: '/:id/summary',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: investorAccountIdSchema,
+      }),
+      responses: {
+        200: IInvestorAccountSummary,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'investor-accounts',
+  },
+);

package/contracts/investors/issuer-payment-methods/index.ts

@@ -0,0 +1,36 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  GetIssuerPaymentMethodZod,
+  IPaginatedIssuerPaymentMethod,
+  PaginationOptionsZod,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerPaymentMethodsContract = c.router(
+  {
+    getIssuerPaymentMethods: {
+      summary: 'get payment methods',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod),
+      responses: {
+        200: IPaginatedIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuer-payment-methods',
+  },
+);

package/contracts/investors/issuers/index.ts

@@ -0,0 +1,30 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import { IPaginatedCatalog } from '../../../common/types/issuer.types';
+const c = initContract();
+
+export const issuersContract = c.router(
+  {
+    getIssuers: {
+      summary: 'Get Issuers with mode property',
+      method: 'GET',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod,
+      responses: {
+        200: IPaginatedCatalog,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuers',
+  },
+);

package/contracts/investors/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/contracts/investors/notes/index.ts

@@ -0,0 +1,69 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  IPaginatedNote,
+  noteIdSchema,
+  NotesFilters,
+  NoteZod,
+  NotFoundError,
+  PaginationOptionsZod,
+  PostNoteBody,
+  UnauthorizedError,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const investorNotesContract = c.router(
+  {
+    postNote: {
+      summary: 'Create a note',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostNoteBody,
+      responses: {
+        201: NoteZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getNotes: {
+      summary: 'Get notes',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(NotesFilters),
+      responses: {
+        200: IPaginatedNote,
+        401: UnauthorizedError,
+      },
+    },
+    getNote: {
+      summary: 'Get note by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: noteIdSchema,
+      }),
+      responses: {
+        200: NoteZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'notes',
+  },
+);

package/contracts/investors/offerings/index.ts

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  NotFoundError,
+  offeringIdSchema,
+  OfferingDetailsResponseZod,
+  PublicOfferingFiltersZod,
+  InternalError,
+} from '../../../common/types';
+import { z } from 'zod';
+import {
+  InvestorsOffering,
+  InvestorsOfferingFiltersZod,
+  InvestorsOfferingsIncludeQuery,
+  InvestorsPaginatedOffering,
+} from '../../../common/types/investors-offering.types';
+
+const c = initContract();
+
+export const offeringsContract = c.router(
+  {
+    getOfferings: {
+      summary: 'Get offerings',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(InvestorsOfferingsIncludeQuery).merge(
+        InvestorsOfferingFiltersZod,
+      ),
+      responses: {
+        200: InvestorsPaginatedOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getPublicOfferings: {
+      summary: 'Get public offerings. This is used for public sites.',
+      method: 'GET',
+      path: '/public',
+      query: PublicOfferingFiltersZod,
+      responses: {
+        200: InvestorsPaginatedOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getOfferingDetails: {
+      summary: 'Get offering details',
+      method: 'GET',
+      path: '/:id/details',
+      pathParams: z.object({
+        id: offeringIdSchema,
+      }),
+      responses: {
+        200: OfferingDetailsResponseZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getOffering: {
+      summary: 'Get offering by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(InvestorsOfferingsIncludeQuery),
+      pathParams: z.object({
+        id: offeringIdSchema,
+      }),
+      responses: {
+        200: InvestorsOffering,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'offerings',
+  },
+);

package/contracts/investors/pages/index.ts

@@ -0,0 +1,88 @@
+import { initContract } from '@ts-rest/core';
+
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  pageIdSchema,
+  GetInvestorPageByUrlZod,
+  IPaginatedInvestorPages,
+  IInvestorPage,
+  GetInvestorPageZod,
+  PublicPagesFiltersZod,
+} 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(GetInvestorPageZod),
+      responses: {
+        200: IPaginatedInvestorPages,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getPublicPages: {
+      summary: 'Get public pages. This is used for public sites.',
+      method: 'GET',
+      path: '/public',
+      query: PublicPagesFiltersZod,
+      responses: {
+        200: IPaginatedInvestorPages,
+        400: BadRequestError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getPageByUrl: {
+      summary: 'Get Page by URL',
+      method: 'GET',
+      path: '/url/:url',
+      pathParams: GetInvestorPageByUrlZod,
+      responses: {
+        200: IInvestorPage,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getPage: {
+      summary: 'Get Page',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: pageIdSchema,
+      }),
+      responses: {
+        200: IInvestorPage,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'pages',
+  },
+);

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

@@ -0,0 +1,149 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  paymentMethodIdSchema,
+  PaymentMethodResponse,
+  PaymentMethodResponseArray,
+  PostPaymentMethod,
+  PostProviderPaymentMethod,
+  PostSetupIntentBody,
+  SetupIntentResponse,
+  UpdatePaymentMethod,
+} from '../../../common/types/payment-methods.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const paymentMethodsContract = c.router(
+  {
+    getPaymentMethods: {
+      summary: 'get payment methods',
+      method: 'GET',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: PaymentMethodResponseArray,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createPaymentMethod: {
+      summary: 'POST payment methods',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostPaymentMethod,
+      responses: {
+        201: PaymentMethodResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createProviderBankAccountPaymentMethod: {
+      summary: 'POST provider bank account payment method',
+      method: 'POST',
+      path: '/provider/bank-account',
+      metadata: {
+        auth: true,
+      },
+      body: PostProviderPaymentMethod,
+      responses: {
+        201: PaymentMethodResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createSetupIntent: {
+      summary: 'POST payment method setup intent',
+      method: 'POST',
+      path: '/intent',
+      metadata: {
+        auth: true,
+      },
+      body: PostSetupIntentBody,
+      responses: {
+        201: SetupIntentResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updatePaymentMethod: {
+      summary: 'PATCH payment methods',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: paymentMethodIdSchema,
+      }),
+      body: UpdatePaymentMethod,
+      responses: {
+        200: PaymentMethodResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getPaymentMethod: {
+      summary: 'GET payment methods',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: paymentMethodIdSchema,
+      }),
+      responses: {
+        200: PaymentMethodResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deletePaymentMethod: {
+      summary: 'DELETE payment methods',
+      method: 'DELETE',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: paymentMethodIdSchema,
+      }),
+      responses: {
+        200: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'payment-methods',
+  },
+);