@open-mercato/documents 0.6.8-develop.7016.1.4ed7b1e49d

package/src/modules/documents/lib/duplicateContent.ts

@@ -0,0 +1,32 @@
+export type DuplicateAttachmentIdMap = ReadonlyMap<string, string>
+
+type RewriteDuplicateAttachmentUrlInput = {
+  sourceDocumentId: string
+  copyDocumentId: string
+  attachmentIds: DuplicateAttachmentIdMap
+}
+
+export function rewriteDuplicateAttachmentSrcUrl(
+  src: string,
+  input: RewriteDuplicateAttachmentUrlInput,
+): string {
+  const match = /^\/api\/documents\/([^/?#]+)\/attachments\/([^/?#]+)([?#].*)?$/.exec(src)
+  if (!match || match[1] !== input.sourceDocumentId) return src
+  const replacementAttachmentId = input.attachmentIds.get(match[2] ?? '')
+  if (!replacementAttachmentId) return src
+  return `/api/documents/${input.copyDocumentId}/attachments/${replacementAttachmentId}${match[3] ?? ''}`
+}
+
+export function rewriteDuplicateAttachmentUrls(
+  contentHtml: string,
+  input: RewriteDuplicateAttachmentUrlInput,
+): string {
+  return contentHtml.replace(
+    /((?<![\w-])src)(\s*=\s*)(["'])([^"']*)\3/gi,
+    (match: string, attribute: string, separator: string, quote: string, src: string) => {
+      const rewritten = rewriteDuplicateAttachmentSrcUrl(src, input)
+      if (rewritten === src) return match
+      return `${attribute}${separator}${quote}${rewritten}${quote}`
+    },
+  )
+}

package/src/modules/documents/lib/editorConfig.ts

@@ -0,0 +1,371 @@
+import { Mark, mergeAttributes, Node, type AnyExtension } from '@tiptap/core'
+import StarterKit from '@tiptap/starter-kit'
+import { Collaboration } from '@tiptap/extension-collaboration'
+import { CollaborationCaret } from '@tiptap/extension-collaboration-caret'
+import Link from '@tiptap/extension-link'
+import Image from '@tiptap/extension-image'
+import { Table } from '@tiptap/extension-table'
+import TableRow from '@tiptap/extension-table-row'
+import TableCell from '@tiptap/extension-table-cell'
+import TableHeader from '@tiptap/extension-table-header'
+import TaskList from '@tiptap/extension-task-list'
+import TaskItem from '@tiptap/extension-task-item'
+import Placeholder from '@tiptap/extension-placeholder'
+import { TextAlign } from '@tiptap/extension-text-align'
+import { Highlight } from '@tiptap/extension-highlight'
+import { TextStyle, Color } from '@tiptap/extension-text-style'
+import { CharacterCount } from '@tiptap/extensions'
+import {
+  firstSafeDocumentsDisplayLabel,
+  sanitizeDocumentsDisplayLabel,
+} from './displayLabels'
+import {
+  firstSafeCollaborationAwarenessName,
+  normalizeCollaborationColor,
+} from './collaborationAwareness'
+
+export type EntityRefAttributes = {
+  entityType: string
+  entityId: string
+  label: string
+  href: string | null
+  labelInvalid?: boolean
+}
+
+const DEFAULT_ENTITY_REF_FALLBACK_LABEL = 'Record'
+
+type HtmlLikeElement = {
+  getAttribute: (name: string) => string | null
+  textContent?: string | null
+}
+
+function isHtmlLikeElement(value: unknown): value is HtmlLikeElement {
+  return Boolean(
+    value &&
+    typeof value === 'object' &&
+    typeof (value as { getAttribute?: unknown }).getAttribute === 'function',
+  )
+}
+
+function readEntityRefAttribute(element: HtmlLikeElement, attribute: string): string | null {
+  const value = element.getAttribute(attribute)
+  return typeof value === 'string' && value.length > 0 ? value : null
+}
+
+function readEntityRefSnapshotLabel(element: HtmlLikeElement): string | null {
+  if (element.getAttribute('data-entity-label-invalid') !== null) return null
+  return firstSafeDocumentsDisplayLabel(
+    readEntityRefAttribute(element, 'data-label'),
+    element.textContent,
+  )
+}
+
+export function isSafeEntityHref(value: unknown): value is string {
+  if (
+    typeof value !== 'string'
+    || value !== value.trim()
+    || !value.startsWith('/backend/')
+    || value.startsWith('//')
+    || value.includes('\\')
+    || /[\u0000-\u001f\u007f]/.test(value)
+  ) {
+    return false
+  }
+
+  try {
+    const base = new URL('https://open-mercato.invalid')
+    const resolved = new URL(value, base)
+    return resolved.origin === base.origin && resolved.pathname.startsWith('/backend/')
+  } catch {
+    return false
+  }
+}
+
+type EntityRefPointerActivationEvent = {
+  target: EventTarget | null
+  metaKey: boolean
+  ctrlKey: boolean
+}
+
+type EntityRefKeyboardActivationEvent = {
+  target: EventTarget | null
+  key: string
+  preventDefault: () => void
+}
+
+type EntityHrefOpener = (href: string) => void
+
+function readClosestEntityHref(target: EventTarget | null, selector: string): string | null {
+  if (!target || typeof (target as { closest?: unknown }).closest !== 'function') return null
+  const element = (target as unknown as { closest: (value: string) => unknown }).closest(selector)
+  if (!element || typeof element !== 'object') return null
+  const dataset = (element as { dataset?: { href?: unknown } }).dataset
+  return isSafeEntityHref(dataset?.href) ? dataset.href : null
+}
+
+export function activateEntityRefFromPointerEvent(
+  event: EntityRefPointerActivationEvent,
+  openHref: EntityHrefOpener,
+): boolean {
+  if (!event.metaKey && !event.ctrlKey) return false
+  const href = readClosestEntityHref(event.target, 'span[data-entity-ref]')
+  if (!href) return false
+  openHref(href)
+  return true
+}
+
+export function activateEntityRefFromKeyboardEvent(
+  event: EntityRefKeyboardActivationEvent,
+  openHref: EntityHrefOpener,
+): boolean {
+  if (event.key !== 'Enter' && event.key !== ' ') return false
+  const href = readClosestEntityHref(event.target, 'span[data-entity-ref][role="link"]')
+  if (!href) return false
+  event.preventDefault()
+  openHref(href)
+  return true
+}
+
+const UnderlineMark = Mark.create({
+  name: 'underline',
+  parseHTML() {
+    return [{ tag: 'u' }]
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ['u', mergeAttributes(HTMLAttributes), 0]
+  },
+})
+
+function createEntityRefNode(configuredFallbackLabel: string | null) {
+  const fallbackLabel = sanitizeDocumentsDisplayLabel(configuredFallbackLabel)
+  return Node.create({
+    name: 'entityRef',
+    group: 'inline',
+    inline: true,
+    atom: true,
+    selectable: true,
+    addAttributes() {
+      return {
+        entityType: {
+          default: null,
+          parseHTML: (element: HtmlLikeElement) => readEntityRefAttribute(element, 'data-entity-type'),
+        },
+        entityId: {
+          default: null,
+          parseHTML: (element: HtmlLikeElement) => readEntityRefAttribute(element, 'data-entity-id'),
+        },
+        label: {
+          default: null,
+          parseHTML: (element: HtmlLikeElement) =>
+            firstSafeDocumentsDisplayLabel(
+              readEntityRefSnapshotLabel(element),
+              fallbackLabel,
+            ),
+        },
+        labelInvalid: {
+          default: false,
+          rendered: false,
+          parseHTML: (element: HtmlLikeElement) => (
+            element.getAttribute('data-entity-label-invalid') !== null
+            || !readEntityRefSnapshotLabel(element)
+          ),
+        },
+        href: {
+          default: null,
+          parseHTML: (element: HtmlLikeElement) => (
+            readEntityRefSnapshotLabel(element)
+              ? readEntityRefAttribute(element, 'data-href')
+              : null
+          ),
+        },
+      }
+    },
+    parseHTML() {
+      return [
+        {
+          tag: 'span[data-entity-ref]',
+          getAttrs: (value: unknown) => {
+            if (!isHtmlLikeElement(value)) return false
+            return {
+              entityType: readEntityRefAttribute(value, 'data-entity-type'),
+              entityId: readEntityRefAttribute(value, 'data-entity-id'),
+              label: firstSafeDocumentsDisplayLabel(
+                readEntityRefSnapshotLabel(value),
+                fallbackLabel,
+              ),
+              labelInvalid: value.getAttribute('data-entity-label-invalid') !== null
+                || !readEntityRefSnapshotLabel(value),
+              href: readEntityRefSnapshotLabel(value)
+                ? readEntityRefAttribute(value, 'data-href')
+                : null,
+            }
+          },
+        },
+      ]
+    },
+    renderHTML({ node }) {
+      const attrs = node.attrs as Partial<EntityRefAttributes>
+      const safeSnapshotLabel = attrs.labelInvalid
+        ? null
+        : sanitizeDocumentsDisplayLabel(attrs.label)
+      const label = firstSafeDocumentsDisplayLabel(
+        safeSnapshotLabel,
+        fallbackLabel,
+      ) ?? ''
+      const href = safeSnapshotLabel && isSafeEntityHref(attrs.href) ? attrs.href : null
+      const interactive = Boolean(label && href)
+      return [
+        'span',
+        mergeAttributes({
+          'data-entity-ref': '',
+          'data-entity-type': attrs.entityType ?? undefined,
+          'data-entity-id': attrs.entityId ?? undefined,
+          'data-label': safeSnapshotLabel ?? undefined,
+          'data-entity-label-invalid': safeSnapshotLabel ? undefined : '',
+          'data-href': href ?? undefined,
+          role: interactive ? 'link' : undefined,
+          tabindex: interactive ? '0' : undefined,
+          'aria-label': interactive ? label : undefined,
+          class: 'om-entity-ref',
+        }),
+        label,
+      ]
+    },
+  })
+}
+
+export const EntityRefNode = createEntityRefNode(DEFAULT_ENTITY_REF_FALLBACK_LABEL)
+
+export const COLLAB_FRAGMENT_FIELD = 'default'
+
+export function getDocumentEditorExtensions(options?: {
+  history?: boolean
+  entityRefFallbackLabel?: string
+}) {
+  const starterKit = StarterKit.configure({
+    link: false,
+    underline: false,
+    ...(options?.history === false ? { undoRedo: false as const } : {}),
+  })
+
+  return [
+    starterKit,
+    UnderlineMark,
+    Link.configure({
+      autolink: true,
+      linkOnPaste: true,
+      openOnClick: false,
+    }),
+    Image.configure({
+      allowBase64: false,
+      inline: false,
+    }),
+    Table.configure({
+      resizable: true,
+    }),
+    TableRow,
+    TableCell,
+    TableHeader,
+    TaskList,
+    TaskItem.configure({
+      nested: true,
+    }),
+    // Server-side CRDT materialization has no request locale. Preserve an
+    // invalid marker and an empty snapshot there; every user-visible editor
+    // supplies its localized fallback and renders it without persisting an
+    // arbitrary English label into the shared document.
+    createEntityRefNode(options?.entityRefFallbackLabel === undefined
+      ? null
+      : firstSafeDocumentsDisplayLabel(
+        options.entityRefFallbackLabel,
+        DEFAULT_ENTITY_REF_FALLBACK_LABEL,
+      )),
+    TextAlign.configure({ types: ['heading', 'paragraph'] }),
+    Highlight.configure({ multicolor: true }),
+    TextStyle,
+    Color,
+  ]
+}
+
+export function getClientEditorExtras(): AnyExtension[] {
+  return [
+    CharacterCount.configure({}),
+  ]
+}
+
+// Remote selections default to ~44% opacity (`${color}70`), which reads as a
+// heavy solid block. Google Docs uses a light wash — drop it to ~20% (`33`) so
+// overlapping text stays legible under a collaborator's highlight.
+function collaboratorSelectionAttributes(user: { color: string }) {
+  const color = normalizeCollaborationColor(user.color)
+  return {
+    style: `background-color: ${color}33`,
+    class: 'ProseMirror-yjs-selection',
+  }
+}
+
+export function resolveCollaborationCaretLabel(
+  user: Record<string, unknown>,
+  fallbackUserLabel: string,
+): string {
+  return firstSafeCollaborationAwarenessName(user.name, fallbackUserLabel)
+}
+
+export function resolveCollaborationCaretColor(user: Record<string, unknown>): string {
+  return normalizeCollaborationColor(user.color)
+}
+
+export function renderCollaborationCaret(
+  user: Record<string, unknown>,
+  fallbackUserLabel: string,
+): HTMLElement {
+  const cursor = document.createElement('span')
+  cursor.classList.add('collaboration-carets__caret')
+  const color = resolveCollaborationCaretColor(user)
+  cursor.setAttribute('style', `border-color: ${color}`)
+
+  const labelText = resolveCollaborationCaretLabel(user, fallbackUserLabel)
+  if (labelText) {
+    cursor.setAttribute('role', 'img')
+    cursor.setAttribute('aria-label', labelText)
+    cursor.setAttribute('title', labelText)
+    cursor.setAttribute('tabindex', '0')
+    cursor.setAttribute('contenteditable', 'false')
+    const label = document.createElement('div')
+    label.classList.add('collaboration-carets__label')
+    label.setAttribute('style', `background-color: ${color}`)
+    label.setAttribute('aria-hidden', 'true')
+    label.append(document.createTextNode(labelText))
+    cursor.append(label)
+  }
+  return cursor
+}
+
+export function getCollaborativeEditorExtensions(args: {
+  ydoc: import('yjs').Doc
+  provider: unknown
+  user: { name: string; color: string }
+  placeholder?: string
+  fallbackUserLabel: string
+  fallbackEntityRefLabel: string
+}) {
+  return [
+    ...getDocumentEditorExtensions({
+      history: false,
+      entityRefFallbackLabel: args.fallbackEntityRefLabel,
+    }),
+    Collaboration.configure({
+      document: args.ydoc,
+      field: COLLAB_FRAGMENT_FIELD,
+    }),
+    CollaborationCaret.configure({
+      provider: args.provider,
+      user: args.user,
+      render: (user) => renderCollaborationCaret(user, args.fallbackUserLabel),
+      selectionRender: collaboratorSelectionAttributes,
+    }),
+    Placeholder.configure({
+      placeholder: args.placeholder ?? 'Start writing…',
+    }),
+  ]
+}

package/src/modules/documents/lib/entityLinks.ts

@@ -0,0 +1,250 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { DocumentEntityLink } from '../data/entities'
+import type {
+  DocumentEntityLinkCreateInput,
+  DocumentEntityType,
+} from '../data/validators'
+import { sanitizeDocumentsDisplayLabel } from './displayLabels'
+import { getEntityTokenFieldNames } from './entityRegistry'
+import { DOCUMENTS_MAX_ENTITY_LINKS_PER_DOCUMENT } from './resourceLimits'
+
+export type DocumentEntityLinkScope = {
+  tenantId: string
+  organizationId: string
+}
+
+export type DocumentEntityLinkCanonicalTarget = {
+  id: string
+  label: string
+  href: string
+  values?: Record<string, string | null>
+}
+
+type LinkTargetFields = Pick<
+  DocumentEntityLink,
+  | 'customerEntityId'
+  | 'customerKind'
+  | 'dealId'
+  | 'productId'
+  | 'catalogOfferId'
+  | 'quoteId'
+  | 'salesOrderId'
+  | 'linkedDocumentId'
+>
+
+export type DocumentEntityLinkCreateData = LinkTargetFields & {
+  id: string
+  documentId: string
+  tenantId: string
+  organizationId: string
+  labelSnapshot: string
+  hrefSnapshot: string
+  source: DocumentEntityLinkCreateInput['source']
+  createdByUserId: string
+}
+
+const EMPTY_TARGET: LinkTargetFields = {
+  customerEntityId: null,
+  customerKind: null,
+  dealId: null,
+  productId: null,
+  catalogOfferId: null,
+  quoteId: null,
+  salesOrderId: null,
+  linkedDocumentId: null,
+}
+
+function sanitizeDocumentEntityValue(value: unknown): string | null {
+  const label = sanitizeDocumentsDisplayLabel(value)
+  return label && label.length <= 10_000 ? label : null
+}
+
+export function buildDocumentEntityLinkTarget(
+  entityType: DocumentEntityType,
+  entityId: string,
+): LinkTargetFields {
+  const target = { ...EMPTY_TARGET }
+  if (entityType === 'customer-person' || entityType === 'customer-company') {
+    target.customerEntityId = entityId
+    target.customerKind = entityType === 'customer-person' ? 'person' : 'company'
+  } else if (entityType === 'deal') {
+    target.dealId = entityId
+  } else if (entityType === 'product') {
+    target.productId = entityId
+  } else if (entityType === 'catalog-offer') {
+    target.catalogOfferId = entityId
+  } else if (entityType === 'quote') {
+    target.quoteId = entityId
+  } else if (entityType === 'document') {
+    target.linkedDocumentId = entityId
+  } else {
+    target.salesOrderId = entityId
+  }
+  return target
+}
+
+export function buildDocumentEntityLinkTargetWhere(
+  entityType: DocumentEntityType,
+  entityId: string,
+): LinkTargetFields {
+  return buildDocumentEntityLinkTarget(entityType, entityId)
+}
+
+export function getDocumentEntityLinkType(link: DocumentEntityLink): DocumentEntityType {
+  if (link.customerEntityId) {
+    return link.customerKind === 'company' ? 'customer-company' : 'customer-person'
+  }
+  if (link.dealId) return 'deal'
+  if (link.productId) return 'product'
+  if (link.catalogOfferId) return 'catalog-offer'
+  if (link.quoteId) return 'quote'
+  if (link.linkedDocumentId) return 'document'
+  return 'sales-order'
+}
+
+export function getDocumentEntityLinkEntityId(link: DocumentEntityLink): string {
+  return link.customerEntityId
+    ?? link.dealId
+    ?? link.productId
+    ?? link.catalogOfferId
+    ?? link.quoteId
+    ?? link.linkedDocumentId
+    ?? link.salesOrderId
+    ?? ''
+}
+
+export function createDocumentEntityLinkData(input: {
+  id: string
+  documentId: string
+  scope: DocumentEntityLinkScope
+  actorUserId: string
+  link: DocumentEntityLinkCreateInput
+}): DocumentEntityLinkCreateData {
+  const labelSnapshot = sanitizeDocumentsDisplayLabel(input.link.label)
+  if (!labelSnapshot) {
+    throw new Error('[internal] document entity link label crossed persistence without a readable label')
+  }
+  return {
+    id: input.id,
+    documentId: input.documentId,
+    tenantId: input.scope.tenantId,
+    organizationId: input.scope.organizationId,
+    labelSnapshot,
+    hrefSnapshot: input.link.href,
+    source: input.link.source,
+    createdByUserId: input.actorUserId,
+    ...buildDocumentEntityLinkTarget(input.link.entityType, input.link.entityId),
+  }
+}
+
+export async function findDocumentEntityLinks(
+  em: EntityManager,
+  documentId: string,
+  scope: DocumentEntityLinkScope,
+  options: { withDeleted?: boolean } = {},
+): Promise<DocumentEntityLink[]> {
+  const links = await findWithDecryption(
+    em,
+    DocumentEntityLink,
+    {
+      documentId,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      ...(options.withDeleted ? {} : { deletedAt: null }),
+    },
+    options.withDeleted
+      ? { orderBy: { createdAt: 'ASC' } }
+      : {
+          orderBy: { createdAt: 'ASC' },
+          limit: DOCUMENTS_MAX_ENTITY_LINKS_PER_DOCUMENT + 1,
+        },
+    scope,
+  )
+  if (!options.withDeleted) assertDocumentEntityLinkListWithinLimit(links)
+  return links
+}
+
+export function assertDocumentEntityLinkListWithinLimit(
+  links: readonly DocumentEntityLink[],
+): void {
+  if (links.length <= DOCUMENTS_MAX_ENTITY_LINKS_PER_DOCUMENT) return
+  throw new CrudHttpError(413, { error: 'documents.links.limitExceeded' })
+}
+
+/** Call only while holding the document aggregate lock. */
+export async function assertDocumentEntityLinkCapacity(
+  em: EntityManager,
+  documentId: string,
+  scope: DocumentEntityLinkScope,
+): Promise<void> {
+  const activeCount = await em.count(DocumentEntityLink, {
+    documentId,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    deletedAt: null,
+  })
+  if (activeCount < DOCUMENTS_MAX_ENTITY_LINKS_PER_DOCUMENT) return
+  throw new CrudHttpError(413, { error: 'documents.links.limitExceeded' })
+}
+
+export function serializeDocumentEntityLink(
+  link: DocumentEntityLink,
+  options: {
+    canOpen: boolean
+    restrictedLabel: string
+    canonicalTarget?: DocumentEntityLinkCanonicalTarget
+  },
+): {
+  id: string
+  entityType: DocumentEntityType
+  entityId: string | null
+  label: string
+  href: string | null
+  canOpen: boolean
+  source: string
+  createdAt: string
+  updatedAt: string
+  values?: Record<string, string | null>
+} {
+  const entityType = getDocumentEntityLinkType(link)
+  const restrictedLabel = sanitizeDocumentsDisplayLabel(options.restrictedLabel)
+  const canonicalLabel = options.canonicalTarget
+    ? sanitizeDocumentsDisplayLabel(options.canonicalTarget.label)
+    : null
+  const snapshotLabel = sanitizeDocumentsDisplayLabel(link.labelSnapshot)
+  const canOpen = options.canOpen && (
+    options.canonicalTarget ? Boolean(canonicalLabel) : Boolean(snapshotLabel)
+  )
+  const readableLabel = canOpen ? canonicalLabel ?? snapshotLabel : restrictedLabel
+  if (!readableLabel) {
+    throw new Error('[internal] document entity link serialization requires a readable fallback label')
+  }
+  const allowedValueFields = getEntityTokenFieldNames(entityType)
+  const values = options.canonicalTarget?.values
+    ? Object.fromEntries(Array.from(allowedValueFields, (field) => [
+        field,
+        sanitizeDocumentEntityValue(options.canonicalTarget?.values?.[field]),
+      ]))
+    : null
+  const hasReadableValues = values
+    ? Object.values(values).some((value) => value !== null)
+    : false
+  return {
+    id: link.id,
+    entityType,
+    entityId: canOpen
+      ? options.canonicalTarget?.id ?? getDocumentEntityLinkEntityId(link)
+      : null,
+    label: canOpen ? readableLabel : restrictedLabel ?? readableLabel,
+    href: canOpen
+      ? options.canonicalTarget?.href ?? link.hrefSnapshot
+      : null,
+    canOpen,
+    source: link.source,
+    createdAt: link.createdAt.toISOString(),
+    updatedAt: link.updatedAt.toISOString(),
+    ...(canOpen && hasReadableValues && values ? { values } : {}),
+  }
+}