@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/common/types/secondary-customer.types.ts

@@ -0,0 +1,66 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import {
+  ExchangeProvider,
+  IPaginationMeta,
+  PaginationOptionsZod,
+} from './common.types';
+import { IBaseEntity } from './entity.types';
+import { accountIdSchema } from './account.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { RawAccountData } from './exchange-provider.types';
+
+extendZodWithOpenApi(z);
+
+export const secondaryCustomerIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const id = TypeID.fromString(value);
+      return id.getType() === 'secondary_customer';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid secondary customer ID format. Must be a valid TypeID with "secondary_customer" prefix.',
+  },
+);
+
+export const SecondaryCustomer = IBaseEntity.extend({
+  accountId: accountIdSchema,
+  tid: z.string(),
+  provider: z.nativeEnum(ExchangeProvider).default(ExchangeProvider.PPEX),
+  rawAccountData: z.custom<RawAccountData>().nullable(),
+});
+export type SecondaryCustomer = z.infer<typeof SecondaryCustomer>;
+
+export const IPaginatedSecondaryCustomers = z.object({
+  items: z.array(SecondaryCustomer),
+  meta: IPaginationMeta,
+});
+export type IPaginatedSecondaryCustomers = z.infer<
+  typeof IPaginatedSecondaryCustomers
+>;
+
+export const SecondaryCustomerFiltersZod = z.object({
+  accountId: accountIdSchema.optional(),
+  search: z.string().max(50).optional(),
+  provider: z.nativeEnum(ExchangeProvider).optional(),
+  tid: z.string().max(50).optional(),
+});
+
+export const GetSecondaryCustomerFiltersZod = PaginationOptionsZod.merge(
+  SecondaryCustomerFiltersZod,
+);
+export type GetSecondaryCustomerFiltersZod = z.infer<
+  typeof GetSecondaryCustomerFiltersZod
+>;
+
+export const ExportSecondaryCustomersResponse = z.object({
+  message: z.string(),
+});
+
+export type ExportSecondaryCustomersResponse = z.infer<
+  typeof ExportSecondaryCustomersResponse
+>;

package/src/common/types/secondary-issuer.types.ts

@@ -0,0 +1,50 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta } from './common.types';
+import { SecondarySecurityZod } from './secondary-security.types';
+extendZodWithOpenApi(z);
+
+export const secondaryIssuerIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'secondary_issuer';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid secondary issuer id. Must be a valid id with "secondary_issuer" prefix.',
+  },
+);
+
+export const SecondaryIssuerZod = IBaseEntity.extend({
+  name: z.string(),
+  accountId: z.string().optional(),
+  securities: z.array(z.lazy(() => SecondarySecurityZod)),
+  ppexIssuerId: z.string().optional(),
+});
+export type SecondaryIssuerZod = z.infer<typeof SecondaryIssuerZod>;
+
+export const IPaginatedSecondaryIssuers = z.object({
+  items: z.array(SecondaryIssuerZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedSecondaryIssuers = z.infer<
+  typeof IPaginatedSecondaryIssuers
+>;
+
+export const CreateSecondaryIssuer = z.object({
+  name: z.string().max(250),
+  ppexIssuerId: z.string().max(250),
+});
+export type CreateSecondaryIssuer = z.infer<typeof CreateSecondaryIssuer>;
+
+export const UpdateSecondaryIssuer = z.object({
+  name: z.string().max(250).optional(),
+  ppexIssuerId: z.string().max(250).optional(),
+});
+export type UpdateSecondaryIssuer = z.infer<typeof UpdateSecondaryIssuer>;

package/src/common/types/secondary-order.types.ts

@@ -0,0 +1,58 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { accountIdSchema } from './account.types';
+import {
+  DateField,
+  DateRangeFiltersZod,
+  ExchangeProvider,
+  IPaginationMeta,
+} from './common.types';
+import { IBaseEntity } from './entity.types';
+import { RawOrderData } from './exchange-provider.types';
+
+extendZodWithOpenApi(z);
+
+export const secondaryOrderIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'secondary_order';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid secondary order id. Must be a valid id with "secondary_order" prefix.',
+  },
+);
+
+export const SecondaryOrder = IBaseEntity.extend({
+  accountId: z.string(),
+  tid: z.string(),
+  provider: z.nativeEnum(ExchangeProvider),
+  rawOrderData: z.custom<RawOrderData>().nullable(),
+});
+export type SecondaryOrder = z.infer<typeof SecondaryOrder>;
+
+export const IPaginatedSecondaryOrders = z.object({
+  items: z.array(SecondaryOrder),
+  meta: IPaginationMeta,
+});
+export type IPaginatedSecondaryOrders = z.infer<
+  typeof IPaginatedSecondaryOrders
+>;
+
+export const SecondaryOrderFiltersZod = z.object({
+  accountId: accountIdSchema.optional(),
+  search: z.string().max(50).optional(),
+  provider: z.nativeEnum(ExchangeProvider).optional(),
+  tid: z.string().max(50).optional(),
+});
+
+export const SecondaryOrderDateRangeFiltersZod = DateRangeFiltersZod.extend({
+  dateField: z
+    .enum([DateField.CREATED_AT, DateField.RAW_ORDER_CREATED_DATE])
+    .optional(),
+});

package/src/common/types/secondary-security.types.ts

@@ -0,0 +1,60 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta } from './common.types';
+import { secondaryIssuerIdSchema } from './secondary-issuer.types';
+import { accountIdSchema } from './account.types';
+
+extendZodWithOpenApi(z);
+
+export const secondarySecurityIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'secondary_security';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid secondary security id. Must be a valid id with "secondary_security" prefix.',
+  },
+);
+
+export const SecondarySecurityZod = IBaseEntity.extend({
+  name: z.string(),
+  issuerId: z.lazy(() => secondaryIssuerIdSchema),
+  accountId: z.lazy(() => accountIdSchema),
+  ticker: z.string(),
+  ppexSecurityId: z.string(),
+});
+
+export type SecondarySecurityZod = z.infer<typeof SecondarySecurityZod>;
+
+export const IPaginatedSecondarySecurities = z.object({
+  items: z.array(SecondarySecurityZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedSecondarySecurities = z.infer<
+  typeof IPaginatedSecondarySecurities
+>;
+
+export const CreateSecondarySecurity = z.object({
+  name: z.string().min(1).max(255),
+  issuerId: z.lazy(() => secondaryIssuerIdSchema),
+  accountId: z.lazy(() => accountIdSchema),
+  ticker: z.string().min(1).max(255),
+  ppexSecurityId: z.string().min(1).max(255),
+});
+export type CreateSecondarySecurity = z.infer<typeof CreateSecondarySecurity>;
+
+export const UpdateSecondarySecurity = z.object({
+  name: z.string().min(1).max(255).optional(),
+  issuerId: z.lazy(() => secondaryIssuerIdSchema).optional(),
+  accountId: z.lazy(() => accountIdSchema).optional(),
+  ticker: z.string().min(1).max(255).optional(),
+  ppexSecurityId: z.string().min(1).max(255).optional(),
+});
+export type UpdateSecondarySecurity = z.infer<typeof UpdateSecondarySecurity>;

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

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { BaseStatus } from './common.types';
+
+export enum PhoenixApprovalStatus {
+  APPROVED = BaseStatus.APPROVED,
+  PENDING = BaseStatus.PENDING,
+}
+
+export const PhoenixSecondaryTradePayloadZod = z.object({
+  investment_ids: z.string(),
+  approval_status: z.nativeEnum(PhoenixApprovalStatus),
+});
+
+export type PhoenixSecondaryTradePayload = z.infer<
+  typeof PhoenixSecondaryTradePayloadZod
+>;

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

@@ -0,0 +1,95 @@
+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 type SecondaryTradeFiltersZod = z.infer<typeof SecondaryTradeFiltersZod>;
+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
+>;
+
+export const CountResultZod = z.array(
+  z.object({
+    count: z.string(),
+  }),
+);
+export type CountResultZod = z.infer<typeof CountResultZod>;

package/src/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
+>;