@open-mercato/core 0.4.5-develop-754ef4d2f0 → 0.4.5-develop-9f9549ebc8

package/src/modules/messages/data/entities.ts

@@ -0,0 +1,284 @@
+import { Entity, PrimaryKey, Property, Index, OptionalProps, Unique } from '@mikro-orm/core'
+
+export type MessageStatus = 'draft' | 'sent'
+export type MessagePriority = 'low' | 'normal' | 'high' | 'urgent'
+export type MessageBodyFormat = 'text' | 'markdown'
+
+export type MessageAction = {
+  id: string
+  label: string
+  labelKey?: string
+  variant?: 'default' | 'secondary' | 'destructive' | 'outline' | 'ghost'
+  icon?: string
+  commandId?: string
+  href?: string
+  isTerminal?: boolean
+  confirmRequired?: boolean
+  confirmMessage?: string
+}
+
+export type MessageActionData = {
+  actions: MessageAction[]
+  primaryActionId?: string
+  expiresAt?: string
+}
+
+@Entity({ tableName: 'messages' })
+@Index({ name: 'messages_sender_idx', properties: ['senderUserId', 'sentAt'] })
+@Index({ name: 'messages_thread_idx', properties: ['threadId'] })
+@Index({ name: 'messages_type_idx', properties: ['type', 'tenantId'] })
+@Index({ name: 'messages_tenant_idx', properties: ['tenantId', 'organizationId'] })
+export class Message {
+  [OptionalProps]?: 'type' | 'status' | 'priority' | 'bodyFormat' | 'isDraft' | 'createdAt' | 'updatedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'type', type: 'text' })
+  type: string = 'default'
+
+  @Property({ name: 'thread_id', type: 'uuid', nullable: true })
+  threadId?: string | null
+
+  @Property({ name: 'parent_message_id', type: 'uuid', nullable: true })
+  parentMessageId?: string | null
+
+  @Property({ name: 'sender_user_id', type: 'uuid' })
+  senderUserId!: string
+
+  @Property({ name: 'subject', type: 'text' })
+  subject!: string
+
+  @Property({ name: 'body', type: 'text' })
+  body!: string
+
+  @Property({ name: 'body_format', type: 'text' })
+  bodyFormat: MessageBodyFormat = 'text'
+
+  @Property({ name: 'priority', type: 'text' })
+  priority: MessagePriority = 'normal'
+
+  @Property({ name: 'status', type: 'text' })
+  status: MessageStatus = 'draft'
+
+  @Property({ name: 'is_draft', type: 'boolean' })
+  isDraft: boolean = true
+
+  @Property({ name: 'sent_at', type: Date, nullable: true })
+  sentAt?: Date | null
+
+  @Property({ name: 'action_data', type: 'json', nullable: true })
+  actionData?: MessageActionData | null
+
+  @Property({ name: 'action_result', type: 'json', nullable: true })
+  actionResult?: Record<string, unknown> | null
+
+  @Property({ name: 'action_taken', type: 'text', nullable: true })
+  actionTaken?: string | null
+
+  @Property({ name: 'action_taken_by_user_id', type: 'uuid', nullable: true })
+  actionTakenByUserId?: string | null
+
+  @Property({ name: 'action_taken_at', type: Date, nullable: true })
+  actionTakenAt?: Date | null
+
+  @Property({ name: 'send_via_email', type: 'boolean', default: false })
+  sendViaEmail: boolean = false
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'organization_id', type: 'uuid', nullable: true })
+  organizationId?: string | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+
+  @Property({ name: 'visibility', type: 'text', nullable: true })
+  visibility?: 'public' | 'internal' | null
+
+  @Property({ name: 'source_entity_type', type: 'text', nullable: true })
+  sourceEntityType?: string | null
+
+  @Property({ name: 'source_entity_id', type: 'uuid', nullable: true })
+  sourceEntityId?: string | null
+
+  @Property({ name: 'external_email', type: 'text', nullable: true })
+  externalEmail?: string | null
+
+  @Property({ name: 'external_name', type: 'text', nullable: true })
+  externalName?: string | null
+
+  @Property({ name: 'external_email_sent_at', type: Date, nullable: true })
+  externalEmailSentAt?: Date | null
+
+  @Property({ name: 'external_email_failed_at', type: Date, nullable: true })
+  externalEmailFailedAt?: Date | null
+
+  @Property({ name: 'external_email_error', type: 'text', nullable: true })
+  externalEmailError?: string | null
+}
+
+export type RecipientType = 'to' | 'cc' | 'bcc'
+export type RecipientStatus = 'unread' | 'read' | 'archived' | 'deleted'
+
+@Entity({ tableName: 'message_recipients' })
+@Index({ name: 'message_recipients_user_idx', properties: ['recipientUserId', 'status'] })
+@Index({ name: 'message_recipients_message_idx', properties: ['messageId'] })
+@Unique({ name: 'message_recipients_message_user_unique', properties: ['messageId', 'recipientUserId'] })
+export class MessageRecipient {
+  [OptionalProps]?: 'recipientType' | 'status' | 'createdAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'message_id', type: 'uuid' })
+  messageId!: string
+
+  @Property({ name: 'recipient_user_id', type: 'uuid' })
+  recipientUserId!: string
+
+  @Property({ name: 'recipient_type', type: 'text' })
+  recipientType: RecipientType = 'to'
+
+  @Property({ name: 'status', type: 'text' })
+  status: RecipientStatus = 'unread'
+
+  @Property({ name: 'read_at', type: Date, nullable: true })
+  readAt?: Date | null
+
+  @Property({ name: 'archived_at', type: Date, nullable: true })
+  archivedAt?: Date | null
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+
+  @Property({ name: 'email_sent_at', type: Date, nullable: true })
+  emailSentAt?: Date | null
+
+  @Property({ name: 'email_delivered_at', type: Date, nullable: true })
+  emailDeliveredAt?: Date | null
+
+  @Property({ name: 'email_opened_at', type: Date, nullable: true })
+  emailOpenedAt?: Date | null
+
+  @Property({ name: 'email_failed_at', type: Date, nullable: true })
+  emailFailedAt?: Date | null
+
+  @Property({ name: 'email_error', type: 'text', nullable: true })
+  emailError?: string | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+}
+
+@Entity({ tableName: 'message_objects' })
+@Index({ name: 'message_objects_message_idx', properties: ['messageId'] })
+@Index({ name: 'message_objects_entity_idx', properties: ['entityType', 'entityId'] })
+export class MessageObject {
+  [OptionalProps]?: 'actionRequired' | 'createdAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'message_id', type: 'uuid' })
+  messageId!: string
+
+  @Property({ name: 'entity_module', type: 'text' })
+  entityModule!: string
+
+  @Property({ name: 'entity_type', type: 'text' })
+  entityType!: string
+
+  @Property({ name: 'entity_id', type: 'uuid' })
+  entityId!: string
+
+  @Property({ name: 'action_required', type: 'boolean' })
+  actionRequired: boolean = false
+
+  @Property({ name: 'action_type', type: 'text', nullable: true })
+  actionType?: string | null
+
+  @Property({ name: 'action_label', type: 'text', nullable: true })
+  actionLabel?: string | null
+
+  @Property({ name: 'entity_snapshot', type: 'json', nullable: true })
+  entitySnapshot?: Record<string, unknown> | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+}
+
+@Entity({ tableName: 'message_access_tokens' })
+@Index({ name: 'message_access_tokens_token_idx', properties: ['token'] })
+@Index({ name: 'message_access_tokens_message_idx', properties: ['messageId'] })
+export class MessageAccessToken {
+  [OptionalProps]?: 'createdAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'message_id', type: 'uuid' })
+  messageId!: string
+
+  @Property({ name: 'recipient_user_id', type: 'uuid' })
+  recipientUserId!: string
+
+  @Property({ name: 'token', type: 'text', unique: true })
+  token!: string
+
+  @Property({ name: 'expires_at', type: Date })
+  expiresAt!: Date
+
+  @Property({ name: 'used_at', type: Date, nullable: true })
+  usedAt?: Date | null
+
+  @Property({ name: 'use_count', type: 'int', default: 0 })
+  useCount: number = 0
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+}
+
+@Entity({ tableName: 'message_confirmations' })
+@Index({ name: 'message_confirmations_message_idx', properties: ['messageId'] })
+@Index({ name: 'message_confirmations_scope_idx', properties: ['tenantId', 'organizationId'] })
+@Unique({ name: 'message_confirmations_message_unique', properties: ['messageId'] })
+export class MessageConfirmation {
+  [OptionalProps]?: 'confirmed' | 'createdAt' | 'updatedAt'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @Property({ name: 'message_id', type: 'uuid' })
+  messageId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'organization_id', type: 'uuid', nullable: true })
+  organizationId?: string | null
+
+  @Property({ name: 'confirmed', type: 'boolean' })
+  confirmed: boolean = true
+
+  @Property({ name: 'confirmed_by_user_id', type: 'uuid', nullable: true })
+  confirmedByUserId?: string | null
+
+  @Property({ name: 'confirmed_at', type: Date, nullable: true })
+  confirmedAt?: Date | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+}
+
+export default [Message, MessageRecipient, MessageObject, MessageAccessToken, MessageConfirmation]

package/src/modules/messages/data/validators.ts

@@ -0,0 +1,297 @@
+import { z } from 'zod'
+
+function collectDuplicateRecipientIds(
+  recipients: Array<{ userId: string }>,
+): string[] {
+  const seen = new Set<string>()
+  const duplicates = new Set<string>()
+  for (const recipient of recipients) {
+    if (seen.has(recipient.userId)) {
+      duplicates.add(recipient.userId)
+      continue
+    }
+    seen.add(recipient.userId)
+  }
+  return Array.from(duplicates)
+}
+
+function validateDefaultWithObjectsPayload(
+  value: {
+    type?: string
+    objects?: Array<{ actionRequired?: boolean; actionType?: string; actionLabel?: string }>
+  },
+  ctx: z.RefinementCtx,
+): void {
+  if (value.type !== 'messages.defaultWithObjects') return
+
+  if (!Array.isArray(value.objects) || value.objects.length === 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['objects'],
+      message: 'at least one object is required for messages.defaultWithObjects',
+    })
+    return
+  }
+
+  value.objects.forEach((object, index) => {
+    if (object.actionRequired === true) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['objects', index, 'actionRequired'],
+        message: 'actionRequired must be false for messages.defaultWithObjects',
+      })
+    }
+    if (typeof object.actionType === 'string' && object.actionType.trim().length > 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['objects', index, 'actionType'],
+        message: 'actionType is not allowed for messages.defaultWithObjects',
+      })
+    }
+    if (typeof object.actionLabel === 'string' && object.actionLabel.trim().length > 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['objects', index, 'actionLabel'],
+        message: 'actionLabel is not allowed for messages.defaultWithObjects',
+      })
+    }
+  })
+}
+
+export const messageRecipientSchema = z.object({
+  userId: z.string().uuid(),
+  type: z.enum(['to', 'cc', 'bcc']).optional().default('to'),
+})
+
+export const messageObjectSchema = z.object({
+  entityModule: z.string().min(1),
+  entityType: z.string().min(1),
+  entityId: z.string().uuid(),
+  actionRequired: z.boolean().optional().default(false),
+  actionType: z.string().optional(),
+  actionLabel: z.string().optional(),
+})
+
+export const messageActionSchema = z.object({
+  id: z.string().min(1),
+  label: z.string().min(1),
+  labelKey: z.string().optional(),
+  variant: z.enum(['default', 'secondary', 'destructive', 'outline', 'ghost']).optional(),
+  icon: z.string().optional(),
+  commandId: z.string().optional(),
+  href: z.string().optional(),
+  isTerminal: z.boolean().optional(),
+  confirmRequired: z.boolean().optional(),
+  confirmMessage: z.string().optional(),
+})
+
+export const messageActionDataSchema = z.object({
+  actions: z.array(messageActionSchema),
+  primaryActionId: z.string().optional(),
+  expiresAt: z.string().datetime().optional(),
+})
+
+export const composeMessageSchema = z.object({
+  type: z.string().optional().default('default'),
+  visibility: z.enum(['public', 'internal']).nullable().optional(),
+  sourceEntityType: z.string().min(1).optional(),
+  sourceEntityId: z.string().uuid().optional(),
+  externalEmail: z.string().email().optional(),
+  externalName: z.string().min(1).max(255).optional(),
+  recipients: z.array(messageRecipientSchema).max(100).optional().default([]),
+  subject: z.string().max(500).optional().default(''),
+  body: z.string().max(50000).optional().default(''),
+  bodyFormat: z.enum(['text', 'markdown']).optional().default('text'),
+  priority: z.enum(['low', 'normal', 'high', 'urgent']).optional().default('normal'),
+  objects: z.array(messageObjectSchema).optional(),
+  attachmentIds: z.array(z.string().uuid()).optional(),
+  attachmentRecordId: z.string().min(1).max(255).optional(),
+  actionData: messageActionDataSchema.optional(),
+  sendViaEmail: z.boolean().optional().default(false),
+  parentMessageId: z.string().uuid().optional(),
+  isDraft: z.boolean().optional().default(false),
+}).superRefine((value, ctx) => {
+  const isDraft = value.isDraft ?? false
+  const visibility = value.visibility ?? 'internal'
+  const recipientCount = value.recipients.length
+  const hasExternalEmail = Boolean(value.externalEmail?.trim())
+  const hasSubject = value.subject.trim().length > 0
+  const hasBody = value.body.trim().length > 0
+
+  if (!isDraft) {
+    if (visibility === 'public') {
+      if (!hasExternalEmail) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['externalEmail'],
+          message: 'externalEmail is required when visibility is public',
+        })
+      }
+      if (recipientCount > 0) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['recipients'],
+          message: 'recipients must be empty when visibility is public',
+        })
+      }
+    } else if (recipientCount === 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['recipients'],
+        message: 'at least one recipient is required when visibility is internal',
+      })
+    }
+
+    if (!hasSubject) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['subject'],
+        message: 'subject is required',
+      })
+    }
+    if (!hasBody) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['body'],
+        message: 'body is required',
+      })
+    }
+  }
+
+  const duplicateRecipientIds = collectDuplicateRecipientIds(value.recipients)
+  if (duplicateRecipientIds.length > 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['recipients'],
+      message: 'recipient user ids must be unique',
+    })
+  }
+
+  validateDefaultWithObjectsPayload(value, ctx)
+})
+
+export const updateDraftSchema = z.object({
+  type: z.string().optional(),
+  visibility: z.enum(['public', 'internal']).nullable().optional(),
+  sourceEntityType: z.string().min(1).optional(),
+  sourceEntityId: z.string().uuid().optional(),
+  externalEmail: z.string().email().optional(),
+  externalName: z.string().min(1).max(255).optional(),
+  recipients: z.array(messageRecipientSchema).optional(),
+  subject: z.string().min(1).max(500).optional(),
+  body: z.string().min(1).max(50000).optional(),
+  bodyFormat: z.enum(['text', 'markdown']).optional(),
+  priority: z.enum(['low', 'normal', 'high', 'urgent']).optional(),
+  objects: z.array(messageObjectSchema).optional(),
+  attachmentIds: z.array(z.string().uuid()).optional(),
+  actionData: messageActionDataSchema.optional(),
+  sendViaEmail: z.boolean().optional(),
+}).superRefine((value, ctx) => {
+  if (value.recipients) {
+    const duplicateRecipientIds = collectDuplicateRecipientIds(value.recipients)
+    if (duplicateRecipientIds.length > 0) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['recipients'],
+        message: 'recipient user ids must be unique',
+      })
+    }
+  }
+
+  validateDefaultWithObjectsPayload(value, ctx)
+})
+
+export const listMessagesSchema = z.object({
+  folder: z.enum(['inbox', 'sent', 'drafts', 'archived', 'all']).optional().default('inbox'),
+  status: z.enum(['unread', 'read', 'archived']).optional(),
+  type: z.string().optional(),
+  visibility: z.enum(['public', 'internal']).optional(),
+  sourceEntityType: z.string().optional(),
+  sourceEntityId: z.string().uuid().optional(),
+  externalEmail: z.string().email().optional(),
+  hasObjects: z.coerce.boolean().optional(),
+  hasAttachments: z.coerce.boolean().optional(),
+  hasActions: z.coerce.boolean().optional(),
+  senderId: z.string().uuid().optional(),
+  search: z.string().max(200).optional(),
+  since: z.string().datetime().optional(),
+  page: z.coerce.number().int().min(1).optional().default(1),
+  pageSize: z.coerce.number().int().min(1).max(100).optional().default(20),
+})
+
+export const forwardMessageSchema = z.object({
+  recipients: z.array(messageRecipientSchema).min(1).max(100),
+  body: z.string().max(50000).optional(),
+  additionalBody: z.string().max(10000).optional(),
+  includeAttachments: z.boolean().optional().default(true),
+  sendViaEmail: z.boolean().optional().default(false),
+}).superRefine((value, ctx) => {
+  const duplicateRecipientIds = collectDuplicateRecipientIds(value.recipients)
+  if (duplicateRecipientIds.length > 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['recipients'],
+      message: 'recipient user ids must be unique',
+    })
+  }
+})
+
+export const replyMessageSchema = z.object({
+  body: z.string().min(1).max(50000),
+  bodyFormat: z.enum(['text', 'markdown']).optional().default('text'),
+  recipients: z.array(messageRecipientSchema).max(100).optional(),
+  attachmentIds: z.array(z.string().uuid()).optional(),
+  attachmentRecordId: z.string().min(1).max(255).optional(),
+  replyAll: z.boolean().optional().default(false),
+  sendViaEmail: z.boolean().optional().default(false),
+}).superRefine((value, ctx) => {
+  if (!value.recipients) return
+  const duplicateRecipientIds = collectDuplicateRecipientIds(value.recipients)
+  if (duplicateRecipientIds.length > 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['recipients'],
+      message: 'recipient user ids must be unique',
+    })
+  }
+})
+
+export const executeActionSchema = z.object({
+  messageId: z.string().uuid(),
+  actionId: z.string().min(1),
+  payload: z.record(z.string(), z.unknown()).optional(),
+})
+
+export const confirmMessageSchema = z.object({
+  messageId: z.string().uuid(),
+  tenantId: z.string().uuid().optional(),
+  organizationId: z.string().uuid().nullable().optional(),
+  confirmed: z.boolean().optional().default(true),
+})
+
+export const messageObjectTypesQuerySchema = z.object({
+  messageType: z.string().min(1),
+})
+
+export const attachmentIdsPayloadSchema = z.object({
+  attachmentIds: z.array(z.string().uuid()).min(1).max(100),
+})
+
+export const unlinkAttachmentPayloadSchema = z.object({
+  attachmentId: z.string().uuid().optional(),
+  attachmentIds: z.array(z.string().uuid()).min(1).max(100).optional(),
+}).refine(
+  (value) => Boolean(value.attachmentId || value.attachmentIds?.length),
+  { message: 'attachmentId or attachmentIds is required' }
+)
+
+export type ComposeMessageInput = z.infer<typeof composeMessageSchema>
+export type UpdateDraftInput = z.infer<typeof updateDraftSchema>
+export type ListMessagesInput = z.infer<typeof listMessagesSchema>
+export type ForwardMessageInput = z.infer<typeof forwardMessageSchema>
+export type ReplyMessageInput = z.infer<typeof replyMessageSchema>
+export type ExecuteActionInput = z.infer<typeof executeActionSchema>
+export type ConfirmMessageInput = z.infer<typeof confirmMessageSchema>
+export type MessageObjectTypesQueryInput = z.infer<typeof messageObjectTypesQuerySchema>
+export type AttachmentIdsPayload = z.infer<typeof attachmentIdsPayloadSchema>
+export type UnlinkAttachmentPayload = z.infer<typeof unlinkAttachmentPayloadSchema>