@dalmore/api-contracts 1.0.3 → 1.0.6

package/src/contracts/compliance-apikey/accounts/index.ts

@@ -1,58 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  IPaginatedAccount,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  AccountFiltersZod,
-  AccountsIncludeQuery,
-  AccountZod,
-  accountIdSchema,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const accountsContract = c.router(
-  {
-    getAccount: {
-      summary: 'Get account by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(AccountsIncludeQuery),
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      responses: {
-        200: AccountZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    getAccounts: {
-      summary: 'Get accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query:
-        PaginationOptionsZod.merge(AccountFiltersZod).merge(
-          AccountsIncludeQuery,
-        ),
-      responses: {
-        200: IPaginatedAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'accounts',
-  },
-);

package/src/contracts/compliance-apikey/index.ts

@@ -1,14 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { accountsContract } from './accounts';
-
-const c = initContract();
-
-// API KEY AUTH
-export const complianceApiKeyContract = c.router(
-  {
-    accounts: accountsContract,
-  },
-  {
-    pathPrefix: '/compliance-apikey/api/v1/',
-  },
-);

package/src/contracts/index.ts

@@ -1,6 +0,0 @@
-export * from './compliance';
-export * from './issuers';
-export * from './investors';
-export * from './clients';
-export * from './secondaries';
-export * from './compliance-apikey';

package/src/contracts/investors/account-contacts/index.ts

@@ -1,58 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  accountIdSchema,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  accountContactIdSchema,
-  IAccountContact,
-} from '../../../common/types/account-contact.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const accountContactsContract = c.router(
-  {
-    getAccountContacts: {
-      summary: '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: 'Get account contact by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountContactIdSchema,
-      }),
-      responses: {
-        200: IAccountContact,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'account-contacts',
-  },
-);

package/src/contracts/investors/aic/index.ts

@@ -1,59 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  AicIncludeQuery,
-  AicZod,
-  AttachAicFileBodyZod,
-  BadRequestError,
-  ForbiddenError,
-  individualIdSchema,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-export const aicContract = c.router(
-  {
-    getAic: {
-      summary: 'Get AIC',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        individualId: individualIdSchema,
-      }),
-      query: AicIncludeQuery,
-      responses: {
-        200: AicZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    attachAicFile: {
-      summary: 'Attach AIC File',
-      method: 'PUT',
-      path: '/file',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        individualId: individualIdSchema,
-      }),
-      body: AttachAicFileBodyZod,
-      responses: {
-        200: AicZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'individual/:individualId/aic',
-  },
-);

package/src/contracts/investors/assets/index.ts

@@ -1,61 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ForbiddenError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  AssetFiltersZod,
-  assetIdSchema,
-  AssetsIncludeQuery,
-  IAsset,
-  IPaginatedAsset,
-} from '../../../common/types/asset.types';
-
-const c = initContract();
-
-export const assetsContract = c.router(
-  {
-    getAssets: {
-      summary: 'Get assets',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query:
-        PaginationOptionsZod.merge(AssetsIncludeQuery).merge(AssetFiltersZod),
-      responses: {
-        200: IPaginatedAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-      },
-    },
-    getAsset: {
-      summary: 'Get asset by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: AssetsIncludeQuery,
-      pathParams: z.object({
-        id: assetIdSchema,
-      }),
-      responses: {
-        200: IAsset,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'assets',
-  },
-);

package/src/contracts/investors/auth/index.ts

@@ -1,116 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  AccessTokenResponse,
-  AuthSuccessResponse,
-  BadRequestError,
-  IChangePasswordBodyZod,
-  InternalError,
-  InvestorForgotPasswordRequestZod,
-  LoginBody2FA,
-  LoginBodyInvestors,
-  NotFoundError,
-  RegisterBodyInvestors,
-  ResetPasswordBody,
-  ResetPasswordVerifyBody,
-  ResetPasswordVerifyResponse,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const authContract = c.router(
-  {
-    registerEmail: {
-      summary: 'Register with email',
-      method: 'POST',
-      path: 'register/email',
-      body: RegisterBodyInvestors,
-      responses: {
-        201: AccessTokenResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    loginEmail: {
-      summary: 'Login with email',
-      method: 'POST',
-      path: 'login/email',
-      headers: z.object({
-        'user-agent': z.string(),
-      }),
-      body: LoginBodyInvestors,
-      responses: {
-        200: AccessTokenResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    forgotPassword: {
-      summary: 'Forgot password',
-      method: 'POST',
-      path: 'forgot-password',
-      body: InvestorForgotPasswordRequestZod,
-      responses: {
-        200: AuthSuccessResponse,
-        400: BadRequestError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    resetPasswordVerify: {
-      summary: 'Reset password verify',
-      method: 'POST',
-      path: 'reset-password/verify',
-      body: ResetPasswordVerifyBody,
-      responses: {
-        200: ResetPasswordVerifyResponse,
-        400: BadRequestError,
-        500: InternalError,
-      },
-    },
-    resetPassword: {
-      summary: 'Reset password',
-      method: 'POST',
-      path: 'reset-password',
-      body: ResetPasswordBody,
-      responses: {
-        200: AuthSuccessResponse,
-        400: BadRequestError,
-        500: InternalError,
-      },
-    },
-    changePassword: {
-      summary: 'Change password',
-      method: 'POST',
-      path: 'change-password',
-      body: IChangePasswordBodyZod,
-      responses: {
-        201: AuthSuccessResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    loginEmailTwoFactor: {
-      summary: 'Login with email and 2FA',
-      method: 'POST',
-      path: 'login/email/2fa',
-      headers: z.object({
-        'user-agent': z.string(),
-      }),
-      body: LoginBody2FA,
-      responses: {
-        200: AccessTokenResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'auth/',
-  },
-);

package/src/contracts/investors/bonus-tiers/index.ts

@@ -1,37 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  EstimateBonusTierCalculationResponseZod,
-  EstimateBonusTierCalculationZod,
-} from '../../../common/types/bonus-tier.types';
-
-const c = initContract();
-
-export const bonusTiersContract = c.router(
-  {
-    estimateCalculation: {
-      summary: 'Estimate bonus tier calculation',
-      method: 'POST',
-      path: '/estimate-calculation',
-      metadata: {
-        auth: true,
-      },
-      body: EstimateBonusTierCalculationZod,
-      responses: {
-        200: EstimateBonusTierCalculationResponseZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'bonus-tiers',
-  },
-);

package/src/contracts/investors/cart/index.ts

@@ -1,75 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  UnauthorizedError,
-  ForbiddenError,
-  NotFoundError,
-  InternalError,
-  BadRequestError,
-  TradeZod,
-  tradeIdSchema,
-} from '../../../common/types';
-import {
-  PlaceTradeResponse,
-  PlaceTradeBody,
-  PatchCartBody,
-} from '../../../common/types/cart.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const cartContract = c.router(
-  {
-    getTradeCart: {
-      summary: 'GET Cart (Trade.status = CART)',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: TradeZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    postCheckout: {
-      summary: 'Place a trade (checkout button)',
-      method: 'POST',
-      path: '/checkout',
-      metadata: {
-        auth: true,
-      },
-      body: PlaceTradeBody,
-      responses: {
-        200: PlaceTradeResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    patchCart: {
-      summary: 'Patch a cart',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: tradeIdSchema,
-      }),
-      body: PatchCartBody,
-      responses: {
-        200: TradeZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'carts',
-  },
-);

package/src/contracts/investors/contact-us/index.ts

@@ -1,48 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  InvestorPostContactUsZod,
-  PostContactUsResponse,
-  PublicInvestorContactUsZod,
-} from '../../../common/types/contact-us.types';
-
-const c = initContract();
-
-export const contactUsContract = c.router(
-  {
-    postContactUsPublic: {
-      summary: 'Post Contact us for public users',
-      method: 'POST',
-      path: '/public',
-      body: PublicInvestorContactUsZod,
-      responses: {
-        201: PostContactUsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    postContactUs: {
-      summary: 'Post Contact us',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: InvestorPostContactUsZod,
-      responses: {
-        201: PostContactUsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'contact-us',
-  },
-);

package/src/contracts/investors/data-records/index.ts

@@ -1,113 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  dataRecordIdSchema,
-  DataRecordsFilters,
-  DataRecordsIncludeQuery,
-  DataRecordStructureZod,
-  DataRecordZod,
-  IPaginatedDataRecords,
-  NavigationSummaryZod,
-  RecordPathResponse,
-} from '../../../common/types/data-record.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const dataRecordsContract = c.router(
-  {
-    getDataRecords: {
-      summary: 'Get Data Records',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(DataRecordsFilters).merge(
-        DataRecordsIncludeQuery,
-      ),
-      responses: {
-        200: IPaginatedDataRecords,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getDataRecord: {
-      summary: 'Get data record by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      query: DataRecordsIncludeQuery,
-      responses: {
-        200: DataRecordZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDataRecordStructure: {
-      summary:
-        'Get data record structure by id - shows the proper tree structure of the data record',
-      method: 'GET',
-      path: '/:id/structure',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      responses: {
-        200: DataRecordStructureZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getDataRecordPath: {
-      summary:
-        'Get data record path by id - useful for navigation and showing the user where they are in the folder structure. Returns the path to the record',
-      method: 'GET',
-      path: '/:id/path',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      responses: {
-        200: RecordPathResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getNavigationSummary: {
-      summary:
-        'Get navigation summary for a data record - useful for breadcrumbs',
-      method: 'GET',
-      path: '/:id/navigation',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      responses: {
-        200: NavigationSummaryZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'data-records',
-  },
-);