@dalmore/api-contracts 1.0.3 → 1.0.5

package/src/common/types/job-item.types.ts

@@ -1,119 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-import { z } from 'zod';
-import {
-  IPaginationMeta,
-  TargetTableConfig,
-  TargetTableEnum,
-} from './common.types';
-import { accountIdSchema } from './account.types';
-import { IBaseEntity } from './entity.types';
-import { batchJobIdSchema } from './batch-jobs.types';
-
-extendZodWithOpenApi(z);
-
-export enum JobItemStatus {
-  PENDING = 'PENDING',
-  IN_PROGRESS = 'IN_PROGRESS',
-  COMPLETED = 'COMPLETED',
-  FAILED = 'FAILED',
-  APPROVED = 'APPROVED',
-  REJECTED = 'REJECTED',
-}
-
-export const JobItemIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'job_item';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid job item ID format. Must be a valid TypeID with "job_item" prefix.',
-  },
-);
-
-export const CreateJobItemZod = z.object({
-  targetTable: z.enum(TargetTableEnum),
-  bullJobId: z.string(),
-  accountId: accountIdSchema,
-  batchJobId: batchJobIdSchema,
-  targetId: z.string().refine(
-    (value) => {
-      try {
-        const tid = TypeID.fromString(value);
-        return Object.values(TargetTableConfig).some(
-          (config) => config.idPrefix === tid.getType(),
-        );
-      } catch {
-        return false;
-      }
-    },
-    {
-      message: `Invalid target ID format. Must match the corresponding table's ID prefix. Valid prefix: ${TargetTableEnum.toString().toLowerCase()}. Example: disbursement_01j6aqmtfyfwy9spjdcnh7yqk7`,
-    },
-  ),
-});
-export type CreateJobItemZod = z.infer<typeof CreateJobItemZod>;
-
-export const JobItemZod = IBaseEntity.extend({
-  id: JobItemIdSchema,
-  targetTable: z.enum(TargetTableEnum),
-  bullJobId: z.string(),
-  accountId: accountIdSchema,
-  batchJobId: batchJobIdSchema,
-  targetId: z.string(),
-  status: z.nativeEnum(JobItemStatus),
-  errorMessage: z.string().optional().nullable(),
-  processedAt: z.date().optional().nullable(),
-});
-export type JobItemZod = z.infer<typeof JobItemZod>;
-export const IPaginatedJobItem = z.object({
-  items: z.array(JobItemZod),
-  meta: IPaginationMeta,
-});
-export type IPaginatedJobItem = z.infer<typeof IPaginatedJobItem>;
-
-export const JobItemFiltersZod = z.object({
-  targetTable: z.enum(TargetTableEnum).optional(),
-  status: z.nativeEnum(JobItemStatus).optional(),
-  batchJobId: batchJobIdSchema.optional(),
-  targetId: z.string().optional(),
-});
-
-const jobItemsInclude = z.enum(['account', 'batchJob']);
-
-/**
- * @description Query parameters for including related entities
- * @xample in contract us as -> query: z.object({}).merge(AccountsIncludeQuery),
- */
-export const JobItemsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          jobItemsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${jobItemsInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${jobItemsInclude.options.join(',')}`,
-    }),
-});
-export interface JobItemsIncludeQuery
-  extends z.infer<typeof JobItemsIncludeQuery> {}
-
-export const PatchJobItemZod = z.object({
-  status: z.nativeEnum(JobItemStatus),
-  errorMessage: z.string().optional(),
-  processedAt: z.date().optional(),
-});
-export type PatchJobItemZod = z.infer<typeof PatchJobItemZod>;

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

@@ -1,171 +0,0 @@
-import { z } from 'zod';
-import { TypeID } from 'typeid-js';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { tradeIdSchema } from './trade.types';
-extendZodWithOpenApi(z);
-
-export enum JobNames {
-  SUBSCRIPTION_AGREEMENT = 'SUBSCRIPTION_AGREEMENT',
-  CHECK_INVESTOR = 'CHECK_INVESTOR',
-}
-
-// type of the data source
-export enum SourceType {
-  TRADES = 'trades',
-}
-
-// lower case to match the database table names
-export enum TargetTables {
-  TRADES = 'trades',
-  INVESTOR_ACCOUNTS = 'investor_accounts',
-}
-
-export enum TargetIdPrefix {
-  TRADE = 'trade',
-  INVESTOR_ACCOUNT = 'investor_account',
-}
-
-// lower case to match the database column names
-export enum TargeFields {
-  SA_CHECK = 'sa_check',
-}
-
-export enum TargetLogFields {
-  SA_LOG = 'sa_log',
-}
-
-export enum TargetTimeStamps {
-  SA_CHECKED_AT = 'sa_checked_at',
-}
-
-// camelCase to match the database column names as they come back from the entity
-export enum ValueFields {
-  SA_STATUS = 'saStatus',
-}
-
-export enum PassValue {
-  APPROVED = 'APPROVED',
-}
-
-export enum FailValue {
-  PENDING = 'PENDING',
-}
-
-export enum Method {
-  SCHEDULE = 'SCHEDULE',
-  MANUAL = 'MANUAL',
-}
-
-export enum CheckType {
-  COMPARE = 'COMPARE',
-}
-
-// Define the allowed ID types
-const allowedIdTypes = ['trade', 'offering', 'investor_account'] as const;
-export type JobAllowedIdType = (typeof allowedIdTypes)[number];
-
-// Create a schema for validating TypeIDs
-const typeIdSchema = (allowedTypes: readonly string[]) =>
-  z.string().refine(
-    (value) => {
-      try {
-        const tid = TypeID.fromString(value);
-        return allowedTypes.includes(tid.getType());
-      } catch {
-        return false;
-      }
-    },
-    {
-      message: `Invalid ID format. Must be a valid TypeID with one of these prefixes: ${allowedTypes.join(', ')}.`,
-    },
-  );
-
-export const DataSchema = z.object({
-  expected: z.array(z.string()),
-});
-export type Data = z.infer<typeof DataSchema>;
-
-export const CheckSchema = z.object({
-  name: z.string(),
-  type: z.nativeEnum(CheckType),
-  required: z.boolean(),
-  valueField: z.nativeEnum(ValueFields),
-  message: z.string(),
-  data: DataSchema,
-});
-export type Check = z.infer<typeof CheckSchema>;
-
-export const ConfigurationSchema = z.object({
-  name: z.nativeEnum(JobNames),
-  sourceType: z.nativeEnum(SourceType),
-  source: z.string(),
-  targetTable: z.nativeEnum(TargetTables),
-  targetIdPrefix: z.nativeEnum(TargetIdPrefix),
-  targetField: z.nativeEnum(TargeFields),
-  targetLogField: z.nativeEnum(TargetLogFields),
-  targetTimeStamp: z.nativeEnum(TargetTimeStamps),
-  passValue: z.nativeEnum(PassValue),
-  failValue: z.nativeEnum(FailValue),
-  checks: z.array(CheckSchema),
-});
-export type Configuration = z.infer<typeof ConfigurationSchema>;
-
-export const JobParamsSchema = z.object({
-  method: z.nativeEnum(Method),
-  names: z
-    .array(z.nativeEnum(JobNames))
-    .min(1, 'At least one name is required')
-    .max(50, 'Maximum of 50 names allowed')
-    .openapi({
-      example: ['SUBSCRIPTION_AGREEMENT'],
-    }),
-  ids: z
-    .array(typeIdSchema(allowedIdTypes))
-    .max(50, 'Maximum of 50 IDs allowed')
-    .openapi({
-      example: [
-        'trade_01j5ty4wbpe1zb171d02tqz9x6',
-        'offering_01j5ty4wbgfxqsp1sgaspaqaye',
-      ],
-    }),
-});
-export type JobParams = z.infer<typeof JobParamsSchema>;
-
-export const CheckInvestorParamsSchema = z.object({
-  method: z.nativeEnum(Method),
-  names: z
-    .array(z.nativeEnum(TargetIdPrefix))
-    .min(1, 'At least one name is required')
-    .max(50, 'Maximum of 50 names allowed')
-    .openapi({
-      example: ['investor_account'],
-    }),
-  ids: z
-    .array(typeIdSchema(allowedIdTypes))
-    .max(50, 'Maximum of 50 IDs allowed')
-    .openapi({
-      example: ['investor_account_01j9kqb7sce108yhpvth20a5w1'],
-    }),
-});
-export type CheckInvestorParams = z.infer<typeof CheckInvestorParamsSchema>;
-
-export const CheckResultLogSchema = z.object({
-  name: z.string(),
-  type: z.nativeEnum(CheckType),
-  message: z.string().nullable(),
-  data: DataSchema,
-  result: z.boolean(),
-});
-export type CheckResultLog = z.infer<typeof CheckResultLogSchema>;
-
-export const CheckResultSchema = z.object({
-  name: z.string(),
-  pass: z.boolean(),
-  logs: z.array(CheckResultLogSchema),
-});
-export type CheckResult = z.infer<typeof CheckResultSchema>;
-
-export const QueueTradeSaLogSchema = z.object({
-  tradeIds: z.lazy(() => z.array(tradeIdSchema).min(1).max(50)),
-});
-export type QueueTradeSaLog = z.infer<typeof QueueTradeSaLogSchema>;

package/src/common/types/kyb.types.ts

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import { IBaseEntity } from './entity.types';
-import { IPaginationMeta, KYBStatus } from './common.types';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-extendZodWithOpenApi(z);
-
-export const kybIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'kyb';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message: 'Invalid kyb ID format. Must be a valid TypeID with "kyb" prefix.',
-  },
-);
-
-export const KybZod = IBaseEntity.extend({
-  thirdPartyId: z.string().openapi({ example: 'third_party_kyb_123' }),
-  platform: z.string().openapi({ example: 'KYB Platform' }),
-  legalEntityId: z
-    .string()
-    .openapi({ example: 'legal_entity_01j1xgme5qeqq97gpdztd7e4a6' }),
-
-  documentType: z.string().openapi({ example: 'Certificate of Incorporation' }),
-  documentImage: z
-    .string()
-    .openapi({ example: 'https://example.com/document.pdf' }),
-  kybStatus: z.nativeEnum(KYBStatus).openapi({ example: 'PENDING' }),
-  reason: z
-    .string()
-    .nullable()
-    .openapi({ example: 'Additional information required' }),
-  response: z
-    .string()
-    .nullable()
-    .openapi({ example: 'Submitted additional documents' }),
-});
-export type KybZod = z.infer<typeof KybZod>;
-
-export const IPaginatedKyb = z.object({
-  items: z.array(KybZod),
-  meta: IPaginationMeta,
-});
-export type IPaginatedKyb = z.infer<typeof IPaginatedKyb>;
-
-export const KybFiltersZod = z.object({
-  kybStatus: z.nativeEnum(KYBStatus).optional(),
-});

package/src/common/types/kyc.types.ts

@@ -1,188 +0,0 @@
-import { z } from 'zod';
-import { IBaseEntity } from './entity.types';
-import { IPaginationMeta, KYCStatus } from './common.types';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-extendZodWithOpenApi(z);
-
-export const kycIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'kyc';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message: 'Invalid kyc ID format. Must be a valid TypeID with "kyc" prefix.',
-  },
-);
-
-export const KycZod = IBaseEntity.extend({
-  tid: z.string().openapi({ example: 'third_party_kyc_123' }).nullable(),
-  platform: z.string().openapi({ example: 'KYC Platform' }),
-  individualId: z
-    .string()
-    .openapi({ example: 'individual_01j1xgme5qeqq97gpdztd7e4a6' }),
-  documentType: z.string().openapi({ example: 'Passport' }),
-  documentImage: z
-    .string()
-    .openapi({ example: 'https://example.com/passport.jpg' }),
-  kycStatus: z.nativeEnum(KYCStatus).openapi({ example: 'PENDING' }),
-  reason: z.string().nullable().openapi({ example: 'Document unclear' }),
-  response: z
-    .string()
-    .nullable()
-    .openapi({ example: 'Submitted clearer document' }),
-});
-export type KycZod = z.infer<typeof KycZod>;
-
-export const IPaginatedKyc = z.object({
-  items: z.array(KycZod),
-  meta: IPaginationMeta,
-});
-export type IPaginatedKyc = z.infer<typeof IPaginatedKyc>;
-
-export const KycFiltersZod = z.object({
-  kycStatus: z.nativeEnum(KYCStatus).optional(),
-});
-
-export enum KYCPlatformProvider {
-  WITH_PERSONA = 'WITH_PERSONA',
-}
-
-export const inquiryIdSchema = z.string().regex(/^inq_[a-zA-Z0-9_-]{10,64}$/, {
-  message: 'Invalid inquiry ID format.',
-});
-
-export const InquiryResponse = z.object({
-  data: z.object({
-    type: z.literal('inquiry'),
-    id: z.string(),
-    attributes: z.object({
-      status: z.string(),
-      'reference-id': z.string(),
-      note: z.any().nullable(),
-      behaviors: z.object({
-        'api-version-less-than-minimum-count': z.any().nullable(),
-        'autofill-cancels': z.number(),
-        'autofill-starts': z.number(),
-        'behavior-threat-level': z.string(),
-        'bot-score': z.number(),
-        'completion-time': z.number(),
-        'debugger-attached': z.boolean(),
-        'devtools-open': z.boolean(),
-        'distraction-events': z.number(),
-        'hesitation-baseline': z.number(),
-        'hesitation-count': z.number(),
-        'hesitation-percentage': z.number(),
-        'hesitation-time': z.number(),
-        'mobile-sdk-version-less-than-minimum-count': z.any().nullable(),
-        'request-spoof-attempts': z.number(),
-        'shortcut-copies': z.number(),
-        'shortcut-pastes': z.number(),
-        'user-agent-spoof-attempts': z.number(),
-      }),
-      tags: z.array(z.any()),
-      creator: z.string(),
-      'reviewer-comment': z.any().nullable(),
-      'updated-at': z.string(),
-      'created-at': z.string(),
-      'started-at': z.any().nullable(),
-      'expires-at': z.any().nullable(),
-      'completed-at': z.any().nullable(),
-      'failed-at': z.any().nullable(),
-      'marked-for-review-at': z.any().nullable(),
-      'decisioned-at': z.string(),
-      'expired-at': z.any().nullable(),
-      'redacted-at': z.any().nullable(),
-      'previous-step-name': z.string(),
-      'next-step-name': z.string(),
-      'name-first': z.any().nullable(),
-      'name-middle': z.any().nullable(),
-      'name-last': z.any().nullable(),
-      birthdate: z.string(),
-      'address-street-1': z.any().nullable(),
-      'address-street-2': z.any().nullable(),
-      'address-city': z.any().nullable(),
-      'address-subdivision': z.any().nullable(),
-      'address-subdivision-abbr': z.any().nullable(),
-      'address-postal-code': z.any().nullable(),
-      'address-postal-code-abbr': z.any().nullable(),
-      'social-security-number': z.any().nullable(),
-      'identification-number': z.any().nullable(),
-      'email-address': z.any().nullable(),
-      'phone-number': z.any().nullable(),
-      fields: z.record(
-        z.object({
-          type: z.string(),
-          value: z.any().nullable(),
-        }),
-      ),
-    }),
-    relationships: z.object({
-      account: z.object({
-        data: z.object({
-          type: z.string(),
-          id: z.string(),
-        }),
-      }),
-      template: z.object({ data: z.any().nullable() }),
-      'inquiry-template': z.object({
-        data: z.object({
-          type: z.string(),
-          id: z.string(),
-        }),
-      }),
-      'inquiry-template-version': z.object({
-        data: z.object({
-          type: z.string(),
-          id: z.string(),
-        }),
-      }),
-      transaction: z.object({ data: z.any().nullable() }),
-      reviewer: z.object({ data: z.any().nullable() }),
-      reports: z.object({ data: z.array(z.any()) }),
-      verifications: z.object({ data: z.array(z.any()) }),
-      sessions: z.object({
-        data: z.array(
-          z.object({
-            type: z.literal('inquiry-session'),
-            id: z.string(),
-          }),
-        ),
-      }),
-      documents: z.object({ data: z.array(z.any()) }),
-      selfies: z.object({ data: z.array(z.any()) }),
-    }),
-  }),
-  included: z.array(z.any()),
-});
-
-export type InquiryResponse = z.infer<typeof InquiryResponse>;
-
-export const KycTimelineEvent = z.object({
-  kyc_id: z.string(),
-  kyc_tid: z.string().nullable(),
-  platform: z.string(),
-  individual_id: z.string(),
-  kyc_status: z.string(),
-  last_event_at: z.date(),
-  event_id: z.string(),
-  external_event_id: z.string(),
-  inquiry_id: z.string(),
-  event_type: z.string(),
-  event_created_at: z.date(),
-  event_processed_at: z.date().nullable(),
-  event_kyc_status: z.string().nullable(),
-  skipped: z.boolean(),
-  skip_reason: z.string().nullable(),
-});
-
-export const KycTimelineResponse = InquiryResponse.extend({
-  timeline_events: z.array(KycTimelineEvent),
-});
-
-export type KycTimelineEvent = z.infer<typeof KycTimelineEvent>;
-export type KycTimelineResponse = z.infer<typeof KycTimelineResponse>;