@dalmore/api-contracts 1.0.0

package/contracts/investors/user-settings/index.ts

@@ -0,0 +1,170 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  sendEmailVerificationBody,
+  sendEmailVerificationResponse,
+  sendVerificationCodeBody,
+  sendVerificationCodeResponse,
+  setupPhoneNumberBody,
+  setupPhoneNumberResponse,
+  setupTwoFactorResponse,
+  userSettingsZod,
+  validPhoneNumberBody,
+  validPhoneNumberResponse,
+  verifyEmailBody,
+  verifyEmailResponse,
+  verifyPhoneNumberBody,
+  verifyPhoneNumberResponse,
+  verifyTwoFactorBody,
+  verifyTwoFactorResponse,
+} from '../../../common/types/user-setting.types';
+
+const c = initContract();
+
+export const userSettingsContract = c.router(
+  {
+    getUserSettings: {
+      summary: 'Get current user settings',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: userSettingsZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    validPhoneNumber: {
+      summary: 'Validate phone number',
+      method: 'POST',
+      path: '/valid-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: validPhoneNumberBody,
+      responses: {
+        200: validPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    setupPhoneNumber: {
+      summary: 'Setup phone number',
+      method: 'POST',
+      path: '/setup-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: setupPhoneNumberBody,
+      responses: {
+        200: setupPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    verifyPhoneNumber: {
+      summary: 'Verify phone number',
+      method: 'POST',
+      path: '/verify-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: verifyPhoneNumberBody,
+      responses: {
+        200: verifyPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    sendVerificationCode: {
+      summary: 'Send verification code',
+      method: 'POST',
+      path: '/send-verification-code',
+      metadata: {
+        auth: true,
+      },
+      body: sendVerificationCodeBody,
+      responses: {
+        200: sendVerificationCodeResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    setupTwoFactorAuthenticator: {
+      summary: 'Setup 2FA',
+      method: 'GET',
+      path: '/setup-authenticator',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: setupTwoFactorResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    verifyTwoFactorAuthenticator: {
+      summary: 'Verify 2FA',
+      method: 'POST',
+      path: '/verify-authenticator',
+      body: verifyTwoFactorBody,
+      responses: {
+        201: verifyTwoFactorResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    sendEmailVerification: {
+      summary: 'Send email verification code',
+      method: 'POST',
+      path: '/send-email-verification',
+      metadata: {
+        auth: true,
+      },
+      body: sendEmailVerificationBody,
+      responses: {
+        200: sendEmailVerificationResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        429: BadRequestError,
+        500: InternalError,
+      },
+    },
+    verifyEmail: {
+      summary: 'Verify email with code',
+      method: 'POST',
+      path: '/verify-email',
+      metadata: {
+        auth: true,
+      },
+      body: verifyEmailBody,
+      responses: {
+        200: verifyEmailResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'user-settings',
+  },
+);

package/contracts/investors/users/index.ts

@@ -0,0 +1,45 @@
+import { initContract } from '@ts-rest/core';
+import {
+  GetMeResponse,
+  InvestorsUserMeUpdateZod,
+  NotFoundError,
+  UnauthorizedError,
+  UserWithoutPasswordZod,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const usersContract = c.router(
+  {
+    me: {
+      summary: 'Get current user',
+      method: 'GET',
+      path: '/me',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: GetMeResponse,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    updateMe: {
+      summary: 'Update current user',
+      method: 'PATCH',
+      path: '/me',
+      metadata: {
+        auth: true,
+      },
+      body: InvestorsUserMeUpdateZod,
+      responses: {
+        201: UserWithoutPasswordZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'users',
+  },
+);

package/contracts/investors/webhooks/index.ts

@@ -0,0 +1,30 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+
+const c = initContract();
+export const webhooksContract = c.router(
+  {
+    postBoldsignWebhook: {
+      summary: '[BoldSign] webhook',
+      method: 'POST',
+      path: '/boldsign',
+      body: z.any(), // Raw body will be handled by NestJS RawBodyRequest
+      responses: {
+        200: z.object({
+          received: z.boolean(),
+        }),
+        400: z.object({
+          received: z.boolean(),
+          error: z.string().optional(),
+        }),
+        401: z.object({
+          received: z.boolean(),
+          error: z.string().optional(),
+        }),
+      },
+    },
+  },
+  {
+    pathPrefix: 'webhooks',
+  },
+);

package/contracts/issuers/account-contacts/index.ts

@@ -0,0 +1,76 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  accountContactIdSchema,
+  IAccountContact,
+  PatchAccountContactZod,
+} 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,
+      },
+      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,
+      },
+    },
+    patchAccountContact: {
+      summary: 'Update account contact',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountContactIdSchema,
+      }),
+      body: PatchAccountContactZod,
+      responses: {
+        200: IAccountContact,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'account-contacts',
+  },
+);

package/contracts/issuers/account-integrations/index.ts

@@ -0,0 +1,97 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  accountIntegrationIdSchema,
+  AccountIntegrationZod,
+  IPaginatedAccountIntegration,
+  PatchAccountIntegrationZod,
+  PostAccountIntegrationZod,
+  AccountIntegrationFiltersZod,
+} from '../../../common/types/account-integration.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const accountIntegrationsContract = c.router(
+  {
+    getAccountIntegrations: {
+      summary: 'Get Account Integrations',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(AccountIntegrationFiltersZod),
+      responses: {
+        200: IPaginatedAccountIntegration,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getAccountIntegration: {
+      summary: 'Get account integration by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountIntegrationIdSchema,
+      }),
+      responses: {
+        200: AccountIntegrationZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postAccountIntegration: {
+      summary: 'Create account integration',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostAccountIntegrationZod,
+      responses: {
+        201: AccountIntegrationZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    patchAccountIntegration: {
+      summary: 'Update account integration',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountIntegrationIdSchema,
+      }),
+      body: PatchAccountIntegrationZod,
+      responses: {
+        200: AccountIntegrationZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'account-integrations',
+  },
+);

package/contracts/issuers/accounts/index.ts

@@ -0,0 +1,92 @@
+import { initContract } from '@ts-rest/core';
+
+import {
+  AccountsIncludeQuery,
+  AccountZod,
+  ForbiddenError,
+  GetAccountIssuersZod,
+  IPaginatedAccount,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  NotFoundError,
+  accountIdSchema,
+  PatchAccountZod,
+  PatchIssuerOnboardingStep,
+  IssuerOnboardingStepZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const accountsContract = c.router(
+  {
+    getAccounts: {
+      summary: 'Get issuer accounts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(AccountsIncludeQuery).merge(
+          GetAccountIssuersZod,
+        ),
+      responses: {
+        200: IPaginatedAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getAccount: {
+      summary: 'Get account by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: accountIdSchema,
+      }),
+      query: z.object({}).merge(AccountsIncludeQuery),
+      responses: {
+        200: AccountZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    patchOnboardingStep: {
+      summary: 'Update an account onboarding step',
+      method: 'PATCH',
+      path: '/onboarding',
+      metadata: {
+        auth: true,
+      },
+      body: PatchIssuerOnboardingStep,
+      responses: {
+        201: IssuerOnboardingStepZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    patchAccount: {
+      summary: 'Update an account',
+      method: 'PATCH',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PatchAccountZod,
+      responses: {
+        201: AccountZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'accounts',
+  },
+);

package/contracts/issuers/activities/index.ts

@@ -0,0 +1,54 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  ActivitiesFilters,
+  activityIdSchema,
+  ActivityZod,
+  IPaginatedActivity,
+} from '../../../../src/common/types/activity.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const activitiesContract = c.router(
+  {
+    getActivities: {
+      summary: 'Get activities',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(ActivitiesFilters),
+      responses: {
+        200: IPaginatedActivity,
+        401: UnauthorizedError,
+      },
+    },
+    getActivity: {
+      summary: 'Get activity by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: activityIdSchema,
+      }),
+      responses: {
+        200: ActivityZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'activities',
+  },
+);

package/contracts/issuers/aic/index.ts

@@ -0,0 +1,39 @@
+import { initContract } from '@ts-rest/core';
+import {
+  AicIncludeQuery,
+  AicZod,
+  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.nullable(),
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'individual/:individualId/aic',
+  },
+);

package/contracts/issuers/api-key-logs/index.ts

@@ -0,0 +1,53 @@
+import { initContract } from '@ts-rest/core';
+
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  IPaginatedApiLogs,
+  ApiLogsTotalsZod,
+  ApiLogsFiltersZod,
+  ApiLogsTotalsFiltersZod,
+} from '../../../common/types/api-key-logs.types';
+
+const c = initContract();
+
+export const issuerApiKeyLogsContract = c.router(
+  {
+    // GET /issuers/api-key-logs
+    getApiKeyLogs: {
+      summary: 'Get API key logs',
+      method: 'GET',
+      path: '',
+      metadata: { auth: true },
+      query: PaginationOptionsZod.merge(ApiLogsFiltersZod),
+      responses: {
+        200: IPaginatedApiLogs,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    // GET /issuers/api-key-logs/totals
+    getApiKeyLogsTotals: {
+      summary: 'Get totals of API key logs',
+      method: 'GET',
+      path: '/totals',
+      metadata: { auth: true },
+      query: ApiLogsTotalsFiltersZod,
+      responses: {
+        200: ApiLogsTotalsZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  { pathPrefix: 'api-key-logs' },
+);