@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/common/types/exchange-api-key.types.ts

@@ -0,0 +1,121 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { accountIdSchema } from './account.types';
+import { ExchangeProvider, IPaginationMeta } from './common.types';
+import { IBaseEntity } from './entity.types';
+import { ApiMessageSchema } from './north-cap-integration.types';
+
+/**
+ * Generic API Message schema that can be extended with more provider-specific message types
+ */
+export const APIMessage = ApiMessageSchema;
+export type APIMessage = z.infer<typeof APIMessage>;
+
+export enum ExchangeApiKeyStatus {
+  PENDING = 'PENDING',
+  ACTIVE = 'ACTIVE',
+  VERIFIED = 'VERIFIED',
+}
+
+export const exchangeApiKeyIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'exchange_api_key';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid exchange api key ID format. Must be a valid TypeID with "exchange_api_key" prefix.',
+  },
+);
+
+export const ExchangeApiKey = IBaseEntity.extend({
+  id: exchangeApiKeyIdSchema,
+  accountId: z.string(),
+  apiKey: z.string(),
+  clientId: z.string(),
+  baseUrl: z.string(),
+  environment: z.string().nullable(),
+  provider: z.nativeEnum(ExchangeProvider),
+  isActive: z.boolean(),
+  status: z
+    .nativeEnum(ExchangeApiKeyStatus)
+    .default(ExchangeApiKeyStatus.PENDING),
+  apiMessage: APIMessage.nullable(),
+});
+export type ExchangeApiKey = z.infer<typeof ExchangeApiKey>;
+
+export const PostExchangeApiKey = z.object({
+  provider: z.nativeEnum(ExchangeProvider),
+  apiKey: z.string(),
+  clientId: z.string(),
+});
+export type PostExchangeApiKey = z.infer<typeof PostExchangeApiKey>;
+export const AdminPostExchangeApiKey = PostExchangeApiKey.extend({
+  accountId: accountIdSchema,
+  environment: z.string().optional(),
+});
+export type AdminPostExchangeApiKey = z.infer<typeof AdminPostExchangeApiKey>;
+
+export const PaginatedExchangeApiKeys = z.object({
+  items: z.array(ExchangeApiKey),
+  meta: IPaginationMeta,
+});
+export type PaginatedExchangeApiKeys = z.infer<typeof PaginatedExchangeApiKeys>;
+
+export const UpdateExchangeApiKey = z.object({
+  provider: z.nativeEnum(ExchangeProvider),
+  apiKey: z.string(),
+  clientId: z.string(),
+  status: z.nativeEnum(ExchangeApiKeyStatus).optional(),
+  apiMessage: APIMessage.nullable().optional(),
+});
+export type UpdateExchangeApiKey = z.infer<typeof UpdateExchangeApiKey>;
+
+const exchangeApiKeysInclude = z.enum(['account']);
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(ExchangeApiKeysIncludeQuery),
+ */
+export const ExchangeApiKeysIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          exchangeApiKeysInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${exchangeApiKeysInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${exchangeApiKeysInclude.options.join(',')}`,
+    }),
+});
+export interface ExchangeApiKeysIncludeQuery
+  extends z.infer<typeof ExchangeApiKeysIncludeQuery> {}
+
+export const ExchangeApiKeysFilter = z.object({
+  accountId: accountIdSchema.optional(),
+  provider: z.nativeEnum(ExchangeProvider).optional(),
+});
+
+export interface ExchangeApiKeysFilter
+  extends z.infer<typeof ExchangeApiKeysFilter> {}
+
+/**
+ * Status response for exchange API key
+ * Returns only the status field
+ */
+export const ExchangeApiKeyStatusResponse = z.object({
+  status: z.nativeEnum(ExchangeApiKeyStatus),
+});
+export type ExchangeApiKeyStatusResponse = z.infer<
+  typeof ExchangeApiKeyStatusResponse
+>;

package/src/common/types/exchange-import.types.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { accountIdSchema } from './account.types';
+
+const exchangeImportsInclude = z.enum(['account']);
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(ExchangeImportsIncludeQuery),
+ */
+export const ExchangeImportsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          exchangeImportsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${exchangeImportsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${exchangeImportsInclude.options.join(',')}`,
+    }),
+});
+
+export interface ExchangeImportsIncludeQuery
+  extends z.infer<typeof ExchangeImportsIncludeQuery> {}
+
+export const ExchangeImportsFilter = z.object({
+  accountId: accountIdSchema.optional(),
+});
+
+export interface ExchangeImportsFilter
+  extends z.infer<typeof ExchangeImportsFilter> {}

package/src/common/types/exchange-provider.types.ts

@@ -0,0 +1,329 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+import { accountIdSchema } from './account.types';
+import {
+  ComplianceReview,
+  ExchangeProvider,
+  IPaginationMeta,
+  RunnerType,
+} from './common.types';
+import { secureRequestIdSchema } from './secure-request.types';
+
+export const exchangeImportIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'exchange_import';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid exchange import ID format. Must be a valid TypeID with "exchange_import" prefix.',
+  },
+);
+
+export enum ExchangeImportFrequency {
+  DAILY = 'DAILY',
+  WEEKLY = 'WEEKLY',
+  MONTHLY = 'MONTHLY',
+  EXTERNAL = 'EXTERNAL',
+}
+
+export const ExchangeImport = IBaseEntity.extend({
+  id: exchangeImportIdSchema,
+  accountId: accountIdSchema,
+  frequency: z.enum([
+    ExchangeImportFrequency.DAILY,
+    ExchangeImportFrequency.WEEKLY,
+    ExchangeImportFrequency.MONTHLY,
+    ExchangeImportFrequency.EXTERNAL,
+  ]),
+  provider: z.nativeEnum(ExchangeProvider),
+  isActive: z.boolean(),
+  runner: z.nativeEnum(RunnerType).default(RunnerType.WORKER),
+  secureRequestId: secureRequestIdSchema.nullable(),
+  primaries: z.boolean().default(false),
+  secondaries: z.boolean().default(false),
+});
+export type ExchangeImport = z.infer<typeof ExchangeImport>;
+
+export const PaginatedExchangeImports = z.object({
+  items: z.array(ExchangeImport),
+  meta: IPaginationMeta,
+});
+export type PaginatedExchangeImports = z.infer<typeof PaginatedExchangeImports>;
+
+export const PostAdminExchangeImport = z.object({
+  frequency: z.enum([
+    ExchangeImportFrequency.DAILY,
+    ExchangeImportFrequency.WEEKLY,
+    ExchangeImportFrequency.MONTHLY,
+    ExchangeImportFrequency.EXTERNAL,
+  ]),
+  provider: z.nativeEnum(ExchangeProvider),
+  accountId: accountIdSchema,
+  runner: z.nativeEnum(RunnerType).default(RunnerType.WORKER).optional(),
+  secureRequestId: secureRequestIdSchema.nullable().optional(),
+  primaries: z.boolean().default(false).optional(),
+  secondaries: z.boolean().default(false).optional(),
+});
+export type PostAdminExchangeImport = z.infer<typeof PostAdminExchangeImport>;
+
+export const UpdateExchangeImport = z.object({
+  isActive: z.boolean(),
+});
+export type UpdateExchangeImport = z.infer<typeof UpdateExchangeImport>;
+
+export const TriggerExchangeImport = z.object({});
+export type TriggerExchangeImport = z.infer<typeof TriggerExchangeImport>;
+
+// https://transactapi.readme.io/reference/createorder
+export const CreateOrderRequest = z.object({
+  memberid: z.string(),
+  issuerid: z.string(),
+  accountid: z.string().optional(),
+  securityid: z.string(),
+  type: z.enum(['Limit', 'RFQ']),
+  action: z.enum(['Buy', 'Sell']),
+  quantity: z.number().int().positive(),
+  price: z.number().positive(),
+  expiration: z.enum(['GTC', 'Day', 'Other']),
+  expirationDate: z.date().optional(),
+  disclosePrice: z.enum(['Yes', 'No']),
+  contingencies: z.enum(['All or None', 'Minimum Quantity', '']).optional(),
+  minimumThreshold: z.number().int().optional(),
+  solicited: z.enum(['Solicited', 'Unsolicited']),
+  token: z.string().optional(),
+});
+export type CreateOrderRequest = z.infer<typeof CreateOrderRequest>;
+
+export const CreateOrderResponse = z.object({
+  statusCode: z.string(),
+  statusDesc: z.string(),
+  orderid: z.string(),
+  orderStatus: z.enum([
+    'Pending',
+    'Live',
+    'Rejected',
+    'Cancelled',
+    'Partially Executed',
+    'Executed',
+  ]),
+  token: z.string().optional(),
+});
+export type CreateOrderResponse = z.infer<typeof CreateOrderResponse>;
+
+// PPEX Order types
+// https://transactapi.readme.io/reference/ppexorders
+export const PpexOrderZod = z.object({
+  securityId: z.string(),
+  securityName: z.string(),
+  expirationType: z.string(),
+  expirationDate: z.string(),
+  memberId: z.string(),
+  orderId: z.string(),
+  accountId: z.string(),
+  accountName: z.string(),
+  securityType: z.string(),
+  shares: z.string(),
+  remainingShares: z.string(),
+  sharePrice: z.string(),
+  amount: z.string(),
+  priceNotDisplayed: z.string(),
+  allOrNone: z.string(),
+  status: z.string(),
+  type: z.string(),
+  tradeStatus: z.string(),
+  orderStatus: z.string(),
+  tradeOrderStatus: z.string(),
+  negotiationStatus: z.string(),
+  deleted: z.string(),
+  createdDate: z.string(),
+  updatedBy: z.string(),
+  updatedDate: z.string(),
+  executionTime: z.string(),
+  contingencies: z.string(),
+  solicited: z.string(),
+  minimumQuantity: z.string(),
+  operationHrStatus: z.string(),
+  origination: z.string(),
+  cancelDate: z.string().optional(),
+  cancelExecutionTime: z.string(),
+  token: z.string(),
+});
+
+// PPEX Trade types
+// https://transactapi.readme.io/reference/ppextrades
+export const PpexTradeZod = z.object({
+  memberId: z.string(),
+  bidId: z.string(),
+  askId: z.string(),
+  offeringId: z.string(),
+  accountId: z.string(),
+  partyType: z.string(),
+  tradeId: z.string(),
+  transactionType: z.string(),
+  amount: z.string(),
+  sharePrice: z.string(),
+  shares: z.string(),
+  status: z.string(),
+  reportingStatus: z.string(),
+  createdDate: z.string(),
+  deleted: z.string(),
+  executionTime: z.string(),
+  updatedDate: z.string().nullable(),
+});
+
+export const GetOrdersResponseZod = z.object({
+  statusCode: z.string(),
+  statusDesc: z.string(),
+  ppex_orders: z.array(PpexOrderZod),
+  pagination: z.object({
+    totalRecords: z.number(),
+    startIndex: z.number(),
+    endIndex: z.number(),
+  }),
+});
+
+export const GetTradesResponseZod = z.object({
+  statusCode: z.string(),
+  statusDesc: z.string(),
+  ppex_trades: z.array(PpexTradeZod),
+  pagination: z.object({
+    totalRecords: z.number(),
+    startIndex: z.number(),
+    endIndex: z.number(),
+  }),
+});
+
+export const GetOrdersRequestZod = z.object({
+  limit: z.number().optional(),
+  offset: z.number().optional(),
+  filter: z.record(z.any()).optional(),
+  sort: z.string().optional(),
+  clientId: z.string(),
+  apiKey: z.string(),
+  baseUrl: z.string(),
+});
+
+export const GetTradesRequestZod = z.object({
+  limit: z.number().optional(),
+  offset: z.number().optional(),
+  filter: z.record(z.any()).optional(),
+  sort: z.string().optional(),
+  deleted: z.boolean().optional(),
+  clientId: z.string(),
+  apiKey: z.string(),
+  baseUrl: z.string(),
+});
+
+export type PpexOrder = z.infer<typeof PpexOrderZod>;
+export type PpexTrade = z.infer<typeof PpexTradeZod>;
+export type GetOrdersResponse = z.infer<typeof GetOrdersResponseZod>;
+export type GetTradesResponse = z.infer<typeof GetTradesResponseZod>;
+export type GetOrdersRequest = z.infer<typeof GetOrdersRequestZod>;
+export type GetTradesRequest = z.infer<typeof GetTradesRequestZod>;
+
+// Will extend for other exchanges if needed
+export type RawOrderData = PpexOrder;
+export type RawTradeData = PpexTrade;
+
+// PPEX Account types
+// https://transactapi.readme.io/reference/accounts
+export const PpexAccountZod = z.object({
+  accountId: z.string(),
+  accountName: z.string().nullable(),
+  type: z.string().nullable(),
+  entityType: z.string().nullable(),
+  residentType: z.string().nullable(),
+  socialSecurityNumber: z.string().nullable(),
+  address1: z.string().nullable(),
+  address2: z.string().nullable(),
+  city: z.string().nullable(),
+  state: z.string().nullable(),
+  zip: z.string().nullable(),
+  country: z.string().nullable(),
+  phone: z.string().nullable(),
+  taxID: z.string().nullable(),
+  kycStatus: z.string().nullable(),
+  kycDate: z.string().nullable(),
+  amlStatus: z.string().nullable(),
+  amlDate: z.string().nullable(),
+  suitabilityScore: z.string().nullable(),
+  suitabilityDate: z.string().nullable(),
+  suitabilityApprover: z.string().nullable(),
+  accreditedStatus: z.string().nullable(),
+  accreditedInvestor: z.string().nullable(),
+  accreditedInvestorDate: z.string().nullable(),
+  '506cLimit': z.string().nullable(),
+  accountTotalLimit: z.string().nullable(),
+  singleInvestmentLimit: z.string().nullable(),
+  associatedAC: z.string().nullable(),
+  syndicate: z.string().nullable(),
+  tags: z.string().nullable(),
+  notes: z.string().nullable(),
+  approvalStatus: z.string().nullable(),
+  approvalPrincipal: z.string().nullable(),
+  approvalLastReview: z.string().nullable(),
+  accountstatus: z.string().nullable(),
+  field1: z.string().nullable(),
+  field2: z.string().nullable(),
+  field3: z.string().nullable(),
+  createdDate: z.string().nullable(),
+  updatedDate: z.string().nullable(),
+});
+
+export const GetAccountsResponseZod = z.object({
+  statusCode: z.string(),
+  statusDesc: z.string(),
+  accounts: z.array(PpexAccountZod),
+  pagination: z.object({
+    totalRecords: z.number(),
+    startIndex: z.number(),
+    endIndex: z.number(),
+  }),
+});
+
+export const GetAccountsRequestZod = z.object({
+  limit: z.number().optional(),
+  offset: z.number().optional(),
+  deleted: z.boolean().optional(),
+  clientId: z.string(),
+  apiKey: z.string(),
+  baseUrl: z.string(),
+});
+
+export type PpexAccount = z.infer<typeof PpexAccountZod>;
+export type GetAccountsResponse = z.infer<typeof GetAccountsResponseZod>;
+export type GetAccountsRequest = z.infer<typeof GetAccountsRequestZod>;
+
+// Will extend for other exchanges if needed
+export type RawAccountData = PpexAccount;
+
+export const SecondaryTradesSummaryFiltersZod = z.object({
+  accountId: accountIdSchema.optional(),
+  complianceReview: z.nativeEnum(ComplianceReview).optional(),
+});
+export type SecondaryTradesSummaryFilters = z.infer<
+  typeof SecondaryTradesSummaryFiltersZod
+>;
+
+export const SecondaryTradeSummaryResponseZod = z.object({
+  accountId: accountIdSchema,
+  accountName: z.string(),
+  tradesCount: z.number(),
+});
+export type SecondaryTradeSummaryResponse = z.infer<
+  typeof SecondaryTradeSummaryResponseZod
+>;
+
+export const PaginatedSecondaryTradeSummaryResponseZod = z.object({
+  items: z.array(SecondaryTradeSummaryResponseZod),
+  meta: IPaginationMeta,
+});
+export type PaginatedSecondaryTradeSummaryResponse = z.infer<
+  typeof PaginatedSecondaryTradeSummaryResponseZod
+>;