@dalmore/api-contracts 1.0.5 → 1.0.6

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

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

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

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

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