@dalmore/api-contracts 1.0.2 → 1.0.5

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

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

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

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

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

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

@@ -1,97 +0,0 @@
-import { initContract } from '@ts-rest/core';
-
-import {
-  AccountsIncludeQuery,
-  AccountZod,
-  ForbiddenError,
-  GetAccountIssuersZod,
-  IPaginatedAccount,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  NotFoundError,
-  accountIdSchema,
-  PatchAccountZod,
-  PatchIssuerOnboardingStep,
-  IssuerOnboardingStepZod,
-  InternalError,
-} 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,
-        500: InternalError,
-      },
-    },
-    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,
-        500: InternalError,
-      },
-    },
-    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,
-        500: InternalError,
-      },
-    },
-    patchAccount: {
-      summary: 'Update an account',
-      method: 'PATCH',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PatchAccountZod,
-      responses: {
-        201: AccountZod,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'accounts',
-  },
-);

package/contracts/issuers/activities/index.ts

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

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

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