@dalmore/api-contracts 0.0.0-dev.d07da18 → 0.0.0-dev.d29fb02

package/contracts/issuers/auth/index.ts

@@ -1,152 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  AccessTokenResponse,
-  BadRequestError,
-  ForbiddenError,
-  IChangePasswordBodyZod,
-  InternalError,
-  IRegisterIssuerBodyZod,
-  LoginBody,
-  LoginBody2FA,
-  LoginBodyIssuers,
-  NotFoundError,
-  SelectAccountIssuersResponse,
-  SwitchAccountIssuersBody,
-  UnauthorizedError,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const authContract = c.router(
-  {
-    selectAccount: {
-      summary: 'Select Account for login',
-      method: 'POST',
-      path: 'login/accounts',
-      body: LoginBody,
-      responses: {
-        200: SelectAccountIssuersResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    registerEmail: {
-      summary: 'Register with email',
-      method: 'POST',
-      path: 'register/email',
-      body: IRegisterIssuerBodyZod,
-      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: LoginBodyIssuers,
-      responses: {
-        200: AccessTokenResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    switchAccount: {
-      summary: 'Switch account',
-      method: 'POST',
-      path: 'switch-account',
-      body: SwitchAccountIssuersBody,
-      responses: {
-        200: AccessTokenResponse,
-        400: BadRequestError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    forgotPassword: {
-      summary: 'Forgot password',
-      method: 'POST',
-      path: 'forgot-password',
-      body: z.object({
-        email: z.string().email(),
-      }),
-      responses: {
-        200: z.string(),
-        400: BadRequestError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    resetPasswordVerify: {
-      summary: 'Reset password verify',
-      method: 'POST',
-      path: 'reset-password/verify',
-      body: z.object({
-        email: z.string().email(),
-        code: z.string(),
-      }),
-      responses: {
-        200: z.object({
-          valid: z.boolean(),
-        }),
-        400: BadRequestError,
-        500: InternalError,
-      },
-    },
-    resetPassword: {
-      summary: 'Reset password',
-      method: 'POST',
-      path: 'reset-password',
-      body: z.object({
-        email: z.string().email(),
-        code: z.string(),
-        password: z.string().min(6),
-      }),
-      responses: {
-        200: null,
-        400: BadRequestError,
-        500: InternalError,
-      },
-    },
-    changePassword: {
-      summary: 'Change password',
-      method: 'POST',
-      path: 'change-password',
-      body: IChangePasswordBodyZod,
-      responses: {
-        201: null,
-        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/contracts/issuers/bonus-tiers/index.ts

@@ -1,55 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  EstimateBonusTierCalculationResponseZod,
-  EstimateBonusTierCalculationZod,
-  IBonusTierList,
-  PostBonusTierZod,
-} 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,
-      },
-    },
-    postBonusTier: {
-      summary: 'Create a new bonus tier',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: PostBonusTierZod,
-      responses: {
-        201: IBonusTierList,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'bonus-tiers',
-  },
-);

package/contracts/issuers/contact-us/index.ts

@@ -1,48 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  InternalError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  PostContactUsResponse,
-  PostContactUsZod,
-  PublicIssuerContactUsZod,
-} 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: PublicIssuerContactUsZod,
-      responses: {
-        201: PostContactUsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-    postContactUs: {
-      summary: 'Post Contact us',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostContactUsZod,
-      responses: {
-        201: PostContactUsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'contact-us',
-  },
-);

package/contracts/issuers/covered-persons/index.ts

@@ -1,136 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  CoveredPersonDeleteResponse,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  PatchCoveredPersonsZod,
-  PreconditionFailedError,
-  ReviewCoveredPersons,
-  UnauthorizedError,
-} from '../../../common/types';
-
-import {
-  coveredPersonIdSchema,
-  CoveredPersonsIncludeQuery,
-  GetCoveredPersonsZod,
-  ICoveredPerson,
-  IPaginatedCoveredPerson,
-  PostCoveredPersonsZod,
-} from '../../../common/types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const coveredPersonsContract = c.router(
-  {
-    getCoveredPersons: {
-      summary: 'Get Covered Persons',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(CoveredPersonsIncludeQuery).merge(
-        GetCoveredPersonsZod,
-      ),
-      responses: {
-        200: IPaginatedCoveredPerson,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    postCoveredPersons: {
-      summary: 'Create a covered person',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostCoveredPersonsZod,
-      responses: {
-        201: ICoveredPerson,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        412: PreconditionFailedError,
-        500: InternalError,
-      },
-    },
-    getCoveredPerson: {
-      summary: 'Get covered person by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(CoveredPersonsIncludeQuery),
-      pathParams: z.object({ id: coveredPersonIdSchema }),
-      responses: {
-        200: ICoveredPerson,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-      },
-    },
-    patchCoveredPerson: {
-      summary: 'Update covered person',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: coveredPersonIdSchema }),
-      body: PatchCoveredPersonsZod,
-      responses: {
-        201: ICoveredPerson,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    reviewCoveredPersons: {
-      summary: 'Review CoveredPersons',
-      method: 'POST',
-      path: '/review',
-      metadata: {
-        auth: true,
-      },
-      body: ReviewCoveredPersons,
-      responses: {
-        201: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteCoveredPerson: {
-      summary: 'Delete covered person by id',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: coveredPersonIdSchema,
-      }),
-      responses: {
-        200: CoveredPersonDeleteResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'covered-persons',
-  },
-);

package/contracts/issuers/dashboard/index.ts

@@ -1,72 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  offeringIdSchema,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  GetInvestmentDashboardQueryZod,
-  InvestmentDashboardZod,
-  IssuerDashboardZod,
-  IssuersOfferingDashboardZod,
-} from '../../../common/types/dashboard.types';
-import { z } from 'zod';
-
-const c = initContract();
-
-export const dashboardContract = c.router(
-  {
-    getDashboard: {
-      summary: 'Get dashboard for issuers',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      responses: {
-        200: IssuerDashboardZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getOfferingDashboard: {
-      summary: 'Get offerings dashboard for approved offerings for issuers',
-      method: 'GET',
-      path: '/offerings/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: offeringIdSchema,
-      }),
-      responses: {
-        200: IssuersOfferingDashboardZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    getInvestmentDashboard: {
-      summary: 'Get investment dashboard for issuers',
-      method: 'GET',
-      path: '/investments',
-      metadata: {
-        auth: true,
-      },
-      query: GetInvestmentDashboardQueryZod,
-      responses: {
-        200: InvestmentDashboardZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'dashboard',
-  },
-);

package/contracts/issuers/data-records/index.ts

@@ -1,257 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  dataRecordFileIdSchema,
-  DataRecordFileZod,
-  dataRecordIdSchema,
-  DataRecordsFilters,
-  DataRecordsIncludeQuery,
-  DataRecordStructureZod,
-  DataRecordZod,
-  DeleteDataRecordFile,
-  DeleteDataRecordFolder,
-  IPaginatedDataRecords,
-  MoveDataRecordFile,
-  MoveDataRecordFolder,
-  NavigationSummaryZod,
-  PatchDataRecordFile,
-  PatchDataRecordFolder,
-  PostDataRecordFile,
-  PostDataRecordFolder,
-  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,
-      },
-    },
-    postDataRecordFolder: {
-      summary: 'Create a data record folder',
-      method: 'POST',
-      path: '/folders',
-      metadata: {
-        auth: true,
-      },
-      body: PostDataRecordFolder,
-      responses: {
-        201: DataRecordZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchDataRecordFolder: {
-      summary: 'Update data record folder',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordIdSchema }),
-      body: PatchDataRecordFolder,
-      responses: {
-        201: DataRecordZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteDataRecordFolder: {
-      summary:
-        'Deletes a folder and optionally(force=true) all its contents (subfolders and file associations)',
-      method: 'DELETE',
-      path: '/folders',
-      metadata: {
-        auth: true,
-      },
-      body: DeleteDataRecordFolder,
-      responses: {
-        204: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    moveDataRecordFolder: {
-      summary: 'Move a data record folder to a new parent',
-      method: 'POST',
-      path: '/folders/move',
-      metadata: {
-        auth: true,
-      },
-      body: MoveDataRecordFolder,
-      responses: {
-        201: DataRecordZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postDataRecordFile: {
-      summary: 'Create a data record file object to a folder',
-      method: 'POST',
-      path: '/files',
-      metadata: {
-        auth: true,
-      },
-      body: PostDataRecordFile,
-      responses: {
-        201: DataRecordFileZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    patchDataRecordFile: {
-      summary: 'Add a file to a folder via a data record file object',
-      method: 'PATCH',
-      path: '/files/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({ id: dataRecordFileIdSchema }),
-      body: PatchDataRecordFile,
-      responses: {
-        201: DataRecordFileZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    deleteDataRecordFile: {
-      summary:
-        'Delete a data record file from a folder - note that this does not delete the file itself',
-      method: 'DELETE',
-      path: '/files',
-      metadata: {
-        auth: true,
-      },
-      body: DeleteDataRecordFile,
-      responses: {
-        204: z.object({ success: z.boolean() }),
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    moveDataRecordFile: {
-      summary: 'Move a data record file from folder A to folder B',
-      method: 'POST',
-      path: '/files/move',
-      metadata: {
-        auth: true,
-      },
-      body: MoveDataRecordFile,
-      responses: {
-        201: DataRecordFileZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'data-records',
-  },
-);