@dalmore/api-contracts 1.0.5 → 1.0.6

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

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { CountryStateSchema, RequiredCountryStateSchema } from './states.types';
+import { CountryZipSchema, RequiredCountryZipSchema } from './zip.type';
+
+export const AddressSchema = z
+  .object({
+    address: z
+      .string()
+      .min(2, 'address is less than 2 characters')
+      .nullable()
+      .optional(),
+    address2: z.string().nullable().optional(),
+    city: z
+      .string()
+      .min(2, 'city is less than 2 characters')
+      .max(30, 'city is more than 30 characters')
+      .nullable()
+      .optional(),
+  })
+  .and(CountryStateSchema)
+  .and(CountryZipSchema);
+
+export type AddressType = z.infer<typeof AddressSchema>;
+
+export const RequiredAddressSchema = z
+  .object({
+    address: z.string().min(2, 'Address must be at least 2 characters'),
+    address2: z
+      .string()
+      .max(100, 'Address2 cannot exceed 100 characters')
+      .nullable()
+      .optional(),
+    city: z
+      .string()
+      .min(2, 'City must be at least 2 characters')
+      .max(50, 'City cannot exceed 50 characters'),
+  })
+  .and(RequiredCountryStateSchema)
+  .and(RequiredCountryZipSchema);
+
+export type RequiredAddressType = z.infer<typeof RequiredAddressSchema>;

package/src/common/types/aic.types.ts

@@ -0,0 +1,246 @@
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { fileIdSchema } from './file.types';
+import {
+  AccountType,
+  AicAccreditationType,
+  ComplianceReview,
+  FilingStatus,
+  SystemReviewStatus,
+} from './common.types';
+import { IIndividualZod, individualIdSchema } from './individuals.types';
+import { userIdSchema, UserZod } from './user.types';
+import { accountIdSchema } from './account.types';
+
+extendZodWithOpenApi(z);
+
+export const aicIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'aic';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid aic ID format. Must be a valid TypeID with "aic" prefix. Example: aic_01j5y5ghx5fg68d663j1fvy2x7`,
+  },
+);
+
+export enum ProfessionalType {
+  SECURITIES_LICENSES = 'SECURITIES_LICENSES',
+  DIRECTORS = 'DIRECTORS',
+  FAMILY_OFFICE = 'FAMILY_OFFICE',
+}
+
+export enum ResultType {
+  PASS = 'PASS',
+  FAIL = 'FAIL',
+}
+
+const aicInclude = z.enum(['individual']);
+
+export const AicIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          aicInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${aicInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${aicInclude.options.join(',')}`,
+    }),
+});
+
+export const IncomeDataEntryZod = z.object({
+  year: z
+    .number()
+    .int()
+    .min(2020)
+    .max(new Date().getFullYear() - 1),
+  filingStatus: z.nativeEnum(FilingStatus),
+  income: z.number().min(0).multipleOf(0.01),
+  fileId: z.lazy(() => fileIdSchema),
+});
+
+export type IncomeDataEntryZod = z.infer<typeof IncomeDataEntryZod>;
+
+export const NetWorthDataEntryZod = z.object({
+  institution: z.string().min(1).max(100),
+  accountType: z.nativeEnum(AccountType),
+  balance: z.number().min(0).multipleOf(0.01),
+  fileId: z.lazy(() => fileIdSchema),
+});
+
+export type NetWorthDataEntryZod = z.infer<typeof NetWorthDataEntryZod>;
+
+export const ProfessionalDataEntryZod = z
+  .object({
+    professionalType: z.nativeEnum(ProfessionalType),
+    licenseNumber: z.string().min(1).max(50).optional().nullable(),
+    fileId: z
+      .lazy(() => fileIdSchema)
+      .optional()
+      .nullable(),
+  })
+  .refine(
+    (data) => {
+      if (data.professionalType === ProfessionalType.SECURITIES_LICENSES) {
+        return !!data.licenseNumber;
+      }
+      return true;
+    },
+    {
+      message: `License number is required when professional type is ${ProfessionalType.SECURITIES_LICENSES}`,
+      path: ['licenseNumber'],
+    },
+  );
+
+export type ProfessionalDataEntryZod = z.infer<typeof ProfessionalDataEntryZod>;
+
+export const EmployeeDataEntryZod = z.object({
+  position: z.string().min(1).max(100),
+  fileId: z.lazy(() => fileIdSchema),
+});
+
+export type EmployeeDataEntryZod = z.infer<typeof EmployeeDataEntryZod>;
+
+// Validation configuration types
+export interface AicValidationConfig<T> {
+  schema: z.ZodType<T>;
+  errorPrefix: string;
+}
+
+export type AicValidationConfigMap = {
+  [AicAccreditationType.INCOME]: AicValidationConfig<IncomeDataEntryZod>;
+  [AicAccreditationType.NET_WORTH]: AicValidationConfig<NetWorthDataEntryZod>;
+  [AicAccreditationType.PROFESSIONAL_CERTIFICATION]: AicValidationConfig<ProfessionalDataEntryZod>;
+  [AicAccreditationType.KNOWLEDGEABLE_EMPLOYEE]: AicValidationConfig<EmployeeDataEntryZod>;
+};
+
+export const validationConfig: AicValidationConfigMap = {
+  [AicAccreditationType.INCOME]: {
+    schema: IncomeDataEntryZod,
+    errorPrefix: 'Income verification',
+  },
+  [AicAccreditationType.NET_WORTH]: {
+    schema: NetWorthDataEntryZod,
+    errorPrefix: 'Net worth verification',
+  },
+  [AicAccreditationType.PROFESSIONAL_CERTIFICATION]: {
+    schema: ProfessionalDataEntryZod,
+    errorPrefix: 'Professional certification',
+  },
+  [AicAccreditationType.KNOWLEDGEABLE_EMPLOYEE]: {
+    schema: EmployeeDataEntryZod,
+    errorPrefix: 'Employee verification',
+  },
+} as const;
+
+export const AicSystemLogEntryZod = z.object({
+  check: z.string().min(1),
+  entered: z.number().optional(),
+  extracted: z.number().optional(),
+  result: z.nativeEnum(ResultType),
+  reason: z.string().optional(),
+});
+
+export type AicSystemLogEntryZod = z.infer<typeof AicSystemLogEntryZod>;
+
+export const AicZod = IBaseEntity.extend({
+  individualId: z.lazy(() => individualIdSchema),
+  individual: z
+    .lazy(() => IIndividualZod)
+    .nullable()
+    .optional(),
+  complianceReview: z.nativeEnum(ComplianceReview),
+  reviewedById: z.lazy(() => userIdSchema).nullable(),
+  reviewedBy: z
+    .lazy(() => UserZod)
+    .nullable()
+    .optional(),
+  reviewedAt: z.date().nullable(),
+  systemReview: z.nativeEnum(SystemReviewStatus),
+  systemLog: z.array(AicSystemLogEntryZod).nullable(),
+  firstName: z.string(),
+  lastName: z.string(),
+  method: z.nativeEnum(AicAccreditationType),
+  incomeData: z.array(IncomeDataEntryZod).nullable(),
+  netWorthData: z.array(NetWorthDataEntryZod).nullable(),
+  professionalData: z.array(ProfessionalDataEntryZod).nullable(),
+  employeeData: z.array(EmployeeDataEntryZod).nullable(),
+});
+
+export type AicZod = z.infer<typeof AicZod>;
+
+export const PostAicZod = z.object({
+  firstName: z.string().min(1).max(50),
+  lastName: z.string().min(1).max(50),
+  method: z.nativeEnum(AicAccreditationType),
+});
+
+export type PostAicZod = z.infer<typeof PostAicZod>;
+
+export const UpdateAicZod = z.object({
+  firstName: z.string().min(1).max(50),
+  lastName: z.string().min(1).max(50),
+  method: z.nativeEnum(AicAccreditationType),
+});
+
+export type UpdateAicZod = z.infer<typeof UpdateAicZod>;
+
+export const AttachAicFilePathParamsZod = z.object({
+  individualId: z.lazy(() => individualIdSchema),
+  fileId: z.lazy(() => fileIdSchema),
+});
+
+export type AttachAicFilePathParamsZod = z.infer<
+  typeof AttachAicFilePathParamsZod
+>;
+
+export const AttachAicFileBodyZod = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(AicAccreditationType.INCOME),
+    metadata: z.array(IncomeDataEntryZod),
+  }),
+  z.object({
+    type: z.literal(AicAccreditationType.NET_WORTH),
+    metadata: z.array(NetWorthDataEntryZod),
+  }),
+  z.object({
+    type: z.literal(AicAccreditationType.PROFESSIONAL_CERTIFICATION),
+    metadata: z.array(ProfessionalDataEntryZod),
+  }),
+  z.object({
+    type: z.literal(AicAccreditationType.KNOWLEDGEABLE_EMPLOYEE),
+    metadata: z.array(EmployeeDataEntryZod),
+  }),
+]);
+
+export type AttachAicFilePathBodyZod = z.infer<typeof AttachAicFileBodyZod>;
+
+export const ComplianceAicQueryZod = z.object({
+  accountId: z.lazy(() => accountIdSchema),
+});
+
+export type ComplianceAicQueryZod = z.infer<typeof ComplianceAicQueryZod>;
+
+export const ComplianceAttachAicFileBodyZod = AttachAicFileBodyZod.and(
+  z.object({
+    accountId: z.lazy(() => accountIdSchema),
+  }),
+);
+
+export type ComplianceAttachAicFileBodyZod = z.infer<
+  typeof ComplianceAttachAicFileBodyZod
+>;

package/src/common/types/aml.types.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { AMLStatus } from './common.types';
+
+extendZodWithOpenApi(z);
+
+export const AmlZod = IBaseEntity.extend({
+  tid: z.string().openapi({ example: 'third_party_kyc_123' }).nullable(),
+  provider: z.string().nullable().openapi({ example: 'AML Provider' }),
+  url: z.string().nullable().openapi({ example: 'https://example.com/aml' }),
+  status: z.nativeEnum(AMLStatus).openapi({ example: 'PENDING' }),
+  checkedAt: z.date().nullable().openapi({ example: '2022-01-01T00:00:00Z' }),
+  individualId: z
+    .string()
+    .openapi({ example: 'individual_01j1xgme5qeqq97gpdztd7e4a6' }),
+});
+export type AmlZod = z.infer<typeof AmlZod>;

package/src/common/types/api-key-logs.types.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { HttpStatus } from '@nestjs/common';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IPaginationMeta, HttpMethod, dateSchema } from './common.types';
+import { apiKeyIdSchema } from './api-keys.types';
+import { IBaseEntity } from './entity.types';
+
+extendZodWithOpenApi(z);
+
+export const ApiLogsFiltersZod = z.object({
+  endpoint: z.string().optional(),
+  apiKeyId: apiKeyIdSchema.optional(),
+  method: z.nativeEnum(HttpMethod).optional(),
+  status: z.nativeEnum(HttpStatus).optional(),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type ApiLogsFiltersZod = z.infer<typeof ApiLogsFiltersZod>;
+
+export const apiKeyLogIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'api_key_log';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid Api Key Log ID format. Must be a valid TypeID with "api_key_log" prefix. Example: api_key_log_01j5y5ghx8fvc83dmx3pznq7hv',
+  },
+);
+
+export const ApiKeyLogZod = IBaseEntity.extend({
+  id: apiKeyLogIdSchema,
+  apiKeyId: apiKeyIdSchema,
+  method: z.nativeEnum(HttpMethod),
+  path: z.string(),
+  status: z.nativeEnum(HttpStatus),
+  durationMs: z.number(),
+  requestBody: z.record(z.any()).nullable(),
+  responseBody: z.record(z.any()).nullable(),
+});
+export type ApiKeyLogZod = z.infer<typeof ApiKeyLogZod>;
+
+export const ApiLogsTotalsFiltersZod = z.object({
+  apiKeyId: apiKeyIdSchema.optional(),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type ApiLogsTotalsFiltersZod = z.infer<typeof ApiLogsTotalsFiltersZod>;
+
+export const ApiLogsTotalsZod = z.object({
+  success: z.number(),
+  failed: z.number(),
+  total: z.number().optional(),
+});
+export type ApiLogsTotalsZod = z.infer<typeof ApiLogsTotalsZod>;
+
+export const IPaginatedApiLogs = z.object({
+  items: z.array(ApiKeyLogZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedApiLogs = z.infer<typeof IPaginatedApiLogs>;

package/src/common/types/api-keys.types.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta, PortalType } from './common.types';
+import { accountIdSchema } from './account.types';
+extendZodWithOpenApi(z);
+
+export const apiKeyIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'api_key';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid Api Key ID format. Must be a valid TypeID with "api_key" prefix. Example: api_key_01j5y5ghx8fvc83dmx3pznq7hv',
+  },
+);
+
+export const ApiKeyZod = IBaseEntity.extend({
+  id: apiKeyIdSchema,
+  name: z.string(),
+  description: z.string().nullable(),
+  key: z.string(),
+  keyHash: z.string(),
+  active: z.boolean(),
+  lastUsedAt: z.date().nullable(),
+  accountId: z.string(),
+  roleId: z.string().nullable(),
+});
+export type ApiKeyZod = z.infer<typeof ApiKeyZod>;
+
+export const IPaginatedApiKeys = z.object({
+  items: z.array(ApiKeyZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedApiKeys = z.infer<typeof IPaginatedApiKeys>;
+
+export const PostApiKeyBody = z.object({
+  name: z
+    .string()
+    .min(2, 'name is less than 2 characters')
+    .max(30, 'name is more than 30 characters')
+    .openapi({ description: 'Name of the API key' }),
+  description: z
+    .string()
+    .min(2, 'description is less than 2 characters')
+    .max(50, 'description is more than 50 characters')
+    .optional()
+    .openapi({ description: 'Description of the API key' }),
+  accountId: accountIdSchema,
+  contract: z
+    .enum([
+      PortalType.CLIENT,
+      PortalType.SECONDARIES,
+      PortalType.COMPLIANCE_APIKEY,
+    ])
+    .default(PortalType.CLIENT),
+});
+export type PostApiKeyBody = z.infer<typeof PostApiKeyBody>;
+
+//It removes accountId because issuers use user.accountId from authentication, so the request body shouldn't include it.
+export const PostIssuerApiKeyBody = PostApiKeyBody.omit({ accountId: true });
+
+export type PostIssuerApiKeyBody = z.infer<typeof PostIssuerApiKeyBody>;