@dalmore/api-contracts 1.0.3 → 1.0.6

package/package.json

@@ -1,67 +1,19 @@
 {
   "name": "@dalmore/api-contracts",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "Type-safe API contracts for Dalmore Client Portal",
   "type": "module",
   "main": "./index.mjs",
-  "types": "./src/contracts/index.ts",
+  "types": "./src/contracts/clients/index.ts",
   "exports": {
     ".": {
-      "types": "./src/contracts/index.ts",
+      "types": "./src/contracts/clients/index.ts",
       "import": "./index.mjs",
       "default": "./index.mjs"
-    },
-    "./compliance": {
-      "types": "./src/contracts/compliance/index.ts",
-      "import": "./compliance/index.mjs",
-      "default": "./compliance/index.mjs"
-    },
-    "./investors": {
-      "types": "./src/contracts/investors/index.ts",
-      "import": "./investors/index.mjs",
-      "default": "./investors/index.mjs"
-    },
-    "./issuers": {
-      "types": "./src/contracts/issuers/index.ts",
-      "import": "./issuers/index.mjs",
-      "default": "./issuers/index.mjs"
-    },
-    "./clients": {
-      "types": "./src/contracts/clients/index.ts",
-      "import": "./clients/index.mjs",
-      "default": "./clients/index.mjs"
-    },
-    "./secondaries": {
-      "types": "./src/contracts/secondaries/index.ts",
-      "import": "./secondaries/index.mjs",
-      "default": "./secondaries/index.mjs"
-    },
-    "./compliance-apikey": {
-      "types": "./src/contracts/compliance-apikey/index.ts",
-      "import": "./compliance-apikey/index.mjs",
-      "default": "./compliance-apikey/index.mjs"
-    },
-    "./types": {
-      "types": "./src/common/types/index.ts",
-      "import": "./types/index.mjs",
-      "default": "./types/index.mjs"
-    },
-    "./helpers": {
-      "types": "./src/common/helpers/index.ts",
-      "import": "./helpers/index.mjs",
-      "default": "./helpers/index.mjs"
     }
   },
   "files": [
-    "*.mjs",
-    "compliance",
-    "investors",
-    "issuers",
-    "clients",
-    "secondaries",
-    "compliance-apikey",
-    "types",
-    "helpers",
+    "index.mjs",
     "src"
   ],
   "keywords": [
@@ -90,6 +42,6 @@
     "zod": "^3.24.4"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=24.0.0 <25.0.0"
   }
 }

package/src/common/types/address.spec.ts

@@ -0,0 +1,203 @@
+import { createAddress } from '../../tests/factory/address.factory';
+import { AddressSchema } from './address.types';
+
+describe('AddressSchema Tests', () => {
+  it('should fail if counry is not valid', () => {
+    const address = createAddress({
+      country: 'eg',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should succeed if counry is valid', () => {
+    const address = createAddress({
+      country: 'CA',
+      zip: 'A1A 1A1',
+      state: 'AB',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should fail if CANADA state is not valid', () => {
+    const address = createAddress({
+      country: 'CA',
+      zip: 'A1A 1A1',
+      state: 'AS',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should succeed if CANADA state is valid', () => {
+    const address = createAddress({
+      country: 'CA',
+      zip: 'A1A 1A1',
+      state: 'AB',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should fail if CANADA state is not valid', () => {
+    const address = createAddress({
+      country: 'CA',
+      zip: '12345',
+      state: 'AS',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should succeed if CANADA zip is valid', () => {
+    const address = createAddress({
+      country: 'CA',
+      zip: 'A1A 1A1',
+      state: 'AB',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should fail if US state is not valid', () => {
+    const address = createAddress({
+      country: 'US',
+      zip: '12345',
+      state: 'CS',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should succeed if US state is valid', () => {
+    const address = createAddress({
+      country: 'US',
+      zip: '12345',
+      state: 'CA',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should fail if US zip is not valid', () => {
+    const address = createAddress({
+      country: 'US',
+      zip: '12345 d',
+      state: 'CS',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should succeed if US zip is valid', () => {
+    const address = createAddress({
+      country: 'US',
+      zip: '12345',
+      state: 'CA',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should fail if state is not valid, state(min=2,max=35)', () => {
+    const address = createAddress({
+      country: 'EG',
+      zip: '12345',
+      state: 'Alex Cairo Tanta Hurgada Dahb Luxor Aswan Sharm ', // length 48
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should fail if state is not valid', () => {
+    const address = createAddress({
+      country: 'EG',
+      zip: '12345',
+      state: 'A',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should succeed if state is valid', () => {
+    const address = createAddress({
+      country: 'EG',
+      zip: '12345',
+      state: 'Alexandria',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should fail if zip is not valid', () => {
+    const address = createAddress({
+      country: 'EG',
+      zip: '1',
+      state: 'Cairo',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeFalsy();
+  });
+
+  it('should succeed if zip is valid', () => {
+    const address = createAddress({
+      country: 'EG',
+      zip: '12345678',
+      state: 'Cairo',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should succeed if zip is optional', () => {
+    const address = createAddress({
+      country: 'EG',
+      state: 'Cairo',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+
+  it('should succeed if state is optional', () => {
+    const address = createAddress({
+      country: 'EG',
+    });
+    const parseRes = AddressSchema.safeParse(address);
+
+    const result = parseRes.success;
+    expect(result).toBeTruthy();
+  });
+});

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

@@ -5,6 +5,7 @@ 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);
 

package/src/common/types/common.types.spec.ts

@@ -0,0 +1,336 @@
+import { PaginationOptionsZod, numberPrecisionSchema } from './common.types';
+import { z } from 'zod';
+
+describe('PaginationOptionsZod', () => {
+  it('should use default values when no values are provided', () => {
+    const result = PaginationOptionsZod.parse({});
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should use provided values when they are valid', () => {
+    const result = PaginationOptionsZod.parse({ page: 2, limit: 20 });
+    expect(result).toEqual({ page: 2, limit: 20 });
+  });
+
+  it('should transform page 0 to page 1', () => {
+    const result = PaginationOptionsZod.parse({ page: 0 });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should transform limit 0 to limit 10', () => {
+    const result = PaginationOptionsZod.parse({ limit: 0 });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should coerce string values to numbers', () => {
+    const result = PaginationOptionsZod.parse({ page: '3', limit: '15' });
+    expect(result).toEqual({ page: 3, limit: 15 });
+  });
+
+  it('should handle negative values without transformation', () => {
+    const result = PaginationOptionsZod.parse({ page: -1, limit: -5 });
+    expect(result).toEqual({ page: -1, limit: -5 });
+  });
+
+  it('should handle decimal values', () => {
+    const result = PaginationOptionsZod.parse({ page: 2.5, limit: 15.7 });
+    expect(result).toEqual({ page: 2.5, limit: 15.7 });
+  });
+
+  it('should throw an error for non-numeric string values', () => {
+    expect(() => {
+      PaginationOptionsZod.parse({ page: 'abc' });
+    }).toThrow();
+  });
+
+  it('should accept empty string values and convert them to defaults', () => {
+    const result = PaginationOptionsZod.parse({ page: '' });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should accept undefined values and use defaults', () => {
+    const result = PaginationOptionsZod.parse({ page: undefined });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should handle null values by using defaults', () => {
+    const result = PaginationOptionsZod.parse({ page: null, limit: null });
+    expect(result).toEqual({ page: 1, limit: 10 });
+  });
+
+  it('should handle objects with extra properties', () => {
+    const result = PaginationOptionsZod.parse({
+      page: 5,
+      limit: 25,
+      sort: 'asc',
+      filter: 'active',
+    });
+    expect(result).toEqual({ page: 5, limit: 25 });
+  });
+
+  it('should handle string numbers with leading zeros', () => {
+    const result = PaginationOptionsZod.parse({ page: '01', limit: '05' });
+    expect(result).toEqual({ page: 1, limit: 5 });
+  });
+
+  it('should handle exponential notation', () => {
+    const result = PaginationOptionsZod.parse({ page: 1e2, limit: 1e1 });
+    expect(result).toEqual({ page: 100, limit: 10 });
+  });
+});
+
+describe('numberPrecisionSchema', () => {
+  describe('default precision (2 decimal places)', () => {
+    it('should transform numbers with more than 2 decimal places', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(123.456)).toBe(123.46);
+      expect(schema.parse(123.456789)).toBe(123.46);
+      expect(schema.parse(0.999)).toBe(1.0);
+    });
+
+    it('should keep numbers with exactly 2 decimal places unchanged', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(123.45)).toBe(123.45);
+      expect(schema.parse(0.99)).toBe(0.99);
+      expect(schema.parse(1000.0)).toBe(1000.0);
+    });
+
+    it('should pad numbers with fewer than 2 decimal places', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(123.4)).toBe(123.4);
+      expect(schema.parse(123)).toBe(123.0);
+      expect(schema.parse(0.5)).toBe(0.5);
+    });
+
+    it('should handle whole numbers', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(100)).toBe(100.0);
+      expect(schema.parse(0)).toBe(0.0);
+      expect(schema.parse(999)).toBe(999.0);
+    });
+
+    it('should handle negative numbers', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(-123.456)).toBe(-123.46);
+      expect(schema.parse(-123.45)).toBe(-123.45);
+      expect(schema.parse(-100)).toBe(-100.0);
+    });
+
+    it('should handle zero', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(0)).toBe(0.0);
+      expect(schema.parse(0.0)).toBe(0.0);
+      expect(schema.parse(0.001)).toBe(0.0);
+    });
+
+    it('should handle very small numbers', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(0.001)).toBe(0.0);
+      expect(schema.parse(0.004)).toBe(0.0);
+      expect(schema.parse(0.005)).toBe(0.01);
+      expect(schema.parse(0.015)).toBe(0.02);
+    });
+
+    it('should handle very large numbers', () => {
+      const schema = numberPrecisionSchema();
+      expect(schema.parse(999999999.123456)).toBe(999999999.12);
+      expect(schema.parse(1234567890.99)).toBe(1234567890.99);
+    });
+
+    it('should handle numbers with floating point precision issues', () => {
+      const schema = numberPrecisionSchema();
+      // Common floating point issue: 0.1 + 0.2 = 0.30000000000000004
+      expect(schema.parse(0.1 + 0.2)).toBe(0.3);
+      expect(schema.parse(0.1 + 0.7)).toBe(0.8);
+    });
+  });
+
+  describe('custom precision values', () => {
+    it('should work with precision 0 (whole numbers)', () => {
+      const schema = numberPrecisionSchema(0);
+      expect(schema.parse(123.456)).toBe(123);
+      expect(schema.parse(123.5)).toBe(124);
+      expect(schema.parse(123.4)).toBe(123);
+      expect(schema.parse(0.9)).toBe(1);
+    });
+
+    it('should work with precision 1', () => {
+      const schema = numberPrecisionSchema(1);
+      expect(schema.parse(123.45)).toBe(123.5);
+      expect(schema.parse(123.44)).toBe(123.4);
+      expect(schema.parse(123.456)).toBe(123.5);
+    });
+
+    it('should work with precision 3', () => {
+      const schema = numberPrecisionSchema(3);
+      expect(schema.parse(123.4567)).toBe(123.457);
+      expect(schema.parse(123.456)).toBe(123.456);
+      expect(schema.parse(123.4)).toBe(123.4);
+    });
+
+    it('should work with precision 4', () => {
+      const schema = numberPrecisionSchema(4);
+      expect(schema.parse(123.45678)).toBe(123.4568);
+      expect(schema.parse(123.4567)).toBe(123.4567);
+      expect(schema.parse(123.4)).toBe(123.4);
+    });
+
+    it('should work with precision 6', () => {
+      const schema = numberPrecisionSchema(6);
+      expect(schema.parse(123.4567890123)).toBe(123.456789);
+      expect(schema.parse(123.456789)).toBe(123.456789);
+    });
+  });
+
+  describe('with base schema constraints', () => {
+    it('should apply positive constraint', () => {
+      const schema = numberPrecisionSchema(2, z.number().positive());
+      expect(schema.parse(123.456)).toBe(123.46);
+      expect(() => schema.parse(-123.456)).toThrow();
+      expect(() => schema.parse(0)).toThrow();
+    });
+
+    it('should apply max constraint', () => {
+      const schema = numberPrecisionSchema(2, z.number().max(1000));
+      expect(schema.parse(999.99)).toBe(999.99);
+      expect(schema.parse(1000.0)).toBe(1000.0);
+      expect(() => schema.parse(1000.01)).toThrow();
+    });
+
+    it('should apply min constraint', () => {
+      const schema = numberPrecisionSchema(2, z.number().min(0.01));
+      expect(schema.parse(0.01)).toBe(0.01);
+      expect(schema.parse(0.015)).toBe(0.02);
+      expect(() => schema.parse(0.005)).toThrow();
+    });
+
+    it('should apply multiple constraints', () => {
+      const schema = numberPrecisionSchema(
+        2,
+        z.number().positive().min(0.01).max(999999999),
+      );
+      expect(schema.parse(500.99)).toBe(500.99);
+      expect(schema.parse(0.015)).toBe(0.02);
+      expect(() => schema.parse(-100)).toThrow();
+      expect(() => schema.parse(0.005)).toThrow();
+      expect(() => schema.parse(1000000000)).toThrow();
+    });
+  });
+
+  describe('rounding behavior', () => {
+    it('should round up correctly', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(123.455)).toBe(123.46);
+      expect(schema.parse(123.445)).toBe(123.45);
+      expect(schema.parse(0.995)).toBe(1.0);
+    });
+
+    it('should round down correctly', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(123.444)).toBe(123.44);
+      expect(schema.parse(123.441)).toBe(123.44);
+    });
+
+    it("should handle banker's rounding (round half to even)", () => {
+      const schema = numberPrecisionSchema(2);
+      // JavaScript's toFixed uses standard rounding, not banker's rounding
+      expect(schema.parse(123.445)).toBe(123.45);
+      expect(schema.parse(123.435)).toBe(123.44);
+    });
+
+    it('should handle edge cases in rounding', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(0.004)).toBe(0.0);
+      expect(schema.parse(0.005)).toBe(0.01);
+      expect(schema.parse(0.015)).toBe(0.02);
+      expect(schema.parse(0.025)).toBe(0.03);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle very small positive numbers', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(0.0001)).toBe(0.0);
+      expect(schema.parse(0.0005)).toBe(0.0);
+      expect(schema.parse(0.0006)).toBe(0.0);
+    });
+
+    it('should handle very large numbers', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(Number.MAX_SAFE_INTEGER)).toBe(
+        Number(Number.MAX_SAFE_INTEGER.toFixed(2)),
+      );
+    });
+
+    it('should handle numbers at precision boundaries', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(123.444)).toBe(123.44);
+      expect(schema.parse(123.445)).toBe(123.45);
+      expect(schema.parse(123.446)).toBe(123.45);
+    });
+
+    it('should handle scientific notation', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(1.23e2)).toBe(123.0);
+      expect(schema.parse(1.234e2)).toBe(123.4);
+      expect(schema.parse(1.2345e2)).toBe(123.45);
+    });
+
+    it('should handle Infinity', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(Infinity)).toBe(Infinity);
+      expect(schema.parse(-Infinity)).toBe(-Infinity);
+    });
+
+    it('should handle NaN', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(() => schema.parse(NaN)).toThrow();
+    });
+  });
+
+  describe('real-world scenarios', () => {
+    it('should handle currency amounts', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(122.4444)).toBe(122.44);
+      expect(schema.parse(99.995)).toBe(100.0);
+      expect(schema.parse(0.01)).toBe(0.01);
+      expect(schema.parse(1000.0)).toBe(1000.0);
+    });
+
+    it('should handle percentage values', () => {
+      const schema = numberPrecisionSchema(2);
+      expect(schema.parse(12.3456)).toBe(12.35);
+      expect(schema.parse(99.999)).toBe(100.0);
+      expect(schema.parse(0.123)).toBe(0.12);
+    });
+
+    it('should handle measurement values with different precision', () => {
+      const schema3 = numberPrecisionSchema(3);
+      expect(schema3.parse(12.34567)).toBe(12.346);
+      expect(schema3.parse(0.1234)).toBe(0.123);
+    });
+  });
+
+  describe('integration with Zod features', () => {
+    it('should work with safeParse', () => {
+      const schema = numberPrecisionSchema(2);
+      const result = schema.safeParse(123.456);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toBe(123.46);
+      }
+    });
+
+    it('should work with safeParse for invalid input', () => {
+      const schema = numberPrecisionSchema(2, z.number().positive());
+      const result = schema.safeParse(-123.456);
+      expect(result.success).toBe(false);
+    });
+
+    it('should preserve type information', () => {
+      const schema = numberPrecisionSchema(2);
+      const result = schema.parse(123.456);
+      expect(typeof result).toBe('number');
+    });
+  });
+});