@dalmore/api-contracts 1.0.7 → 1.0.8

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

@@ -0,0 +1,298 @@
+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/src/common/types/phone.spec.ts

@@ -0,0 +1,76 @@
+import { PhoneZodSchema } from './phone.type';
+
+describe('PhoneSchema Tests', () => {
+  it('should pass if US phone is valid', () => {
+    const phone = '+1-212-456-7890';
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should pass if EG phone is valid', () => {
+    const phone = '+201088511706';
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should fail if EG phone is not valid', () => {
+    const phone = '+2010885101706';
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should fail if phone is not valid', () => {
+    const phone = '+201706';
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should not fail if phone is empty string', () => {
+    const phone = '';
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should fail if phone is too long string', () => {
+    const phone = '+125055501990001';
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should fail if phone contains letters', () => {
+    const phone = '+12505d50199';
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should pass if US phone is valid', () => {
+    const phone = '+12505550199';
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should pass if US phone is valid', () => {
+    const phone = '+12124567890';
+
+    const parseRes = PhoneZodSchema.safeParse(phone);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+});

package/src/common/types/phone.type.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { normalizePhoneNumber } from './contract-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/src/common/types/portfolio.types.ts

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