@dalmore/api-contracts 1.0.6 → 1.0.7

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

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

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

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

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

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

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