@dalmore/api-contracts 1.0.3 → 1.0.5

package/src/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/src/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/src/common/types/notification.types.ts

@@ -1,58 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { z } from 'zod';
-import { TypeID } from 'typeid-js';
-import { accountIdSchema } from './account.types';
-
-extendZodWithOpenApi(z);
-export enum NotificationChannel {
-  EMAIL = 'EMAIL',
-  SLACK = 'SLACK',
-}
-export enum NotificationType {
-  COMPLIANCE_TRADE_ALERT = 'COMPLIANCE_TRADE_ALERT',
-  TRADE_ALERT = 'TRADE_ALERT',
-}
-
-export const notificationIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'notification';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid notification ID format. Must be a valid TypeID with "notification" prefix.',
-  },
-);
-
-export const SendNotificationZod = z.object({
-  message: z.string(),
-  subject: z.string(),
-  buttonText: z.string(),
-  link: z.string(),
-  debug: z.boolean().default(false),
-  notificationChannel: z.nativeEnum(NotificationChannel),
-  channelName: z.string(),
-  channelEmail: z.string().email(),
-  notificationType: z.nativeEnum(NotificationType),
-});
-export type SendNotificationZod = z.infer<typeof SendNotificationZod>;
-
-const SlackSettingsSchema = z.object({
-  channelName: z.string().min(1).max(50),
-  channelEmail: z.string().email(),
-});
-
-export const PostNotificationZod = z.object({
-  accountId: accountIdSchema,
-  notificationChannel: z.literal(NotificationChannel.SLACK), // Only Slack for now
-  notificationType: z.nativeEnum(NotificationType),
-  enabled: z.boolean().default(true),
-  debug: z.boolean().default(false),
-  settings: SlackSettingsSchema,
-});
-
-export type PostNotificationZod = z.infer<typeof PostNotificationZod>;