@dalmore/api-contracts 0.0.0-dev.ee0e6b6 → 0.0.0-dev.f0b9301

package/common/types/north-cap-integration.types.ts

@@ -1,190 +0,0 @@
-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';
-import { accountIdSchema } from './account.types';
-import { secureRequestIdSchema } from './secure-request.types';
-
-extendZodWithOpenApi(z);
-
-export enum NorthCapIntegrationEnvironment {
-  PRODUCTION = 'PRODUCTION',
-  SANDBOX = 'SANDBOX',
-}
-
-export enum NorthCapIntegrationStatus {
-  PENDING = 'PENDING',
-  VERIFIED = 'VERIFIED',
-  ERROR = 'ERROR',
-}
-
-export const ApiSuccessResponseSchema = z.object({
-  valid: z.literal(true),
-  status_code: z.number(),
-  latency_ms: z.number(),
-  raw: z
-    .object({
-      statusCode: z.string(),
-      statusDesc: z.string(),
-      job: z
-        .object({
-          id: z.string(),
-          type: z.string(),
-          progress: z.string(),
-          status: z.string(),
-          reason: z.string().nullable(),
-          outputId: z.string().nullable(),
-          createdAt: z.string(),
-          updatedAt: z.string(),
-        })
-        .optional(),
-    })
-    .and(z.record(z.any())),
-});
-
-export const ApiErrorResponseSchema = z.object({
-  valid: z.literal(false),
-  status_code: z.number(),
-  latency_ms: z.number(),
-  raw: z
-    .object({
-      statusCode: z.string(),
-      statusDesc: z.string(),
-    })
-    .and(z.record(z.any())),
-  error: z.string().optional(),
-});
-
-export const ApiMessageSchema = z.union([
-  ApiSuccessResponseSchema,
-  ApiErrorResponseSchema,
-]);
-
-export type ApiSuccessResponseSchema = z.infer<typeof ApiSuccessResponseSchema>;
-export type ApiErrorResponseSchema = z.infer<typeof ApiErrorResponseSchema>;
-export type ApiMessageSchema = z.infer<typeof ApiMessageSchema>;
-
-export const northCapIntegrationIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'north_cap_integration';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid North Cap Integration ID format. Must be a valid TypeID with "north_cap_integration" prefix. Example: north_cap_integration_01j5y5ghx8fvc83dmx3pznq7hv',
-  },
-);
-
-export const NorthCapIntegrationZod = IBaseEntity.extend({
-  id: northCapIntegrationIdSchema,
-  accountId: accountIdSchema.openapi({
-    example: 'account_01j1xgme5qeqq97gpdztd7e4a6',
-  }),
-  environment: z
-    .nativeEnum(NorthCapIntegrationEnvironment)
-    .openapi({ example: NorthCapIntegrationEnvironment.SANDBOX }),
-  clientId: z
-    .string()
-    .min(1, 'Client ID is required')
-    .max(50, 'Client ID is too long')
-    .openapi({ example: 'client123' }),
-  apikey: z
-    .string()
-    .min(1, 'API key is required')
-    .max(255, 'API key is too long')
-    .openapi({ example: 'api_key_123' }),
-  primaries: z.boolean().openapi({ example: false }),
-  secondaries: z.boolean().openapi({ example: true }),
-  status: z
-    .nativeEnum(NorthCapIntegrationStatus)
-    .openapi({ example: NorthCapIntegrationStatus.PENDING }),
-  apiMessage: ApiMessageSchema.nullable().openapi({ example: null }),
-  secureRequestId: secureRequestIdSchema.openapi({
-    example: 'secure_request_01j1xgme5qeqq97gpdztd7e4a6',
-  }),
-});
-
-export type NorthCapIntegrationZod = z.infer<typeof NorthCapIntegrationZod>;
-
-export const IPaginatedNorthCapIntegrations = z.object({
-  items: z.array(NorthCapIntegrationZod),
-  meta: IPaginationMeta,
-});
-
-export type IPaginatedNorthCapIntegrations = z.infer<
-  typeof IPaginatedNorthCapIntegrations
->;
-
-export const PostNorthCapIntegrationSchema = z.object({
-  accountId: accountIdSchema,
-  environment: z
-    .nativeEnum(NorthCapIntegrationEnvironment)
-    .default(NorthCapIntegrationEnvironment.SANDBOX),
-  clientId: z
-    .string()
-    .min(1, 'Client ID is required')
-    .max(50, 'Client ID is too long'),
-  apikey: z
-    .string()
-    .min(1, 'API key is required')
-    .max(255, 'API key is too long'),
-  primaries: z.boolean().default(false),
-  secondaries: z.boolean().default(false),
-  apiMessage: ApiMessageSchema.nullable().optional(),
-  secureRequestId: secureRequestIdSchema,
-});
-
-export type PostNorthCapIntegrationSchema = z.infer<
-  typeof PostNorthCapIntegrationSchema
->;
-
-export const UpdateNorthCapIntegrationSchema = z.object({
-  status: z.nativeEnum(NorthCapIntegrationStatus).optional(),
-  apiMessage: ApiMessageSchema.nullable().optional(),
-});
-
-export type UpdateNorthCapIntegrationSchema = z.infer<
-  typeof UpdateNorthCapIntegrationSchema
->;
-
-export const NorthCapIntegrationFiltersZod = z.object({
-  accountId: accountIdSchema.optional(),
-  status: z.nativeEnum(NorthCapIntegrationStatus).optional(),
-});
-
-export const northCapIntegrationInclude = z.enum(['account', 'secureRequest']);
-
-/**
- * @description Query parameters for including related entities
- * @example in contract use as -> query: z.object({}).merge(NorthCapIntegrationsIncludeQuery),
- */
-export const NorthCapIntegrationsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          northCapIntegrationInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${northCapIntegrationInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${northCapIntegrationInclude.options.join(',')}`,
-    }),
-});
-
-export type NorthCapIntegrationFiltersZod = z.infer<
-  typeof NorthCapIntegrationFiltersZod
->;
-
-export interface NorthCapIntegrationsIncludeQuery
-  extends z.infer<typeof NorthCapIntegrationsIncludeQuery> {}

package/common/types/note.types.ts

@@ -1,109 +0,0 @@
-import { z } from 'zod';
-import { TypeID } from 'typeid-js';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { IBaseEntity } from './entity.types';
-import {
-  IPaginationMeta,
-  TargetTableConfig,
-  TargetTableEnum,
-  // UserWithoutPasswordAccountZod,
-} from './common.types';
-import { accountIdSchema } from './account.types';
-extendZodWithOpenApi(z);
-
-export const noteIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'note';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid note ID format. Must be a valid TypeID with "note" prefix. Example: note_01j5y5ghx8fvc83dmx3pznq7hv',
-  },
-);
-
-export const NoteZod = IBaseEntity.extend({
-  id: noteIdSchema,
-  body: z.string(),
-  accountId: z.string(),
-  userId: z.string(),
-  targetTable: z.enum(TargetTableEnum),
-  targetId: z.string(),
-}).refine(
-  (data) => {
-    const { targetTable, targetId } = data;
-    const idPrefix = TargetTableConfig[targetTable].idPrefix;
-    try {
-      const tid = TypeID.fromString(targetId);
-      return tid.getType() === idPrefix;
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      "Invalid target ID format. Must match the corresponding table's ID prefix.",
-    path: ['targetId'],
-  },
-);
-export type NoteZod = z.infer<typeof NoteZod>;
-
-export const IPaginatedNote = z.object({
-  items: z.array(NoteZod),
-  meta: IPaginationMeta,
-});
-export type IPaginatedNote = z.infer<typeof IPaginatedNote>;
-
-export const PostNoteBody = z.object({
-  body: z.string(),
-  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 PostNoteBody = z.infer<typeof PostNoteBody>;
-
-export const CompliancePostNoteBody = PostNoteBody.extend({
-  accountId: accountIdSchema,
-});
-
-export type CompliancePostNoteBody = z.infer<typeof CompliancePostNoteBody>;
-
-export const NotesFilters = z.object({
-  targetTable: z.enum(TargetTableEnum).optional(),
-  targetId: z
-    .string()
-    .optional()
-    .refine(
-      (value) => {
-        try {
-          if (!value) return true;
-          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 NotesFilters = z.infer<typeof NotesFilters>;

package/common/types/notification.types.ts

@@ -1,268 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { z } from 'zod';
-import { TypeID } from 'typeid-js';
-import { IBaseEntity } from './entity.types';
-
-extendZodWithOpenApi(z);
-
-export enum NotificationChannelType {
-  EMAIL = 'EMAIL',
-  SLACK = 'SLACK',
-  WEBHOOK = 'WEBHOOK',
-}
-
-export enum NotificationRecordStatus {
-  PENDING = 'PENDING',
-  SENT = 'SENT',
-  FAILED = 'FAILED',
-}
-
-export const notificationChannelIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'notification_channel';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid notification channel ID format. Must be a valid TypeID with "notification_channel" prefix.',
-  },
-);
-
-export const notificationChannelTriggerIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'notification_channel_trigger';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid notification channel trigger ID format. Must be a valid TypeID with "notification_channel_trigger" prefix.',
-  },
-);
-
-export const notificationRecordIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'notification_record';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid notification record ID format. Must be a valid TypeID with "notification_record" prefix.',
-  },
-);
-
-export const EmailChannelSettingsSchema = z.object({
-  recipients: z.array(z.string().email()).min(1),
-  subjectTemplate: z.string().optional(),
-});
-export type EmailChannelSettings = z.infer<typeof EmailChannelSettingsSchema>;
-
-export const SlackChannelSettingsSchema = z
-  .object({
-    webhookUrl: z.string().url().optional(),
-    channelEmail: z.string().email().optional(),
-  })
-  .refine((data) => data.webhookUrl || data.channelEmail, {
-    message: 'Either webhookUrl or channelEmail is required',
-  });
-export type SlackChannelSettings = z.infer<typeof SlackChannelSettingsSchema>;
-
-export const WebhookChannelSettingsSchema = z.object({
-  url: z.string().url(),
-  method: z.enum(['POST', 'PUT']),
-  headers: z.record(z.string()).optional(),
-  authType: z.enum(['none', 'bearer', 'basic', 'api_key']).default('none'),
-  authValue: z.string().optional(),
-});
-export type WebhookChannelSettings = z.infer<
-  typeof WebhookChannelSettingsSchema
->;
-
-export const NotificationChannelSettingsSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal(NotificationChannelType.EMAIL),
-    config: EmailChannelSettingsSchema,
-  }),
-  z.object({
-    type: z.literal(NotificationChannelType.SLACK),
-    config: SlackChannelSettingsSchema,
-  }),
-  z.object({
-    type: z.literal(NotificationChannelType.WEBHOOK),
-    config: WebhookChannelSettingsSchema,
-  }),
-]);
-export type NotificationChannelSettings = z.infer<
-  typeof NotificationChannelSettingsSchema
->;
-
-export const EmailNotificationPayloadSchema = z.object({
-  to: z.array(z.string().email()),
-  subject: z.string(),
-  body: z.string(),
-  html: z.string().optional(),
-});
-export type EmailNotificationPayload = z.infer<
-  typeof EmailNotificationPayloadSchema
->;
-
-export const SlackNotificationPayloadSchema = z.object({
-  webhookUrl: z.string().url().optional(),
-  channelEmail: z.string().email().optional(),
-  message: z.string(),
-  blocks: z.array(z.record(z.unknown())).optional(),
-});
-export type SlackNotificationPayload = z.infer<
-  typeof SlackNotificationPayloadSchema
->;
-
-export const WebhookNotificationPayloadSchema = z.object({
-  url: z.string().url(),
-  method: z.enum(['POST', 'PUT']),
-  headers: z.record(z.string()),
-  body: z.record(z.unknown()),
-});
-export type WebhookNotificationPayload = z.infer<
-  typeof WebhookNotificationPayloadSchema
->;
-
-export const NotificationPayloadSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal(NotificationChannelType.EMAIL),
-    data: EmailNotificationPayloadSchema,
-  }),
-  z.object({
-    type: z.literal(NotificationChannelType.SLACK),
-    data: SlackNotificationPayloadSchema,
-  }),
-  z.object({
-    type: z.literal(NotificationChannelType.WEBHOOK),
-    data: WebhookNotificationPayloadSchema,
-  }),
-]);
-export type NotificationPayload = z.infer<typeof NotificationPayloadSchema>;
-
-export const EmailNotificationResponseSchema = z.object({
-  messageId: z.string().optional(),
-  accepted: z.array(z.string()).optional(),
-  rejected: z.array(z.string()).optional(),
-});
-export type EmailNotificationResponse = z.infer<
-  typeof EmailNotificationResponseSchema
->;
-
-export const SlackNotificationResponseSchema = z.object({
-  ok: z.boolean().optional(),
-  error: z.string().optional(),
-  responseBody: z.string().optional(),
-});
-export type SlackNotificationResponse = z.infer<
-  typeof SlackNotificationResponseSchema
->;
-
-export const WebhookNotificationResponseSchema = z.object({
-  statusCode: z.number(),
-  headers: z.record(z.string()).optional(),
-  body: z.unknown().optional(),
-});
-export type WebhookNotificationResponse = z.infer<
-  typeof WebhookNotificationResponseSchema
->;
-
-export const NotificationResponseSchema = z.discriminatedUnion('type', [
-  z.object({
-    type: z.literal(NotificationChannelType.EMAIL),
-    data: EmailNotificationResponseSchema,
-  }),
-  z.object({
-    type: z.literal(NotificationChannelType.SLACK),
-    data: SlackNotificationResponseSchema,
-  }),
-  z.object({
-    type: z.literal(NotificationChannelType.WEBHOOK),
-    data: WebhookNotificationResponseSchema,
-  }),
-]);
-export type NotificationResponse = z.infer<typeof NotificationResponseSchema>;
-
-export const INotificationChannelZod = IBaseEntity.extend({
-  id: notificationChannelIdSchema.openapi({
-    example: 'notification_channel_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  accountSettingsId: z.string().openapi({
-    example: 'account_setting_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  channelType: z.nativeEnum(NotificationChannelType).openapi({
-    example: NotificationChannelType.SLACK,
-  }),
-  name: z.string().openapi({
-    example: 'Compliance Alerts',
-  }),
-  enabled: z.boolean().openapi({
-    example: true,
-  }),
-  settings: NotificationChannelSettingsSchema,
-});
-export type INotificationChannelZod = z.infer<typeof INotificationChannelZod>;
-
-export const INotificationChannelTriggerZod = IBaseEntity.extend({
-  id: notificationChannelTriggerIdSchema.openapi({
-    example: 'notification_channel_trigger_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  notificationChannelId: notificationChannelIdSchema.openapi({
-    example: 'notification_channel_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  activityTypeId: z.string().openapi({
-    example: 'activity_type_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  enabled: z.boolean().openapi({
-    example: true,
-  }),
-});
-export type INotificationChannelTriggerZod = z.infer<
-  typeof INotificationChannelTriggerZod
->;
-
-export const INotificationRecordZod = IBaseEntity.extend({
-  id: notificationRecordIdSchema.openapi({
-    example: 'notification_record_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  notificationChannelId: notificationChannelIdSchema.openapi({
-    example: 'notification_channel_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  activityId: z.string().nullable().openapi({
-    example: 'activity_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  targetTable: z.string().openapi({
-    example: 'trades',
-  }),
-  targetId: z.string().openapi({
-    example: 'trade_01j5y5ghx8fvc83dmx3pznq7hv',
-  }),
-  status: z.nativeEnum(NotificationRecordStatus).openapi({
-    example: NotificationRecordStatus.SENT,
-  }),
-  payload: NotificationPayloadSchema,
-  response: NotificationResponseSchema.nullable(),
-  errorMessage: z.string().nullable().openapi({
-    example: null,
-  }),
-  retryCount: z.number().openapi({
-    example: 0,
-  }),
-  sentAt: z.date().nullable().openapi({
-    example: new Date(),
-  }),
-});
-export type INotificationRecordZod = z.infer<typeof INotificationRecordZod>;