@dalmore/api-contracts 1.0.3 → 1.0.6

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/queue.types.ts

@@ -1,3 +1,4 @@
+import { JobsOptions } from 'bullmq';
 import { typeid } from 'typeid-js';
 
 export enum QueueFrequency {

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

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

package/src/common/types/site-link.types.spec.ts

@@ -0,0 +1,134 @@
+import {
+  SiteLinkType,
+  PostSiteLinkZod,
+  createSocialMediaUrlSchema,
+} from './site-link.types';
+
+describe('PostSiteLinkZod', () => {
+  it('should validate a valid Facebook link', () => {
+    const validData = {
+      type: SiteLinkType.FACEBOOK,
+      url: 'https://facebook.com/validpage',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a valid LinkedIn link', () => {
+    const validData = {
+      type: SiteLinkType.LINKEDIN,
+      url: 'https://linkedin.com/in/validprofile',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a valid Twitter link', () => {
+    const validData = {
+      type: SiteLinkType.TWITTER,
+      url: 'https://twitter.com/validhandle',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate when url is null', () => {
+    const validData = {
+      type: SiteLinkType.FACEBOOK,
+      url: null,
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate when url is undefined', () => {
+    const validData = {
+      type: SiteLinkType.FACEBOOK,
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a WEBSITE type with any valid URL', () => {
+    const validData = {
+      type: SiteLinkType.WEBSITE,
+      url: 'https://example.com',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate an OTHER type with any valid URL', () => {
+    const validData = {
+      type: SiteLinkType.OTHER,
+      url: 'https://example.org',
+    };
+
+    const result = PostSiteLinkZod.safeParse(validData);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject an invalid Facebook URL', () => {
+    const invalidData = {
+      type: SiteLinkType.FACEBOOK,
+      url: 'https://not-facebook.com/profile',
+    };
+
+    const result = PostSiteLinkZod.safeParse(invalidData);
+    expect(result.success).toBe(false);
+    if (!result.success) {
+      expect(result.error.issues[0]!.path).toContain('url');
+    }
+  });
+
+  it('should reject an invalid URL format', () => {
+    const invalidData = {
+      type: SiteLinkType.WEBSITE,
+      url: 'not-a-valid-url',
+    };
+
+    const result = PostSiteLinkZod.safeParse(invalidData);
+    expect(result.success).toBe(false);
+  });
+
+  it('should require type field', () => {
+    const invalidData = {
+      url: 'https://example.com',
+    };
+
+    const result = PostSiteLinkZod.safeParse(invalidData as any);
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('createSocialMediaUrlSchema', () => {
+  it('should validate a correct Facebook URL', () => {
+    const schema = createSocialMediaUrlSchema(SiteLinkType.FACEBOOK);
+    const result = schema.safeParse('https://facebook.com/validpage');
+    expect(result.success).toBe(true);
+  });
+
+  it('should validate a correct Facebook URL with www', () => {
+    const schema = createSocialMediaUrlSchema(SiteLinkType.FACEBOOK);
+    const result = schema.safeParse('https://www.facebook.com/validpage');
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject an incorrect Facebook URL', () => {
+    const schema = createSocialMediaUrlSchema(SiteLinkType.FACEBOOK);
+    const result = schema.safeParse('https://not-facebook.com/profile');
+    expect(result.success).toBe(false);
+  });
+
+  it('should handle null values', () => {
+    const schema = createSocialMediaUrlSchema(SiteLinkType.FACEBOOK);
+    const result = schema.safeParse(null);
+    expect(result.success).toBe(true);
+  });
+});

package/src/common/types/trade.types.ts

@@ -53,10 +53,8 @@ import {
   SecondaryTrade,
   SecondaryTradeFiltersZod,
 } from './secondary-trade.types';
-
-// Stub types for backend entities (not included in contracts package)
-type InvestorAccount = Record<string, unknown>;
-type Trade = Record<string, unknown>;
+import { InvestorAccount } from '../../investor-accounts/entities/investor-account.entity';
+import { Trade } from '../../trades/entities/trade.entity';
 
 extendZodWithOpenApi(z);
 export const CheckResultsSchema = z.object({