@dalmore/api-contracts 1.0.3 → 1.0.6

package/src/common/helpers/index.ts

@@ -1,205 +0,0 @@
-/**
- * Contract helpers - minimal subset for API contracts package
- * This file is copied directly to @dalmore/api-contracts
- */
-import { HttpStatus } from '@nestjs/common';
-import parsePhoneNumberFromString, {
-  CountryCode,
-  PhoneNumber,
-} from 'libphonenumber-js';
-import { err, ok, Result } from 'neverthrow';
-import { ErrorResult } from '../types/common.types';
-
-/**
- * Validates a US zip code format (12345 or 12345-6789)
- */
-export const validateUSZipCode = (zipCode: string): boolean => {
-  const regex = /^[0-9]{5}(?:-[0-9]{4})?$/;
-  return regex.test(zipCode);
-};
-
-/**
- * Validates a Canadian postal code format (A1A 1A1)
- */
-export const validateCanadaZipCode = (zipCode: string): boolean => {
-  const regex = /^[A-Za-z]\d[A-Za-z] \d[A-Za-z]\d$/;
-  return regex.test(zipCode);
-};
-
-/**
- * Normalizes a short date string (M/D/YY or M/D/YYYY) to MM/DD/YYYY format
- */
-export function normalizeShortDate(input: string): string {
-  const [month, day, year] = input.split('/');
-
-  if (!month || !day || !year) {
-    throw new Error('Invalid date format');
-  }
-
-  const paddedMonth = month.padStart(2, '0');
-  const paddedDay = day.padStart(2, '0');
-  const fullYear = year.length === 2 ? `20${year}` : year;
-
-  return `${paddedMonth}/${paddedDay}/${fullYear}`;
-}
-
-/**
- * Converts a string into a URL-safe slug
- */
-export function slugify(input: string, exclude: boolean = false): string {
-  if (exclude) {
-    const excludeWords = ['llc', 'inc', 'corp', 'co'];
-    const negativeWordsList = [
-      'www',
-      'api',
-      'admin',
-      'dashboard',
-      'auth',
-      'cdn',
-      'static',
-      'blog',
-      'support',
-      'status',
-      'mail',
-      'smtp',
-      'ftp',
-      'ssh',
-      'login',
-      'register',
-      'signup',
-      'account',
-      'accounts',
-      'user',
-      'users',
-      'profile',
-      'settings',
-      'help',
-      'docs',
-      'documentation',
-      'developer',
-      'developers',
-      'app',
-      'apps',
-      'test',
-      'demo',
-      'staging',
-      'dev',
-      'prod',
-      'production',
-      'beta',
-      'alpha',
-      'portal',
-      'portals',
-      'client',
-      'clients',
-      'investor',
-      'investors',
-      'issuer',
-      'issuers',
-      'compliance',
-      'offering',
-      'offerings',
-      'trade',
-      'trades',
-    ];
-
-    let slug = input
-      .toLowerCase()
-      .replace(/[^\w\s-]/g, '')
-      .replace(/[\s_-]+/g, '-')
-      .replace(/^-+|-+$/g, '');
-
-    excludeWords.forEach((word) => {
-      slug = slug.replace(new RegExp(`-${word}$`, 'i'), '');
-    });
-
-    if (negativeWordsList.includes(slug)) {
-      return 'new-account';
-    }
-
-    return slug;
-  }
-
-  return input
-    .toLowerCase()
-    .replace(/[^\w\s-]/g, '')
-    .replace(/[\s_-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-}
-
-type CurlOptions = {
-  query?: Record<string, string>;
-  headers?: Record<string, string>;
-  body?: Record<string, unknown>;
-  formData?: Record<string, string>;
-};
-
-export const authHeader: CurlOptions['headers'] = {
-  Authorization: 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
-};
-
-const generateCurlExample = (
-  method: string,
-  path: string,
-  options: CurlOptions,
-) => {
-  const baseUrl = 'https://dalmore-client-portal-api-prod.onrender.com/api/v1';
-  let curl = `curl -X ${method.toUpperCase()} '${baseUrl}${path}`;
-  if (options.query) {
-    const queryString = new URLSearchParams(options.query).toString();
-    curl += `?${queryString}`;
-  }
-  curl += "'";
-  if (options.headers) {
-    Object.entries(options.headers).forEach(([key, value]) => {
-      curl += ` \\\n  --header '${key}: ${value}'`;
-    });
-  }
-  if (options.body) {
-    curl += ` \\\n  --header 'Content-Type: application/json'`;
-    curl += ` \\\n  --data '${JSON.stringify(options.body)}'`;
-  }
-  if (options.formData) {
-    Object.entries(options.formData).forEach(([key, value]) => {
-      curl += ` \\\n  --form '${key}=${value}'`;
-    });
-  }
-  return curl;
-};
-
-export const generateApiDescription = (
-  summary: string,
-  method: string,
-  path: string,
-  options: CurlOptions,
-) => {
-  const curlExample = generateCurlExample(method, path, options);
-  return `${summary}
-
-### Example curl request
-
-\`\`\`bash
-${curlExample}
-\`\`\``;
-};
-
-/**
- * Normalizes a phone number to E.164 format
- */
-export function normalizePhoneNumber(
-  phoneNumber: string,
-  countryCode: CountryCode,
-): Result<PhoneNumber, ErrorResult> {
-  const parsedPhoneNumber = parsePhoneNumberFromString(
-    phoneNumber,
-    countryCode,
-  );
-
-  if (!parsedPhoneNumber || !parsedPhoneNumber.isValid()) {
-    return err({
-      status: HttpStatus.BAD_REQUEST,
-      message: 'Invalid phone number. Only numbers',
-    });
-  }
-  return ok(parsedPhoneNumber);
-}

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

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

package/src/contracts/compliance/account-managers/index.ts

@@ -1,142 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import { z } from 'zod';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalError,
-  NotFoundError,
-  PaginationOptionsZod,
-  PreconditionFailedError,
-  UnauthorizedError,
-} from '../../../common/types';
-import {
-  AccountManagerDeleteQuery,
-  AccountManagerDeleteResponse,
-  accountManagerIdSchema,
-  AccountManagersIncludeQuery,
-  IAccountManagerZod,
-  IPaginatedAccountManager,
-  PatchAccountManagerZod,
-  PostAccountManagerZod,
-  SetDefaultAccountManagerForAllAccountsResponse,
-} from '../../../common/types/account-manager.types';
-
-const c = initContract();
-
-export const accountManagersContract = c.router(
-  {
-    getAccountManagers: {
-      summary: 'Get account managers',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(AccountManagersIncludeQuery),
-      responses: {
-        200: IPaginatedAccountManager,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getAccountManager: {
-      summary: 'Get account manager by id',
-      method: 'GET',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      query: z.object({}).merge(AccountManagersIncludeQuery),
-      pathParams: z.object({
-        id: accountManagerIdSchema,
-      }),
-      responses: {
-        200: IAccountManagerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    setDefaultAccountManagerForAllAccounts: {
-      summary: '[ADMIN] Set default account manager for all accounts',
-      method: 'PATCH',
-      path: '/set-default-for-all-accounts',
-      metadata: {
-        auth: true,
-      },
-      body: z.object({}),
-      responses: {
-        200: SetDefaultAccountManagerForAllAccountsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    patchAccountManager: {
-      summary: 'Update account manager by id',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountManagerIdSchema,
-      }),
-      body: PatchAccountManagerZod,
-      responses: {
-        201: IAccountManagerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        500: InternalError,
-      },
-    },
-    postAccountManager: {
-      summary: 'Create account manager',
-      method: 'POST',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      body: PostAccountManagerZod,
-      responses: {
-        201: IAccountManagerZod,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    deleteAccountManager: {
-      summary: 'Delete account manager by id',
-      method: 'DELETE',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountManagerIdSchema,
-      }),
-      query: AccountManagerDeleteQuery,
-      responses: {
-        201: AccountManagerDeleteResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        404: NotFoundError,
-        412: PreconditionFailedError,
-        500: InternalError,
-      },
-    },
-  },
-
-  {
-    pathPrefix: 'account-managers',
-  },
-);

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

@@ -1,187 +0,0 @@
-import { initContract } from '@ts-rest/core';
-import {
-  ForbiddenError,
-  IPaginatedAccount,
-  NotFoundError,
-  PaginationOptionsZod,
-  UnauthorizedError,
-  AccountFiltersZod,
-  AccountsIncludeQuery,
-  AccountZod,
-  InternalError,
-  accountIdSchema,
-  CreateAccountZod,
-  AccountsSummaryFilterZod,
-  IPaginatedAccountsSummaryResponse,
-  UpdateAccountIssuersStatusZod,
-  UpdateAccountStatusReponse,
-  CompliancePatchAccountZod,
-  AccountSortZod,
-  BadRequestError,
-} from '../../../common/types';
-import { z } from 'zod';
-import { AccountDetailSummaryZod } from '../../../common/types/account-detail.types';
-import {
-  accountManagerIdSchema,
-  SetDefaultAccountManagerForAllAccountsResponse,
-} from '../../../common/types/account-manager.types';
-
-const c = initContract();
-
-export const accountsContract = c.router(
-  {
-    getPaginatedAccountsSummary: {
-      summary: 'Get accounts summary with pagination',
-      method: 'GET',
-      path: '/summary',
-      metadata: {
-        auth: true,
-      },
-      query: PaginationOptionsZod.merge(AccountsSummaryFilterZod).merge(
-        AccountSortZod,
-      ),
-      responses: {
-        200: IPaginatedAccountsSummaryResponse,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    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,
-        500: InternalError,
-      },
-    },
-    // Admin
-    getAccountsAdmin: {
-      summary: '[ADMIN] Get accounts',
-      method: 'GET',
-      path: '',
-      metadata: {
-        auth: true,
-      },
-      query:
-        PaginationOptionsZod.merge(AccountFiltersZod).merge(
-          AccountsIncludeQuery,
-        ),
-      responses: {
-        200: IPaginatedAccount,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    updateAccountAdmin: {
-      summary: '[ADMIN] Update account by id',
-      method: 'PATCH',
-      path: '/:id',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      body: CompliancePatchAccountZod,
-      responses: {
-        200: AccountZod,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    updateAccountStatusAdmin: {
-      summary: '[ADMIN] Update account status by id',
-      method: 'PATCH',
-      path: '/:id/status',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      body: UpdateAccountIssuersStatusZod,
-      responses: {
-        200: UpdateAccountStatusReponse,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-
-    createAccount: {
-      summary: '[ADMIN] Create an account',
-      method: 'POST',
-      path: '/',
-      metadata: {
-        auth: true,
-      },
-      body: CreateAccountZod,
-      responses: {
-        201: AccountZod,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    getAccountDetailSummary: {
-      summary: 'Get account detail summary',
-      method: 'GET',
-      path: '/:id/detail-summary',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      responses: {
-        200: AccountDetailSummaryZod,
-        404: NotFoundError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-    setAccountManagerForAccount: {
-      summary: 'Set account manager for account',
-      method: 'PATCH',
-      path: '/:id/set-account-manager-for-account',
-      metadata: {
-        auth: true,
-      },
-      pathParams: z.object({
-        id: accountIdSchema,
-      }),
-      body: z.object({
-        accountManagerId: accountManagerIdSchema,
-      }),
-      responses: {
-        200: SetDefaultAccountManagerForAllAccountsResponse,
-        400: BadRequestError,
-        401: UnauthorizedError,
-        403: ForbiddenError,
-        500: InternalError,
-      },
-    },
-  },
-  {
-    pathPrefix: 'accounts',
-  },
-);

package/src/contracts/compliance/activities/index.ts

@@ -1,55 +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,
-        403: ForbiddenError,
-      },
-    },
-    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',
-  },
-);