@dalmore/api-contracts 0.0.0-dev.0fb0042 → 0.0.0-dev.139a1fa

package/common/types/payment-methods.types.ts

@@ -1,298 +0,0 @@
-import { TypeID } from 'typeid-js';
-import { z } from 'zod';
-import { CountryEnumSchema } from './countries.types';
-import { userIdSchema } from './user.types';
-import { PaymentMethodType } from './common.types';
-// Re-export PaymentMethodType for backward compatibility
-export { PaymentMethodType };
-
-export const paymentMethodIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'payment_method';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message: `Invalid payment_method ID format. Must be a valid TypeID with "payment_method" prefix. Example: payment_method_01j5y5ghx5fg68d663j1fvy2x7`,
-  },
-);
-
-export enum PaymentMethodProvider {
-  STRIPE = 'STRIPE',
-  PLAID = 'PLAID',
-  OTHER = 'OTHER',
-}
-export enum PaymentMethodStatus {
-  PENDING = 'PENDING',
-  VERIFIED = 'VERIFIED',
-  CANCELLED = 'CANCELLED',
-  ERRORED = 'ERRORED',
-}
-
-// https://docs.stripe.com/api/setup_intents/create
-// https://docs.stripe.com/api/payment_methods/object#payment_method_object-type
-export enum SetupIntentPaymentMethodType {
-  card = 'card',
-  us_bank_account = 'us_bank_account',
-  ach = 'ach', // ACH is not directly supported by Stripe but we add it here to differentiate between instant bank account
-}
-
-export const PostPaymentMethod = z.object({
-  paymentMethodType: z.nativeEnum(PaymentMethodType),
-  paymentMethodProvider: z.nativeEnum(PaymentMethodProvider),
-  status: z.nativeEnum(PaymentMethodStatus).optional(),
-  clientSecret: z.string().min(1).max(255).optional(),
-  tid: z.string(),
-  name: z
-    .string()
-    .min(2, 'name is less than 2 characters')
-    .max(30, 'name is more than 30 characters'),
-  last4: z.string().length(4, 'last4 shall be 4 characters'),
-  brand: z
-    .string()
-    .min(2, 'brand is less than 2 characters')
-    .max(30, 'brand is more than 30 characters')
-    .optional(),
-  country: CountryEnumSchema.optional(),
-});
-export type PostPaymentMethod = z.infer<typeof PostPaymentMethod>;
-
-export const PostProviderPaymentMethod = z.object({
-  providerPaymentMethodId: z.string(),
-  paymentMethodType: z.enum([PaymentMethodType.BANK_ACCOUNT]),
-  clientSecret: z.string(),
-});
-export type PostProviderPaymentMethod = z.infer<
-  typeof PostProviderPaymentMethod
->;
-
-export const CompliancePostPaymentMethod = PostPaymentMethod.omit({
-  tid: true,
-}).extend({
-  tid: z.string().optional(),
-  userId: z.lazy(() => userIdSchema),
-});
-
-export const UpdatePaymentMethod = z.object({
-  paymentMethodType: z.nativeEnum(PaymentMethodType).optional(),
-  paymentMethodProvider: z.nativeEnum(PaymentMethodProvider).optional(),
-  status: z.nativeEnum(PaymentMethodStatus).optional(),
-  clientSecret: z.string().min(1).max(255).optional(),
-  tid: z.string().optional(),
-  name: z
-    .string()
-    .min(2, 'name is less than 2 characters')
-    .max(30, 'name is more than 30 characters')
-    .optional(),
-  last4: z.string().length(4, 'last4 shall be 4 characters').optional(),
-  brand: z
-    .string()
-    .min(2, 'brand is less than 2 characters')
-    .max(30, 'brand is more than 30 characters')
-    .optional(),
-  country: CountryEnumSchema.optional(),
-});
-
-export const PaymentMethodFilterQuery = z.object({
-  userId: z.lazy(() => userIdSchema).optional(),
-});
-export type PaymentMethodFilterQuery = z.infer<typeof PaymentMethodFilterQuery>;
-
-export const PaymentMethodResponse = z.object({
-  id: paymentMethodIdSchema,
-  paymentMethodType: z.nativeEnum(PaymentMethodType),
-  paymentMethodProvider: z.nativeEnum(PaymentMethodProvider),
-  status: z.nativeEnum(PaymentMethodStatus),
-  clientSecret: z.string().nullable(),
-  tid: z.string().nullable(),
-  name: z.string(),
-  last4: z.string().nullable(),
-  brand: z.string().nullable(),
-  country: z.string().nullable(),
-  userId: z.string().nullable(),
-});
-export type PaymentMethodResponse = z.infer<typeof PaymentMethodResponse>;
-export const PaymentMethodResponseArray = z.array(PaymentMethodResponse);
-
-// https://docs.stripe.com/api/payment_intents/object#payment_intent_object-status
-export enum StripePaymentIntentStatus {
-  SUCCEEDED = 'succeeded',
-  REQUIRES_PAYMENT_METHOD = 'requires_payment_method',
-  REQUIRES_CONFIRMATION = 'requires_confirmation',
-  REQUIRES_ACTION = 'requires_action',
-  REQUIRES_CAPTURE = 'requires_capture',
-  PROCESSING = 'processing',
-  CANCELED = 'canceled',
-}
-
-export const PaymentProviderResult = z.object({
-  id: z.string(),
-  amount: z.number(),
-  currency: z.string(),
-  provider: z.nativeEnum(PaymentMethodProvider),
-  created: z.date(),
-  status: z.nativeEnum(StripePaymentIntentStatus),
-});
-export type PaymentProviderResult = z.infer<typeof PaymentProviderResult>;
-
-export const PostSetupIntentBody = z.object({
-  paymentMethodType: z.nativeEnum(SetupIntentPaymentMethodType),
-});
-export type PostSetupIntentBody = z.infer<typeof PostSetupIntentBody>;
-
-export const SetupIntentResponse = z.object({
-  id: z.string(),
-  object: z.literal('setup_intent'),
-  application: z.string().nullable(),
-  cancellation_reason: z.string().nullable(),
-  client_secret: z.string(),
-  created: z.number(),
-  customer: z.string().nullable(),
-  description: z.string().nullable(),
-  flow_directions: z.string().nullable(),
-  last_setup_error: z.string().nullable(),
-  latest_attempt: z.string().nullable(),
-  livemode: z.boolean(),
-  mandate: z.string().nullable(),
-  metadata: z.record(z.any()),
-  next_action: z.string().nullable(),
-  on_behalf_of: z.string().nullable(),
-  payment_method: z.string().nullable(),
-  payment_method_options: z.object({
-    card: z.object({
-      mandate_options: z.string().nullable(),
-      network: z.string().nullable(),
-      request_three_d_secure: z.string(),
-    }),
-  }),
-  payment_method_types: z.array(z.string()),
-  single_use_mandate: z.string().nullable(),
-  status: z.string(),
-  usage: z.string(),
-});
-export type SetupIntentResponse = z.infer<typeof SetupIntentResponse>;
-
-export const StripePaymentMethod = z.object({
-  id: z.string(),
-  object: z.string(),
-  billing_details: z.object({
-    address: z.object({
-      city: z.string().nullable(),
-      country: z.string().nullable(),
-      line1: z.string().nullable(),
-      line2: z.string().nullable(),
-      postal_code: z.string().nullable(),
-      state: z.string().nullable(),
-    }),
-    email: z.string(),
-    name: z.string(),
-    phone: z.string().nullable(),
-    tax_id: z.string().nullable(),
-  }),
-  card: z
-    .object({
-      brand: z.string(),
-      checks: z.object({
-        address_line1_check: z.string().nullable(),
-        address_postal_code_check: z.string().nullable(),
-        cvc_check: z.string().nullable(),
-      }),
-      country: z.string(),
-      exp_month: z.number().nullable(),
-      exp_year: z.number().nullable(),
-      fingerprint: z.string().nullable(),
-      funding: z.string().nullable(),
-      generated_from: z.string().nullable(),
-      last4: z.string(),
-      networks: z.object({
-        available: z.array(z.string()),
-        preferred: z.string().nullable(),
-      }),
-      three_d_secure_usage: z.object({ supported: z.boolean() }),
-      wallet: z.string().nullable(),
-    })
-    .nullable(),
-  us_bank_account: z.object({
-    account_holder_type: z.string(),
-    account_type: z.string(),
-    bank_name: z.string(),
-    financial_connections_account: z.string(),
-    fingerprint: z.string(),
-    last4: z.string(),
-    networks: z.object({
-      preferred: z.string().nullable(),
-      supported: z.array(z.string()),
-    }),
-    routing_number: z.string(),
-    status_details: z.object({
-      reason: z.string().nullable(),
-    }),
-  }),
-  created: z.number(),
-  customer: z.string(),
-  livemode: z.boolean(),
-  metadata: z.object({}),
-  redaction: z.string().nullable(),
-  type: z.string(),
-});
-export type StripePaymentMethod = z.infer<typeof StripePaymentMethod>;
-
-export const StripeConnectedAccountZod = z.object({
-  id: z.string(),
-  name: z.string(),
-});
-export type StripeConnectedAccountZod = z.infer<
-  typeof StripeConnectedAccountZod
->;
-
-// Stripe Connect Account Management Types
-// https://docs.stripe.com/api/accounts/create
-export enum StripeBusinessType {
-  INDIVIDUAL = 'individual',
-  COMPANY = 'company',
-  GOVERNMENT_ENTITY = 'government_entity',
-  NON_PROFIT = 'non_profit',
-}
-
-export const CreateConnectedAccountDataZod = z.object({
-  email: z.string().email(),
-  businessType: z.nativeEnum(StripeBusinessType),
-  country: z.string().length(2).optional().default('US'),
-  companyName: z.string().optional(),
-  individualFirstName: z.string().optional(),
-  individualLastName: z.string().optional(),
-});
-
-export type CreateConnectedAccountData = z.infer<
-  typeof CreateConnectedAccountDataZod
->;
-
-export const ConnectedAccountResponseZod = z.object({
-  id: z.string(),
-  email: z.string().optional(),
-  country: z.string(),
-  business_type: z.string().optional(),
-  charges_enabled: z.boolean(),
-  payouts_enabled: z.boolean(),
-  details_submitted: z.boolean(),
-  requirements: z.object({
-    currently_due: z.array(z.string()),
-    eventually_due: z.array(z.string()),
-    past_due: z.array(z.string()),
-    disabled_reason: z.string().nullable(),
-  }),
-});
-
-export type ConnectedAccountResponse = z.infer<
-  typeof ConnectedAccountResponseZod
->;
-
-export const AccountLinkResponseZod = z.object({
-  url: z.string().url(),
-  expires_at: z.number(),
-});
-
-export type AccountLinkResponse = z.infer<typeof AccountLinkResponseZod>;

package/common/types/phone.type.ts

@@ -1,27 +0,0 @@
-import { z } from 'zod';
-import { normalizePhoneNumber } from '../helpers';
-import { CountryCodes } from './countries.types';
-import { CountryCode } from 'libphonenumber-js';
-import { ok } from 'neverthrow';
-
-export const PhoneZodSchema = z
-  .string()
-  .nullable()
-  .transform((phone) => {
-    if (phone === null || phone === '') return ok(null); // Allow null values
-    let result!: ReturnType<typeof normalizePhoneNumber>;
-    for (const code of CountryCodes) {
-      if (result && result.isOk()) break;
-      result = normalizePhoneNumber(phone, code as CountryCode);
-    }
-
-    return result;
-  })
-  .refine((result) => result.isOk(), { message: 'phone is not valid' })
-  .transform((result) => {
-    if (result.isErr()) return ''; // the condition shall always evaluate to false!, it just calms TS :)
-    const parsedPhoneNumber = result?.value;
-    if (parsedPhoneNumber === null) return '';
-    const phone = parsedPhoneNumber.number.toString();
-    return phone;
-  });

package/common/types/portfolio.types.ts

@@ -1,50 +0,0 @@
-import { z } from 'zod';
-import { AssetType, InvestorAccountType, TradeStatus } from './common.types';
-
-export const PortfolioResponse = z.object({
-  totalAmount: z.string(),
-  id: z.string(),
-  type: z.nativeEnum(InvestorAccountType),
-  name: z.string(),
-});
-
-export type PortfolioResponse = z.infer<typeof PortfolioResponse>;
-export const PortfolioResponseList = z.object({
-  totalAmount: z.number().default(0),
-  portfollios: z.array(PortfolioResponse),
-});
-export type PortfolioResponseList = z.infer<typeof PortfolioResponseList>;
-
-export const AccountPortfolio = z.object({
-  totalAmount: z.string(),
-  id: z.string(),
-  name: z.string(),
-  description: z.string().nullable(),
-  type: z.nativeEnum(AssetType),
-  accountTotalAmount: z.string(),
-  percentage: z.string(),
-});
-
-export type AccountPortfolio = z.infer<typeof AccountPortfolio>;
-
-export const AccountPortfolioResponse = z.object({
-  totalAmount: z.number().default(0),
-  portfollios: z.array(AccountPortfolio),
-});
-export type AccountPortfolioResponse = z.infer<typeof AccountPortfolioResponse>;
-
-export const TradeStatusBreakdown = z.object({
-  tradeStatus: z.nativeEnum(TradeStatus),
-  count: z.number(),
-  amount: z.number(),
-  percentage: z.string(),
-});
-export type TradeStatusBreakdown = z.infer<typeof TradeStatusBreakdown>;
-
-export const TradeStatusBreakdownResponse = z.object({
-  totalAmount: z.number(),
-  tradeStatusBreakdown: z.array(TradeStatusBreakdown),
-});
-export type TradeStatusBreakdownResponse = z.infer<
-  typeof TradeStatusBreakdownResponse
->;

package/common/types/queue.types.ts

@@ -1,112 +0,0 @@
-import { JobsOptions } from 'bullmq';
-import { typeid } from 'typeid-js';
-
-export enum QueueFrequency {
-  SUPER_HIGH_FREQUENCY = 'SUPER_HIGH_FREQUENCY',
-  HIGH_FREQUENCY = 'HIGH_FREQUENCY',
-  MEDIUM_FREQUENCY = 'MEDIUM_FREQUENCY',
-  LOW_FREQUENCY = 'LOW_FREQUENCY',
-}
-
-interface QueueOptionsConfig {
-  removeOnComplete: number;
-  removeOnFail: number;
-  attempts: number;
-  backoff: {
-    type: 'exponential' | 'fixed';
-    delay: number;
-  };
-}
-
-const FREQUENCY_CONFIGS: Record<QueueFrequency, QueueOptionsConfig> = {
-  [QueueFrequency.SUPER_HIGH_FREQUENCY]: {
-    removeOnComplete: 50,
-    removeOnFail: 25,
-    attempts: 1,
-    backoff: {
-      type: 'fixed',
-      delay: 500,
-    },
-  },
-  [QueueFrequency.HIGH_FREQUENCY]: {
-    removeOnComplete: 50,
-    removeOnFail: 25,
-    attempts: 2,
-    backoff: {
-      type: 'fixed',
-      delay: 1000,
-    },
-  },
-  [QueueFrequency.MEDIUM_FREQUENCY]: {
-    removeOnComplete: 75,
-    removeOnFail: 35,
-    attempts: 3,
-    backoff: {
-      type: 'exponential',
-      delay: 1500,
-    },
-  },
-  [QueueFrequency.LOW_FREQUENCY]: {
-    removeOnComplete: 100,
-    removeOnFail: 50,
-    attempts: 3,
-    backoff: {
-      type: 'exponential',
-      delay: 2000,
-    },
-  },
-};
-
-/**
- * Creates standardized BullMQ job options based on frequency and job ID
- * @param jobId - Unique identifier for the job (for deduplication)
- * @param frequency - Queue frequency level (defaults to LOW_FREQUENCY)
- * @param customOptions - Optional custom options to override defaults
- * @returns JobsOptions for BullMQ
- */
-export function createQueueJobOptions(
-  jobId?: string,
-  frequency: QueueFrequency = QueueFrequency.LOW_FREQUENCY,
-  customOptions?: Partial<JobsOptions>,
-): JobsOptions {
-  const config = FREQUENCY_CONFIGS[frequency];
-  const finalJobId = jobId || typeid('job').toString();
-
-  return {
-    jobId: finalJobId,
-    removeOnComplete: config.removeOnComplete,
-    removeOnFail: config.removeOnFail,
-    attempts: config.attempts,
-    backoff: config.backoff,
-    ...customOptions,
-  };
-}
-
-/**
- * Convenience functions for each frequency level
- */
-export const createSuperHighFrequencyJobOptions = (
-  jobId?: string,
-  customOptions?: Partial<JobsOptions>,
-) =>
-  createQueueJobOptions(
-    jobId,
-    QueueFrequency.SUPER_HIGH_FREQUENCY,
-    customOptions,
-  );
-
-export const createHighFrequencyJobOptions = (
-  jobId?: string,
-  customOptions?: Partial<JobsOptions>,
-) => createQueueJobOptions(jobId, QueueFrequency.HIGH_FREQUENCY, customOptions);
-
-export const createMediumFrequencyJobOptions = (
-  jobId?: string,
-  customOptions?: Partial<JobsOptions>,
-) =>
-  createQueueJobOptions(jobId, QueueFrequency.MEDIUM_FREQUENCY, customOptions);
-
-export const createLowFrequencyJobOptions = (
-  jobId?: string,
-  customOptions?: Partial<JobsOptions>,
-) => createQueueJobOptions(jobId, QueueFrequency.LOW_FREQUENCY, customOptions);

package/common/types/registered-reps.types.ts

@@ -1,25 +0,0 @@
-import { z } from 'zod';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-
-extendZodWithOpenApi(z);
-
-export enum CommissionRateType {
-  FIXED = 'FIXED',
-  PERCENTAGE = 'PERCENTAGE',
-}
-
-export const registeredRepIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'registered_rep';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid registered rep ID format. Must be a valid TypeID with "registered_rep" prefix. Example: registered_rep_01j5y5ghx8fvc83dmx3pznq7hv',
-  },
-);

package/common/types/rejection-reasons.types.ts

@@ -1,56 +0,0 @@
-import { IBaseEntity } from './entity.types';
-
-import { TypeID } from 'typeid-js';
-import { z } from 'zod';
-
-export const RejectionReasons = {
-  KYC: [
-    'ID document is expired',
-    'ID photo is blurry or unclear',
-    'ID does not match applicant’s name',
-    'Document type not accepted',
-    'Incomplete or missing ID submission',
-  ],
-  AML: [
-    'Missing supporting financial documents',
-    'Income documentation not sufficient',
-    'CPA/Attorney letter is outdated or unsigned',
-    'Documents do not meet accreditation criteria',
-  ],
-  AIC: [
-    'Individual appears on a sanctions list',
-    'Match found in politically exposed persons (PEP) database',
-    'Potential adverse media found',
-    'High-risk jurisdiction flagged',
-    'Name match flagged – additional verification required',
-  ],
-  SUB_DOC: [
-    'Signature missing or incorrect',
-    'Incomplete or incorrectly filled document',
-    'Document version is outdated',
-    'Not all pages were submitted',
-    'Mismatch in investment amount',
-  ],
-};
-
-export const rejectionReasonIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'rejection_reason';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid rejection reason ID format. Must be a valid TypeID with "rejection_reason" prefix.',
-  },
-);
-
-export const RejectionReasonZod = IBaseEntity.extend({
-  id: z.string(),
-  reason: z.string(),
-  target: z.string(),
-});
-export type RejectionReasonZod = z.infer<typeof RejectionReasonZod>;

package/common/types/reminder-config.types.ts

@@ -1,40 +0,0 @@
-import { Job } from 'bullmq';
-import { QueryRunner } from 'typeorm';
-import { Site } from '../../sites/entities/site.entity';
-import { ProcessTradeCancellationReminderDto } from '../../workers/dto.worker';
-
-export enum ReminderType {
-  DAILY = 'daily',
-  CUMULATIVE = 'cumulative',
-  WARNING = 'warning',
-  CANCEL = 'cancel',
-  SKIP = 'skip', // for days with no action
-}
-
-export interface ReminderConfig {
-  day: number;
-  type: ReminderType;
-  daysLeft?: number; // for warning type
-  createTask?: boolean; // for daily type
-  priority?: 'low' | 'medium' | 'high' | 'urgent';
-}
-
-export interface ReminderTemplate {
-  subject: (params: ReminderTemplateParams) => string;
-  description: (params: ReminderTemplateParams) => string;
-}
-
-export interface ReminderTemplateParams {
-  day: number;
-  offeringName: string;
-  daysLeft?: number;
-  userName: string;
-  tradeStatus: string;
-}
-
-export interface ReminderContext {
-  queryRunner: QueryRunner;
-  job: Job<ProcessTradeCancellationReminderDto>;
-  site: Site;
-  logContext: any;
-}