@dalmore/api-contracts 1.0.0

package/contracts/issuers/api-keys/index.ts

@@ -0,0 +1,93 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  ForbiddenError,
+  NotFoundError,
+  UnauthorizedError,
+  InternalError,
+  ApiKeyZod,
+  IPaginatedApiKeys,
+  PaginationOptionsZod,
+  BadRequestError,
+  apiKeyIdSchema,
+  PostIssuerApiKeyBody,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerApiKeysContract = c.router(
+  {
+    postApiKey: {
+      summary: 'Create API Key',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostIssuerApiKeyBody,
+      responses: {
+        201: ApiKeyZod,
+        400: BadRequestError,
+        404: NotFoundError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getApiKeys: {
+      summary: 'Get API Keys',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod,
+      responses: {
+        200: IPaginatedApiKeys,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getApiKey: {
+      summary: 'Get API Key',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: apiKeyIdSchema,
+      }),
+      responses: {
+        200: ApiKeyZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    deactivateApiKey: {
+      summary: 'Deactivate API Key by id',
+      method: 'PATCH',
+      path: '/:id/deactivate',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: apiKeyIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        202: ApiKeyZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'api-keys',
+  },
+);

package/contracts/issuers/assets/index.ts

@@ -0,0 +1,122 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ConflictError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  AssetFiltersZod,
+  assetIdSchema,
+  AssetsIncludeQuery,
+  IAsset,
+  IPaginatedAsset,
+  PostAsset,
+  PutAsset,
+} 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: z.object({}).merge(AssetsIncludeQuery),
+      pathParams: z.object({
+        id: assetIdSchema,
+      }),
+      responses: {
+        200: IAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    postAssets: {
+      summary: 'Create an asset',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostAsset,
+      responses: {
+        201: IAsset,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        409: ConflictError,
+        500: InternalError,
+      },
+    },
+    updateAsset: {
+      summary: 'Update asset',
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: assetIdSchema,
+      }),
+      body: PutAsset,
+      responses: {
+        201: IAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    setHeroAsset: {
+      summary: 'Set hero asset',
+      method: 'PATCH',
+      path: '/hero/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: assetIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        201: IAsset,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+
+  {
+    pathPrefix: 'assets',
+  },
+);

package/contracts/issuers/auth/index.ts

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,37 @@
+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/contracts/issuers/contact-us/index.ts

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,136 @@
+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

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