@dalmore/api-contracts 1.0.0

package/common/types/secondary-trade.types.ts

@@ -0,0 +1,87 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types';
+import {
+  ComplianceReview,
+  DateField,
+  DateRangeFiltersZod,
+  ExchangeProvider,
+} from './common.types';
+import { RawTradeData } from './exchange-provider.types';
+import { IPaginationMeta } from './common.types';
+import { accountIdSchema } from './account.types';
+extendZodWithOpenApi(z);
+
+export const secondaryTradeIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'secondary_trade';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid secondary trade id. Must be a valid id with "secondary_trade" prefix.',
+  },
+);
+
+export const SecondaryTradeZod = IBaseEntity.extend({
+  accountId: z.string(),
+  tid: z.string(),
+  provider: z.nativeEnum(ExchangeProvider),
+  complianceReview: z.nativeEnum(ComplianceReview),
+  complianceReviewNotes: z.string().nullable(),
+  complianceReviewerId: z.string().nullable(),
+  rawTradeData: z.custom<RawTradeData>().nullable(),
+});
+
+export type SecondaryTrade = z.infer<typeof SecondaryTradeZod>;
+
+export const IPaginatedSecondaryTrades = z.object({
+  items: z.array(SecondaryTradeZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedSecondaryTrades = z.infer<
+  typeof IPaginatedSecondaryTrades
+>;
+
+export const SecondaryTradeFiltersZod = z.object({
+  accountId: accountIdSchema.optional(),
+  search: z.string().max(50).optional(),
+  provider: z.nativeEnum(ExchangeProvider).optional(),
+  tid: z.string().max(50).optional(),
+  complianceReview: z.nativeEnum(ComplianceReview).optional(),
+});
+
+export const ExportSecondaryTradesResponse = z.object({
+  message: z.string(),
+});
+
+export type ExportSecondaryTradesResponse = z.infer<
+  typeof ExportSecondaryTradesResponse
+>;
+
+export const SecondaryTradeDateRangeFiltersZod = DateRangeFiltersZod.extend({
+  dateField: z
+    .enum([DateField.CREATED_AT, DateField.RAW_TRADE_CREATED_DATE])
+    .optional(),
+});
+
+export const SecondaryTradeSummaryZod = z.object({
+  accountId: accountIdSchema,
+  accountName: z.string(),
+  totalNeedsReviewCount: z.number().int(),
+  totalReadyToApproveCount: z.number().int(),
+});
+export type SecondaryTradeSummaryZod = z.infer<typeof SecondaryTradeSummaryZod>;
+
+export const IPaginatedSecondaryTradeSummaryResponse = z.object({
+  items: z.array(SecondaryTradeSummaryZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedSecondaryTradeSummaryResponse = z.infer<
+  typeof IPaginatedSecondaryTradeSummaryResponse
+>;

package/common/types/secure-request.types.ts

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta } from './common.types';
+extendZodWithOpenApi(z);
+
+export const secureRequestIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'secure_request';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid Secure ID format. Must be a valid TypeID with "secure_request" prefix. Example: secure_request_01j5y5ghx8fvc83dmx3pznq7hv',
+  },
+);
+
+export enum SecureRequestTemplate {
+  DEFAULT = 'default',
+  NORTHCAP = 'northcap',
+}
+
+export const SecureRequestZod = IBaseEntity.extend({
+  payload: z.record(z.any()), // Accepts objects with any shape
+  ipAddress: z.string().nullable(),
+  template: z.string().nullable(),
+});
+export type SecureRequestZod = z.infer<typeof SecureRequestZod>;
+
+export const IPaginatedSecureRequests = z.object({
+  items: z.array(SecureRequestZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedSecureRequests = z.infer<typeof IPaginatedSecureRequests>;
+
+export const PostSecureRequestBody = z.object({
+  payload: z.record(z.any()).refine(
+    (payload) => {
+      const stringified = JSON.stringify(payload);
+      if (stringified.length > 1024 * 100) {
+        throw new Error('Payload exceeds maximum size of 100KB');
+      }
+      return stringified;
+    },
+    {
+      message:
+        'Payload values must be strings with a maximum length of 100 characters',
+    },
+  ),
+  template: z
+    .nativeEnum(SecureRequestTemplate)
+    .nullable()
+    .openapi({ description: 'Template name' }),
+});
+export type PostSecureRequestBody = z.infer<typeof PostSecureRequestBody>;
+
+export const PostSecureRequestResponse = SecureRequestZod.extend({
+  exchangeApiKeyId: z.string().optional(),
+  exchangeImportId: z.string().optional(),
+});
+export type PostSecureRequestResponse = z.infer<
+  typeof PostSecureRequestResponse
+>;