@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/common/types/email-theme.types.ts

@@ -0,0 +1,442 @@
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { accountIdSchema } from './account.types';
+import {
+  AccountZod,
+  HexCodeColorSchema,
+  IPaginationMeta,
+  ThemeScope,
+} from './common.types';
+import { EmailTemplatesType } from './mail-template.types';
+import { userIdSchema } from './user.types';
+import { tradeIdSchema } from './trade.types';
+import { TaskType } from './task.types';
+
+export const emailThemeIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'email_theme';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid email theme ID format. Must be a valid TypeID with "email_theme" prefix. Example: email_theme_01j5y5ghx5fg68d663j1fvy2x7`,
+  },
+);
+
+export const emailThemeSettingIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'email_theme_setting';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid email theme setting ID format. Must be a valid TypeID with "email_theme_setting" prefix. Example: email_theme_setting_01j5y5ghx5fg68d663j1fvy2x7`,
+  },
+);
+
+export const EmailThemeFiltersZod = z.object({
+  accountId: accountIdSchema.optional(),
+});
+export type EmailThemeFiltersZod = z.infer<typeof EmailThemeFiltersZod>;
+
+export const GetEmailThemeZod = z.object({
+  id: emailThemeIdSchema,
+  name: z.string().nullable(),
+  accountId: z.lazy(() => accountIdSchema).nullable(),
+});
+export type GetEmailThemeZod = z.infer<typeof GetEmailThemeZod>;
+
+export const EmailThemesList = z.object({
+  items: z.array(GetEmailThemeZod),
+});
+export type EmailThemesList = z.infer<typeof EmailThemesList>;
+
+export const EmailThemeSettingsZod = z.object({
+  id: emailThemeSettingIdSchema,
+  name: z.string().nullable(),
+  category: z.string().nullable(),
+  darkMode: z.string().nullable(),
+  lightMode: z.string().nullable(),
+});
+
+export const IEmailTheme = z.object({
+  id: emailThemeIdSchema,
+  name: z.string().nullable(),
+  accountId: z.lazy(() => accountIdSchema).nullable(),
+  account: z
+    .lazy(() => AccountZod)
+    .optional()
+    .nullable(),
+});
+
+export type IEmailTheme = z.infer<typeof IEmailTheme>;
+
+export const IEmailThemeSetting = z.object({
+  id: emailThemeSettingIdSchema,
+  name: z.string().nullable(),
+  category: z.string().nullable(),
+  darkMode: z.string().nullable(),
+  lightMode: z.string().nullable(),
+  emailThemeId: emailThemeIdSchema.nullable(),
+  theme: z
+    .lazy(() => IEmailTheme)
+    .optional()
+    .nullable(),
+});
+export type IEmailThemeSetting = z.infer<typeof IEmailThemeSetting>;
+
+export const IEmailThemeSettings = z.array(IEmailThemeSetting);
+export type IEmailThemeSettings = z.infer<typeof IEmailThemeSettings>;
+
+const emailThemesInclude = z.enum(['site', 'emailThemeSettings']);
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(ThemesIncludeQuery),
+ */
+export const EmailThemesIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          emailThemesInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${emailThemesInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${emailThemesInclude.options.join(',')}`,
+    }),
+});
+
+export const IPaginatedEmailTheme = z.object({
+  items: z.array(IEmailTheme),
+  meta: IPaginationMeta,
+});
+export type IPaginatedEmailTheme = z.infer<typeof IPaginatedEmailTheme>;
+
+export const PostEmailThemeZod = z.object({
+  name: z.string().min(2).max(50).openapi({ example: 'email_theme_name' }),
+  emailThemeId: emailThemeIdSchema.openapi({
+    example: 'email_theme_01j5y5ghx5fg68d663j1fvy2x7',
+  }),
+});
+export type PostEmailThemeZod = z.infer<typeof PostEmailThemeZod>;
+
+export const CompliancePostEmailThemeZod = PostEmailThemeZod.extend({
+  scope: z.nativeEnum(ThemeScope).default(ThemeScope.ACCOUNT),
+  accountId: accountIdSchema
+    .openapi({
+      example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
+    })
+    .nullable()
+    .optional(),
+  emailThemeId: emailThemeIdSchema.nullable().optional(),
+}).superRefine((data, ctx) => {
+  if (data.scope === ThemeScope.ACCOUNT) {
+    if (!data.accountId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Account Id is required when scope is ACCOUNT',
+      });
+    }
+    if (!data.emailThemeId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'Email Theme Id is required when scope is ACCOUNT',
+      });
+    }
+  }
+});
+export type CompliancePostEmailThemeZod = z.infer<
+  typeof CompliancePostEmailThemeZod
+>;
+
+export const PatchEmailThemeSetting = z.object({
+  darkMode: HexCodeColorSchema.optional(),
+  lightMode: HexCodeColorSchema.optional(),
+});
+
+export type PatchEmailThemeSetting = z.infer<typeof PatchEmailThemeSetting>;
+
+export const CompliancePatchEmailThemeSetting = PatchEmailThemeSetting.extend({
+  accountId: accountIdSchema.nullable().default(null).openapi({
+    example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
+  }),
+});
+export type CompliancePatchEmailThemeSetting = z.infer<
+  typeof CompliancePatchEmailThemeSetting
+>;
+
+export const PatchEmailThemeSettings = z
+  .array(
+    PatchEmailThemeSetting.extend({
+      id: emailThemeSettingIdSchema.openapi({
+        example: 'email_theme_setting_01j5y5ghx5fg68d663j1fvy2x7',
+      }),
+    }),
+  )
+  .min(1);
+
+export type PatchEmailThemeSettings = z.infer<typeof PatchEmailThemeSettings>;
+
+export const CompliancePatchEmailThemeSettings = z.object({
+  accountId: accountIdSchema.nullable().default(null).openapi({
+    example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
+  }),
+  emailThemeSettings: PatchEmailThemeSettings,
+});
+export type CompliancePatchEmailThemeSettings = z.infer<
+  typeof CompliancePatchEmailThemeSettings
+>;
+export const EmailThemeExportZod = z.object({
+  name: z.string().nullable(),
+  category: z.string().nullable(),
+  lightMode: HexCodeColorSchema.nullable(),
+  darkMode: HexCodeColorSchema.nullable(),
+});
+export type EmailThemeExportZod = z.infer<typeof EmailThemeExportZod>;
+
+export const PatchEmailThemeSettingWithName = z.object({
+  name: z.string(),
+  category: z.string(),
+  darkMode: HexCodeColorSchema.optional(),
+  lightMode: HexCodeColorSchema.optional(),
+});
+
+export type PatchEmailThemeSettingWithName = z.infer<
+  typeof PatchEmailThemeSettingWithName
+>;
+
+export const ImportEmailThemeSettingsZod = z.array(
+  PatchEmailThemeSettingWithName,
+);
+export type ImportEmailThemeSettingsZod = z.infer<
+  typeof ImportEmailThemeSettingsZod
+>;
+
+export const ComplianceImportEmailThemeSettingsZod = z.object({
+  accountId: accountIdSchema.openapi({
+    example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
+  }),
+  emailThemeSettings: ImportEmailThemeSettingsZod,
+});
+export type ComplianceImportEmailThemeSettingsZod = z.infer<
+  typeof ComplianceImportEmailThemeSettingsZod
+>;
+
+export const ExportEmailThemeSettingsZod = z.array(EmailThemeExportZod);
+export type ExportEmailThemeSettingsZod = z.infer<
+  typeof ExportEmailThemeSettingsZod
+>;
+
+export const PatchEmailThemeNameZod = z.object({
+  name: z.string().min(2).max(50).openapi({ example: 'green' }),
+});
+export type PatchEmailThemeNameZod = z.infer<typeof PatchEmailThemeNameZod>;
+
+export const CompliancePatchEmailThemeNameZod = PatchEmailThemeNameZod.extend({
+  accountId: accountIdSchema.nullable().optional().openapi({
+    example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
+  }),
+});
+export type CompliancePatchEmailThemeNameZod = z.infer<
+  typeof CompliancePatchEmailThemeNameZod
+>;
+
+export const PreviewEmailThemeResponse = z.object({
+  emailPreview: z.string(),
+  subject: z.string().nullable().optional(),
+  senderName: z.string().nullable().optional(),
+});
+export type PreviewEmailThemeResponse = z.infer<
+  typeof PreviewEmailThemeResponse
+>;
+
+export const SendPreviewEmailResponse = z.object({
+  message: z.string(),
+});
+export type SendPreviewEmailResponse = z.infer<typeof SendPreviewEmailResponse>;
+
+export const SendPreviewEmailZod = z.object({
+  email: z.string().email().openapi({ example: 'test@test.com' }),
+});
+export type SendPreviewEmailZod = z.infer<typeof SendPreviewEmailZod>;
+
+export const ComplianceSendPreviewEmailZod = SendPreviewEmailZod.extend({
+  accountId: accountIdSchema.openapi({
+    example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
+  }),
+});
+export type ComplianceSendPreviewEmailZod = z.infer<
+  typeof ComplianceSendPreviewEmailZod
+>;
+
+export const GetEmailThemesAdminQuery = z.object({
+  accountId: accountIdSchema.optional(),
+  search: z.string().max(50).optional(),
+});
+export type GetEmailThemesAdminQuery = z.infer<typeof GetEmailThemesAdminQuery>;
+
+export const CreateDefaultEmailThemeSettingsZod = z.object({
+  name: z.string(),
+  category: z.string(),
+  darkMode: z.string(),
+  lightMode: z.string(),
+  emailThemeId: emailThemeIdSchema,
+});
+export type CreateDefaultEmailThemeSettingsZod = z.infer<
+  typeof CreateDefaultEmailThemeSettingsZod
+>;
+
+export const EMAIL_THEME_SETTINGS_CATEGORIES = {
+  header: ['background-color', 'text-color'],
+  footer: ['background-color', 'text-primary-color'],
+  content: [
+    'text-primary-color',
+    'text-secondary-color',
+    'primary-background-color',
+    'secondary-background-color',
+  ],
+  button: ['background-color', 'text-color'],
+  link: ['text-color'],
+  body: ['background-color'],
+};
+
+export const PreviewEmailThemeZod = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(EmailTemplatesType.WELCOME_ISSUER),
+    userId: userIdSchema,
+    to: z.string().email(),
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.WELCOME_INVESTOR),
+    userId: userIdSchema,
+    to: z.string().email(),
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.RESET_PASSWORD),
+    userId: userIdSchema,
+    to: z.string().email(),
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.RESET_PASSWORD_SUCCESS),
+    userId: userIdSchema,
+    to: z.string().email(),
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.ORDER_PLACED),
+    tradeId: tradeIdSchema,
+    to: z.string().email(),
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.ORDER_APPROVED),
+    tradeId: tradeIdSchema,
+    to: z.string().email(),
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.PAYMENT_FAILED),
+    tradeId: tradeIdSchema,
+    to: z.string().email(),
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.TASK_ASSIGNED),
+    taskType: z.nativeEnum(TaskType),
+    to: z.string().email(),
+  }),
+]);
+export type PreviewEmailThemeZod = z.infer<typeof PreviewEmailThemeZod>;
+
+export const CompliancePreviewEmailThemeZod = z
+  .object({
+    accountId: accountIdSchema.openapi({
+      example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
+    }),
+  })
+  .and(PreviewEmailThemeZod);
+export type CompliancePreviewEmailThemeZod = z.infer<
+  typeof CompliancePreviewEmailThemeZod
+>;
+
+export const GenerateTemplatePreviewHtmlZod = z.discriminatedUnion('type', [
+  z.object({
+    type: z.literal(EmailTemplatesType.WELCOME_ISSUER),
+    userId: userIdSchema,
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.WELCOME_INVESTOR),
+    userId: userIdSchema,
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.RESET_PASSWORD),
+    userId: userIdSchema,
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.RESET_PASSWORD_SUCCESS),
+    userId: userIdSchema,
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.ORDER_PLACED),
+    tradeId: tradeIdSchema,
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.ORDER_APPROVED),
+    tradeId: tradeIdSchema,
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.PAYMENT_FAILED),
+    tradeId: tradeIdSchema,
+  }),
+  z.object({
+    type: z.literal(EmailTemplatesType.TASK_ASSIGNED),
+    taskType: z.nativeEnum(TaskType),
+  }),
+]);
+
+export type GenerateTemplatePreviewHtmlZod = z.infer<
+  typeof GenerateTemplatePreviewHtmlZod
+>;
+
+export const ComplianceGenerateTemplatePreviewHtmlZod = z
+  .object({
+    accountId: accountIdSchema.openapi({
+      example: 'account_01j5y5ghx5fg68d663j1fvy2x7',
+    }),
+  })
+  .and(GenerateTemplatePreviewHtmlZod);
+export type ComplianceGenerateTemplatePreviewHtmlZod = z.infer<
+  typeof ComplianceGenerateTemplatePreviewHtmlZod
+>;
+
+export const GetDefaultEmailThemeZod = z.object({
+  id: emailThemeIdSchema,
+  name: z.string().nullable(),
+});
+export type GetDefaultEmailThemeZod = z.infer<typeof GetDefaultEmailThemeZod>;
+
+export const GetDefaultEmailThemesZod = z.array(GetDefaultEmailThemeZod);
+export type GetDefaultEmailThemesZod = z.infer<typeof GetDefaultEmailThemesZod>;
+export const DefaultEmailThemesZod = z.object({
+  emailThemes: z.array(
+    z.object({
+      name: z.string(),
+      emailThemeSettings: z.array(
+        z.object({
+          category: z.string(),
+          name: z.string(),
+          lightMode: HexCodeColorSchema,
+        }),
+      ),
+    }),
+  ),
+});
+export type DefaultEmailThemesZod = z.infer<typeof DefaultEmailThemesZod>;

package/src/common/types/entity.types.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+extendZodWithOpenApi(z);
+
+export const dateOrString = z.union([z.string().datetime(), z.date()]);
+
+export const IBaseEntity = z.object({
+  id: z
+    .string()
+    .openapi({ example: 'entityprefix_01j1xgme5qeqq97gpdztd7e4a6' }),
+  __entity: z.string().optional().openapi({ example: 'Entity' }),
+  createdAt: dateOrString.openapi({ example: new Date() }),
+  updatedAt: dateOrString.openapi({ example: new Date() }),
+  deletedAt: dateOrString.nullable().openapi({ example: new Date() }),
+});

package/src/common/types/error-responses.types.ts

@@ -0,0 +1,135 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+extendZodWithOpenApi(z);
+
+export const BadRequestError = z.object({
+  status: z.number().openapi({
+    example: '400',
+  }),
+  message: z.string().openapi({
+    example: 'BAD_REQUEST',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['invalid email'],
+  }),
+});
+
+export const UnauthorizedError = z.object({
+  status: z.number().openapi({
+    example: '401',
+  }),
+  message: z.string().openapi({
+    example: 'UNAUTHORIZED',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['unauthorized'],
+  }),
+});
+
+export const ForbiddenError = z.object({
+  status: z.number().openapi({
+    example: '403',
+  }),
+  message: z.string().openapi({
+    example: 'FORBIDDEN',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['forbidden resource'],
+  }),
+});
+
+export const NotFoundError = z.object({
+  status: z.number().openapi({
+    example: '404',
+  }),
+  message: z.string().openapi({
+    example: 'NOT_FOUND',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['User not found'],
+  }),
+});
+
+export const ConflictError = z.object({
+  status: z.number().openapi({
+    example: '409',
+  }),
+  message: z.string().openapi({
+    example: 'CONFLICT',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['resource conflicted'],
+  }),
+});
+
+export const PreconditionFailedError = z.object({
+  status: z.number().openapi({
+    example: '412',
+  }),
+  message: z.string().openapi({
+    example: 'PRECONDITION_FAILED',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['precondition failed'],
+  }),
+});
+
+export const UnprocessableError = z.object({
+  status: z.number().openapi({
+    example: '422',
+  }),
+  message: z.string().openapi({
+    example: 'UNPROCESSABLE_ENTITY',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['file is required'],
+  }),
+});
+
+export const InternalError = z.object({
+  status: z.number().openapi({
+    example: '500',
+  }),
+  message: z.string().openapi({
+    example: 'INTERNAL_SERVER_ERROR',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['error occurred'],
+  }),
+});
+
+export const NotImplementedError = z.object({
+  status: z.number().openapi({
+    example: '501',
+  }),
+  message: z.string().openapi({
+    example: 'NOT_IMPLEMENTED',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['not implemented'],
+  }),
+});
+
+export const BadGateWayError = z.object({
+  status: z.number().openapi({
+    example: '502',
+  }),
+  message: z.string().openapi({
+    example: 'BAD_GATEWAY',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['bad gateway'],
+  }),
+});
+
+export const ServiceUnavailableError = z.object({
+  status: z.number().openapi({
+    example: '503',
+  }),
+  message: z.string().openapi({
+    example: 'SERVICE_UNAVAILABLE',
+  }),
+  errors: z.array(z.string()).openapi({
+    example: ['service unavailable'],
+  }),
+});

package/src/common/types/escrow-account.types.ts

@@ -0,0 +1,104 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { z } from 'zod';
+import { AccountZod, IPaginationMeta } from './common.types';
+import { IBaseEntity } from './entity.types';
+import { TypeID } from 'typeid-js';
+import { accountIdSchema } from './account.types';
+
+extendZodWithOpenApi(z);
+
+export const escrowAccountIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'escrow_account';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid escrow account ID format. Must be a valid TypeID with "escrow_account" prefix.',
+  },
+);
+
+export const IEscrowAccount = IBaseEntity.extend({
+  accountNumber: z.string().optional().nullable(),
+  routingNumber: z.string().optional().nullable(),
+  accountName: z.string(),
+  agentEmail: z.string(),
+  agentName: z.string(),
+  accountId: accountIdSchema,
+  account: AccountZod.optional().nullable(),
+});
+export type IEscrowAccount = z.infer<typeof IEscrowAccount>;
+
+export const IPaginatedEscrowAccount = z.object({
+  items: z.array(IEscrowAccount),
+  meta: IPaginationMeta,
+});
+export type IPaginatedEscrowAccount = z.infer<typeof IPaginatedEscrowAccount>;
+export const PostEscrowAccount = z.object({
+  accountName: z.string().min(2).max(50).openapi({ example: 'Bulk' }),
+  accountNumber: z.string().optional().nullable(),
+  routingNumber: z.string().min(9).max(9).optional().nullable(),
+  agentName: z.string().min(2).max(50),
+  agentEmail: z.string().email(),
+});
+
+export type PostEscrowAccount = z.infer<typeof PostEscrowAccount>;
+
+export const CompliancePostEscrowAccount = PostEscrowAccount.extend({
+  accountId: accountIdSchema,
+});
+export type CompliancePostEscrowAccount = z.infer<
+  typeof CompliancePostEscrowAccount
+>;
+
+export const PatchEscrowAccount = z.object({
+  accountName: z
+    .string()
+    .min(2)
+    .max(50)
+    .openapi({ example: 'Bulk' })
+    .optional(),
+  accountNumber: z.string().min(10).max(18).optional().nullable().optional(),
+  routingNumber: z.string().min(9).max(9).optional().nullable().optional(),
+  agentName: z.string().min(2).max(50).optional(),
+  agentEmail: z.string().email().optional(),
+});
+
+export type PatchEscrowAccount = z.infer<typeof PatchEscrowAccount>;
+
+const escrowAccountsInclude = z.enum(['account']);
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(EscrowAccountsIncludeQuery),
+ */
+export const EscrowAccountsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          escrowAccountsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${escrowAccountsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${escrowAccountsInclude.options.join(',')}`,
+    }),
+});
+export interface EscrowAccountsIncludeQuery
+  extends z.infer<typeof EscrowAccountsIncludeQuery> {}
+
+export const EscrowAccountsFilter = z.object({
+  accountId: accountIdSchema.optional(),
+  search: z.string().optional(),
+});
+export interface EscrowAccountsFilter
+  extends z.infer<typeof EscrowAccountsFilter> {}