@dalmore/api-contracts 0.0.0-dev.eb820f7 → 0.0.0-dev.f0b9301

package/common/types/auth.types.ts

@@ -1,370 +0,0 @@
-import { z } from 'zod';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { accountIdSchema } from './account.types';
-import { PasswordSchema } from './password.type';
-import { inviteIdSchema } from './invite.types';
-import {
-  PortalType,
-  ManagedByType,
-  UserRole,
-  createUrlSchema,
-} from './common.types';
-import { TypeID } from 'typeid-js';
-import { TwoFactorMethod } from './sms.types';
-import { PhoneZodSchema } from './phone.type';
-
-extendZodWithOpenApi(z);
-
-export const userLoginIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'user_login';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid user ID format. Must be a valid TypeID with "user_login" prefix.',
-  },
-);
-
-export enum AuthProvider {
-  EMAIL = 'email',
-}
-
-const isBase64 = (v: string) => {
-  if (v.length % 4 !== 0) {
-    return false;
-  }
-  try {
-    return btoa(atob(v)) === v;
-  } catch (err) {
-    return false;
-  }
-};
-
-const BaseAuthBody = z.object({
-  firstName: z
-    .string()
-    .min(2, 'firstName is less than 2 characters')
-    .max(20, 'firstName is more than 20 characters')
-    .openapi({
-      example: 'Neil',
-    }),
-  lastName: z
-    .string()
-    .min(2, 'lastName is less than 2 characters')
-    .max(20, 'lastName is more than 20 characters')
-    .openapi({
-      example: 'Armstrong',
-    }),
-  email: z
-    .string()
-    .email()
-    .transform((val) => val.toLowerCase())
-    .openapi({
-      example: 'neil@dalmoregroup.com',
-    }),
-  password: PasswordSchema,
-});
-
-export const IRegisterBodyZod = BaseAuthBody.extend({
-  code: z
-    .string()
-    .refine(isBase64, {
-      message: 'Must be a valid base64 encoded string',
-    })
-    .openapi({
-      example: 'eyJpdiI6InhhTFIyVG9ETnhnUzQ1QzUyNzRJenc9PSIsI',
-    }),
-});
-
-export const IChangePasswordBodyZod = z
-  .object({
-    currentPassword: z.string().min(6).openapi({
-      example: 'Secretpassword6#',
-    }),
-    newPassword: PasswordSchema,
-    newPasswordConfirm: PasswordSchema,
-  })
-  .refine((data) => data.currentPassword !== data.newPassword, {
-    message: 'New password must be different from current password',
-    path: ['newPassword'],
-  })
-  .refine((data) => data.newPassword === data.newPasswordConfirm, {
-    message: 'Password confirmation does not match new password',
-    path: ['newPasswordConfirm'],
-  });
-
-export const LoginBody = z.object({
-  email: z
-    .string()
-    .email()
-    .transform((val) => val.toLowerCase())
-    .openapi({
-      example: 'neil@dalmoregroup.com',
-    }),
-  password: z.string().openapi({
-    example: 'Secretpassword6#',
-  }),
-  rememberMe: z.boolean().optional().default(false).openapi({
-    example: true,
-  }),
-  twoFactorMethod: z.nativeEnum(TwoFactorMethod).optional().openapi({
-    example: 'SMS',
-  }),
-});
-export type LoginBody = z.infer<typeof LoginBody>;
-
-export const LoginBody2FA = z.object({
-  token: z.string().min(6).max(14).openapi({
-    example: 'neil@dalmoregroup.com',
-  }),
-  temporaryToken: z.string().min(1).openapi({
-    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
-  }),
-  rememberMe: z.boolean().optional().default(false).openapi({
-    example: true,
-  }),
-});
-export type LoginBody2FA = z.infer<typeof LoginBody>;
-
-export const LoginBodyInvestors = LoginBody.extend({
-  site: z.string().openapi({ site: 'example.com' }),
-});
-export type LoginBodyInvestors = z.infer<typeof LoginBodyInvestors>;
-
-export const LoginBodyIssuers = LoginBody.extend({
-  accountId: accountIdSchema.openapi({
-    accountId: 'account_00041061050r3gg28a1c60t3gf',
-  }),
-});
-export type LoginBodyIssuers = z.infer<typeof LoginBodyIssuers>;
-
-export const SelectAccountIssuers = LoginBody;
-export type SelectAccountIssuers = z.infer<typeof SelectAccountIssuers>;
-
-export const SelectAccountIssuersResponse = z.object({
-  invites: z.array(
-    z.object({
-      id: inviteIdSchema.openapi({
-        example: 'invite_00041061050r3gg28a1c60t3gf',
-      }),
-      name: z.string().openapi({ example: 'Example Account' }),
-      accountId: accountIdSchema.nullable().openapi({
-        example: 'account_00041061050r3gg28a1c60t3gf',
-      }),
-      role: z
-        .nativeEnum(UserRole)
-        .nullable()
-        .openapi({ example: UserRole.MARKETER }),
-    }),
-  ),
-  accounts: z.array(
-    z.object({
-      id: accountIdSchema.openapi({
-        example: 'account_00041061050r3gg28a1c60t3gf',
-      }),
-      name: z.string().openapi({ example: 'Example Account' }),
-      firstName: z.string().openapi({ example: 'John' }),
-      lastName: z.string().openapi({ example: 'Doe' }),
-    }),
-  ),
-});
-export type SelectAccountIssuersResponse = z.infer<
-  typeof SelectAccountIssuersResponse
->;
-
-export const SwitchAccountIssuersBody = z.object({
-  accountId: accountIdSchema,
-});
-export type SwitchAccountIssuersBody = z.infer<typeof SwitchAccountIssuersBody>;
-
-export const AccessTokenResponse = z.object({
-  accessToken: z.string().optional().openapi({
-    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
-  }),
-  requiresTwoFactor: z.boolean().optional().openapi({
-    example: true,
-  }),
-  temporaryToken: z.string().optional().openapi({
-    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9',
-  }),
-  requiresTwoFactorSetup: z.boolean().optional().openapi({
-    example: true,
-  }),
-  twoFactorMethod: z.nativeEnum(TwoFactorMethod).optional().openapi({
-    example: 'SMS',
-  }),
-});
-export type AccessTokenResponse = z.infer<typeof AccessTokenResponse>;
-
-// Base schema for issuer registration (shared fields without refinements)
-const BaseRegisterIssuerFields = BaseAuthBody.extend({
-  confirmPassword: PasswordSchema,
-  accountName: z
-    .string()
-    .min(1)
-    .max(150)
-    .openapi({
-      example: 'Example Account',
-    })
-    .nullable()
-    .optional(),
-  accountType: z
-    .nativeEnum(ManagedByType)
-    .optional()
-    .default(ManagedByType.DALMORE)
-    .openapi({
-      example: ManagedByType.DALMORE,
-    }),
-});
-
-// Full issuer registration schema with code (for invite-based registration)
-export const IRegisterIssuerBodyZod = BaseRegisterIssuerFields.extend({
-  code: z
-    .string()
-    .refine(isBase64, {
-      message: 'Must be a valid base64 encoded string',
-    })
-    .optional()
-    .openapi({
-      example: 'eyJpdiI6InhhTFIyVG9ETnhnUzQ1QzUyNzRJenc9PSIsI',
-    }),
-})
-  .refine((data) => data.password === data.confirmPassword, {
-    message: 'Passwords do not match',
-    path: ['confirmPassword'],
-  })
-  .refine(
-    (data) => {
-      // If code is not provided, accountName must be present and not empty/null
-      if (!data.code || data.code.length === 0) {
-        return (
-          data.accountName !== null &&
-          data.accountName !== undefined &&
-          data.accountName !== ''
-        );
-      }
-      // If code is provided, accountName is not required
-      return true;
-    },
-    {
-      message: 'Account name is required if code is not provided',
-      path: ['accountName'],
-    },
-  );
-
-// Client issuer registration schema without code (for API key registration)
-export const IRegisterClientIssuerBodyZod = BaseRegisterIssuerFields.refine(
-  (data) => data.password === data.confirmPassword,
-  {
-    message: 'Passwords do not match',
-    path: ['confirmPassword'],
-  },
-).refine(
-  (data) => {
-    // For client registration, accountName is always required
-    return (
-      data.accountName !== null &&
-      data.accountName !== undefined &&
-      data.accountName !== ''
-    );
-  },
-  {
-    message: 'Account name is required',
-    path: ['accountName'],
-  },
-);
-
-// Investors are a special case in which they require phone number at the time of registration
-// The phone number provided here is NOT validated and will still need to go thru the regular 2FA setup process
-export const RegisterBodyInvestors = BaseAuthBody.extend({
-  confirmPassword: PasswordSchema,
-  phoneNumber: PhoneZodSchema.openapi({ example: '+12124567890' }).optional(),
-  site: z
-    .string()
-    .min(2, 'site is less than 2 characters')
-    .max(253, 'site is more than 253 characters')
-    .openapi({
-      example: 'func.co',
-    }),
-}).refine((data) => data.password === data.confirmPassword, {
-  message: 'Passwords do not match',
-  path: ['confirmPassword'],
-});
-
-export const ResetPasswordVerifyBody = z.object({
-  email: z.string().email(),
-  code: z.string().length(6, 'code is not 6 characters').openapi({
-    example: '123456',
-  }),
-});
-
-export type ResetPasswordVerifyBodyType = z.infer<
-  typeof ResetPasswordVerifyBody
->;
-export const ResetPasswordVerifyResponse = z.object({
-  valid: z.boolean(),
-});
-
-export type ResetPasswordVerifyResponseType = z.infer<
-  typeof ResetPasswordVerifyResponse
->;
-
-export const ResetPasswordBody = z.object({
-  email: z.string().email(),
-  code: z.string().length(6, 'code is not 6 characters').openapi({
-    example: '123456',
-  }),
-  password: PasswordSchema,
-});
-export type ResetPasswordBodyType = z.infer<typeof ResetPasswordBody>;
-
-export const AuthSuccessResponse = z.object({
-  success: z.boolean(),
-});
-export type AuthSuccessResponseType = z.infer<typeof AuthSuccessResponse>;
-
-export const ClientAuthSuccessResponse = z.object({
-  userId: z.string().openapi({ example: 'user_01je6ht4b8fbmttkzh2hs82xqp' }),
-});
-
-export type ClientAuthSuccessResponse = z.infer<
-  typeof ClientAuthSuccessResponse
->;
-
-export const AdminForgotPasswordRequestZod = z.object({
-  email: z.string().email(),
-  portal: z.nativeEnum(PortalType),
-});
-export type AdminForgotPasswordRequestZod = z.infer<
-  typeof AdminForgotPasswordRequestZod
->;
-
-export const InvestorForgotPasswordRequestZod = z.object({
-  email: z.string().email(),
-  url: createUrlSchema({ strict: true }),
-});
-export type InvestorForgotPasswordRequestZod = z.infer<
-  typeof InvestorForgotPasswordRequestZod
->;
-
-// Define paths that should be accessible EVEN with twoFactorPending
-export const twoFactorPendingAllowedPaths = [
-  '/auth/login',
-  '/auth/register',
-  '/user-settings/valid-phone-number',
-  '/user-settings/setup-phone-number',
-  '/user-settings/verify-phone-number',
-  '/user-settings/send-verification-code',
-  '/user-settings/setup-authenticator',
-  '/user-settings/verify-authenticator',
-];
-
-export const lockedUserAllowedPathsAndMethods = [
-  { path: '/users/me', method: 'GET' },
-  { path: '/auth/login', method: 'POST' },
-];

package/common/types/batch-jobs.types.ts

@@ -1,151 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-import { z } from 'zod';
-import { dateSchema, IPaginationMeta, UserRole } from './common.types';
-import { userIdSchema } from './user.types';
-import { accountIdSchema } from './account.types';
-import { IBaseEntity } from './entity.types';
-import { JobsOptions } from 'bullmq';
-
-extendZodWithOpenApi(z);
-
-export enum JobTaskType {
-  BULK_TRADE_APPROVAL = 'BULK_TRADE_APPROVAL',
-  SINGLE_TRADE_APPROVAL = 'SINGLE_TRADE_APPROVAL',
-  BULK_TRADE_REJECTION = 'BULK_TRADE_REJECTION',
-  SINGLE_TRADE_REJECTION = 'SINGLE_TRADE_REJECTION',
-  BULK_COMPLIANCE_REVIEW = 'BULK_COMPLIANCE_REVIEW',
-  BULK_EXCHANGE_IMPORT = 'BULK_EXCHANGE_IMPORT',
-  VALIDATE_PLACED_TRADES = 'VALIDATE_PLACED_TRADES',
-  IMPORT_FUNDING_CHECK = 'IMPORT_FUNDING_CHECK',
-  REG_D_TRADE_PROCESSING = 'REG_D_TRADE_PROCESSING',
-  BULK_FILE_REPROCESSING = 'BULK_FILE_REPROCESSING',
-}
-
-export enum BatchJobStatus {
-  PENDING = 'PENDING',
-  IN_PROGRESS = 'IN_PROGRESS',
-  COMPLETED = 'COMPLETED',
-  FAILED = 'FAILED',
-  CANCELLED = 'CANCELLED',
-  KILLED = 'KILLED',
-}
-
-export const batchJobIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'batch_job';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid batch job ID format. Must be a valid TypeID with "batch_job" prefix.',
-  },
-);
-
-export const CreateBatchJobZod = z.object({
-  jobTaskType: z.nativeEnum(JobTaskType),
-  totalTasks: z.number().int(),
-  bullFlowId: z.string(),
-  userId: userIdSchema,
-  accountId: accountIdSchema,
-});
-export type CreateBatchJobZod = z.infer<typeof CreateBatchJobZod>;
-
-export const BatchJobZod = IBaseEntity.extend({
-  id: batchJobIdSchema,
-  jobTaskType: z.nativeEnum(JobTaskType),
-  totalTasks: z.number().int(),
-  bullFlowId: z.string(),
-  userId: userIdSchema,
-  accountId: accountIdSchema,
-  status: z.nativeEnum(BatchJobStatus),
-  tasksPending: z.number().int(),
-  tasksProcessing: z.number().int(),
-  tasksCompleted: z.number().int(),
-  tasksFailed: z.number().int(),
-});
-export type BatchJobZod = z.infer<typeof BatchJobZod>;
-export const IPaginatedBatchJob = z.object({
-  items: z.array(BatchJobZod),
-  meta: IPaginationMeta,
-});
-export type IPaginatedBatchJob = z.infer<typeof IPaginatedBatchJob>;
-
-export const BatchJobFiltersZod = z.object({
-  search: z.string().optional(),
-  jobTaskType: z.nativeEnum(JobTaskType).optional(),
-  status: z.nativeEnum(BatchJobStatus).optional(),
-  accountId: accountIdSchema.optional(),
-  userId: userIdSchema.optional(),
-  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
-  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
-});
-export type BatchJobFiltersZod = z.infer<typeof BatchJobFiltersZod>;
-const batchJobsInclude = z.enum(['user', 'account', 'jobItems']);
-
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(AccountsIncludeQuery),
- */
-export const BatchJobsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          batchJobsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${batchJobsInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${batchJobsInclude.options.join(',')}`,
-    }),
-});
-export interface BatchJobsIncludeQuery
-  extends z.infer<typeof BatchJobsIncludeQuery> {}
-
-export interface ChildJobConfig {
-  name: string;
-  queueName: string;
-  data: ChildJobData;
-  opts: JobsOptions;
-}
-
-export const ChildJobData = z.object({
-  batchJobId: z.string(),
-  targetId: z.string(),
-  userId: z.string(),
-  userAccountId: z.string(),
-  userFirstName: z.string().optional(),
-  userLastName: z.string().optional(),
-  userRoleId: z.string().optional(),
-  userRole: z.nativeEnum(UserRole).optional(),
-});
-export type ChildJobData = z.infer<typeof ChildJobData>;
-
-export const BatchJobData = z.object({
-  taskType: z.nativeEnum(JobTaskType),
-  props: z.record(z.string(), z.any()),
-});
-export type BatchJobData = z.infer<typeof BatchJobData>;
-
-export const BatchJobResult = z.object({
-  success: z.boolean(),
-  message: z.string(),
-  jobId: z.string().nullable().optional(),
-});
-export type BatchJobResult = z.infer<typeof BatchJobResult>;
-
-export interface BatchJobConfig {
-  data: BatchJobData;
-  childConfigs: (childData: ChildJobData) => ChildJobConfig[];
-  opts: JobsOptions;
-}

package/common/types/bonus-tier.types.ts

@@ -1,147 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-import { z } from 'zod';
-import { IBaseEntity } from './entity.types';
-import { assetIdSchema, IAsset } from './asset.types';
-import { AccountZod } from './common.types';
-import { accountIdSchema } from './account.types';
-
-extendZodWithOpenApi(z);
-
-export const bonusTierIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'bonus_tier';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message: `Invalid bonus tier ID format. Must be a valid TypeID with "bonus_tier" prefix. Example: bonus_tier_01j5y5ghx5fg68d663j1fvy2x7`,
-  },
-);
-
-export enum BonusType {
-  PERCENTAGE = 'PERCENTAGE',
-  FIXED = 'FIXED',
-}
-
-export const bonusTiersInclude = z.enum(['account', 'asset']);
-
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(BonusTiersIncludeQuery),
- */
-export const BonusTiersIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          bonusTiersInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${bonusTiersInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${bonusTiersInclude.options.join(',')}`,
-    }),
-});
-
-export const IBonusTier = IBaseEntity.extend({
-  assetId: z.lazy(() => assetIdSchema),
-  asset: z.lazy(() => IAsset),
-  accountId: z.lazy(() => accountIdSchema),
-  account: z.lazy(() => AccountZod),
-  order: z.number(),
-  type: z.nativeEnum(BonusType),
-  value: z.number(),
-  startValue: z.number().nullable(),
-  endValue: z.number().nullable(),
-  startAmount: z.number().nullable(),
-  endAmount: z.number().nullable(),
-});
-
-export const IBonusTierList = z.array(IBonusTier);
-export type IBonusTierList = z.infer<typeof IBonusTierList>;
-
-export const EstimateBonusTierCalculationZod = z
-  .object({
-    assetId: assetIdSchema
-      .optional()
-      .openapi({ example: 'asset_00041061050r3gg28a1c60t3gf' }),
-    bonusTierId: bonusTierIdSchema.optional().openapi({
-      example: 'bonus_tier_01j5y5ghx5fg68d663j1fvy2x7',
-    }),
-    type: z.nativeEnum(BonusType).openapi({ example: BonusType.PERCENTAGE }),
-    value: z.number().positive().int().openapi({ example: 50 }),
-    startAmount: z.number().positive().openapi({ example: 100 }),
-    endAmount: z.number().positive().openapi({ example: 200 }),
-    pricePerShare: z.number().positive().openapi({ example: 100 }),
-  })
-  .refine(
-    (data) => {
-      if (data.type === BonusType.PERCENTAGE) {
-        return data.value <= 100;
-      }
-      return true;
-    },
-    {
-      message: 'Value must be less than or equal to 100 for percentage type',
-    },
-  );
-export type EstimateBonusTierCalculationZod = z.infer<
-  typeof EstimateBonusTierCalculationZod
->;
-
-export const EstimateBonusTierCalculationResponseZod = z.object({
-  bonusTierId: bonusTierIdSchema
-    .nullable()
-    .openapi({ example: 'bonus_tier_01j5y5ghx5fg68d663j1fvy2x7' }),
-  assetId: assetIdSchema
-    .nullable()
-    .openapi({ example: 'asset_00041061050r3gg28a1c60t3gf' }),
-  type: z
-    .nativeEnum(BonusType)
-    .nullable()
-    .openapi({ example: BonusType.PERCENTAGE }),
-  startValue: z.number().openapi({ example: 100 }),
-  endValue: z.number().openapi({ example: 200 }),
-});
-
-export type EstimateBonusTierCalculationResponseZod = z.infer<
-  typeof EstimateBonusTierCalculationResponseZod
->;
-export type IBonusTier = z.infer<typeof IBonusTier>;
-export const BonusTierListZod = z
-  .array(
-    z.object({
-      type: z.nativeEnum(BonusType).openapi({ example: BonusType.PERCENTAGE }),
-      value: z.number().positive().int().max(1000000).openapi({ example: 50 }),
-      startAmount: z.number().max(999999999).openapi({ example: 100 }),
-      endAmount: z.number().max(999999999).openapi({ example: 200 }),
-    }),
-  )
-  .min(1, { message: 'At least one bonus tier is required' });
-export type BonusTierListZod = z.infer<typeof BonusTierListZod>;
-
-export const PostBonusTierZod = z.object({
-  assetId: assetIdSchema.openapi({
-    example: 'asset_00041061050r3gg28a1c60t3gf',
-  }),
-  bonusTiers: BonusTierListZod,
-});
-
-export type PostBonusTierZod = z.infer<typeof PostBonusTierZod>;
-
-export const CompliancePostBonusTierZod = PostBonusTierZod.extend({
-  accountId: accountIdSchema,
-});
-
-export type CompliancePostBonusTierZod = z.infer<
-  typeof CompliancePostBonusTierZod
->;

package/common/types/cart.types.ts

@@ -1,18 +0,0 @@
-import { z } from 'zod';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TradeStatus } from './common.types';
-import { investorAccountIdSchema } from './investor-account.types';
-import { paymentMethodIdSchema } from './payment-methods.types';
-
-extendZodWithOpenApi(z);
-
-export const PlaceTradeResponse = z.object({
-  tradeStatus: z.nativeEnum(TradeStatus).optional(),
-});
-export const PlaceTradeBody = z.object({});
-
-export const PatchCartBody = z.object({
-  investorAccountId: investorAccountIdSchema.optional(),
-  paymentMethodId: paymentMethodIdSchema.optional(),
-});
-export type PatchCartBody = z.infer<typeof PatchCartBody>;