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

package/src/modules/documents/backend/documents/documentUi.ts

@@ -0,0 +1,134 @@
+import type { DocumentCapabilities } from '../../lib/capabilities'
+
+export type { DocumentCapabilities } from '../../lib/capabilities'
+
+export type DocumentTier = 'owner' | 'editor' | 'commenter' | 'viewer'
+
+export type DocumentDetail = {
+  id: string
+  title: string
+  tier: DocumentTier
+  updatedAt: string | null
+  archivedAt: string | null
+  isFavorite: boolean
+  isWatching: boolean
+  capabilities: DocumentCapabilities
+}
+
+export type DocumentContent = {
+  contentHtml: string
+  updatedAt: string | null
+}
+
+export function readRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null
+}
+
+export function readString(record: Record<string, unknown>, ...keys: string[]): string | null {
+  for (const key of keys) {
+    const value = record[key]
+    if (typeof value === 'string' && value.trim().length > 0) return value
+  }
+  return null
+}
+
+export function readBoolean(record: Record<string, unknown>, ...keys: string[]): boolean | null {
+  for (const key of keys) {
+    const value = record[key]
+    if (typeof value === 'boolean') return value
+  }
+  return null
+}
+
+export function readNumber(record: Record<string, unknown>, ...keys: string[]): number | null {
+  for (const key of keys) {
+    const value = record[key]
+    if (typeof value === 'number' && Number.isFinite(value)) return value
+  }
+  return null
+}
+
+export function readArrayPayload(payload: unknown, ...keys: string[]): unknown[] {
+  if (Array.isArray(payload)) return payload
+  const record = readRecord(payload)
+  if (!record) return []
+  for (const key of keys) {
+    const value = record[key]
+    if (Array.isArray(value)) return value
+  }
+  return []
+}
+
+export function unwrapRecord(payload: unknown, ...keys: string[]): Record<string, unknown> | null {
+  const root = readRecord(payload)
+  if (!root) return null
+  for (const key of keys) {
+    const nested = readRecord(root[key])
+    if (nested) return nested
+  }
+  return root
+}
+
+function readTier(value: string | null): DocumentTier {
+  if (value === 'owner' || value === 'editor' || value === 'commenter') return value
+  return 'viewer'
+}
+
+function readCapabilities(record: Record<string, unknown>, tier: DocumentTier): DocumentCapabilities {
+  const capabilities = readRecord(record.capabilities)
+  const legacyCanShare = readBoolean(record, 'canShare', 'can_share') ?? tier === 'owner'
+  const legacyCanEdit = tier === 'owner' || tier === 'editor'
+  const legacyCanComment = tier !== 'viewer'
+  return {
+    canView: capabilities ? readBoolean(capabilities, 'canView', 'can_view') ?? true : true,
+    canComment: capabilities ? readBoolean(capabilities, 'canComment', 'can_comment') ?? legacyCanComment : legacyCanComment,
+    canEdit: capabilities ? readBoolean(capabilities, 'canEdit', 'can_edit') ?? legacyCanEdit : legacyCanEdit,
+    canShare: capabilities ? readBoolean(capabilities, 'canShare', 'can_share') ?? legacyCanShare : legacyCanShare,
+    canDelete: capabilities ? readBoolean(capabilities, 'canDelete', 'can_delete') ?? false : false,
+    canCreate: capabilities ? readBoolean(capabilities, 'canCreate', 'can_create') ?? false : false,
+    canManageTemplates: capabilities
+      ? readBoolean(capabilities, 'canManageTemplates', 'can_manage_templates') ?? false
+      : false,
+    canArchive: capabilities
+      ? readBoolean(capabilities, 'canArchive', 'can_archive') ?? false
+      : false,
+    canDuplicate: capabilities
+      ? readBoolean(capabilities, 'canDuplicate', 'can_duplicate') ?? false
+      : false,
+  }
+}
+
+export function normalizeDocumentDetail(payload: unknown): DocumentDetail | null {
+  const record = unwrapRecord(payload, 'document', 'item', 'data')
+  if (!record) return null
+  const id = readString(record, 'id')
+  const title = readString(record, 'title')
+  if (!id || !title) return null
+  const tier = readTier(readString(record, 'tier', 'permission', 'effectiveTier', 'effective_tier'))
+  return {
+    id,
+    title,
+    tier,
+    updatedAt: readString(record, 'updatedAt', 'updated_at'),
+    archivedAt: readString(record, 'archivedAt', 'archived_at'),
+    isFavorite: readBoolean(record, 'isFavorite', 'is_favorite') ?? false,
+    isWatching: readBoolean(record, 'isWatching', 'is_watching') ?? false,
+    capabilities: readCapabilities(record, tier),
+  }
+}
+
+export function normalizeDocumentContent(payload: unknown): DocumentContent {
+  const record = unwrapRecord(payload, 'content', 'item', 'data')
+  return {
+    contentHtml: record ? readString(record, 'contentHtml', 'content_html') ?? '' : '',
+    updatedAt: record ? readString(record, 'updatedAt', 'updated_at') : null,
+  }
+}
+
+export function formatDateTime(value: string | null | undefined, fallback: string): string {
+  if (!value) return fallback
+  const date = new Date(value)
+  return Number.isNaN(date.getTime()) ? fallback : date.toLocaleString()
+}

package/src/modules/documents/backend/documents/documentsListTypes.ts

@@ -0,0 +1,163 @@
+import { readArrayPayload, readBoolean, readNumber, readRecord, readString, type DocumentCapabilities } from './documentUi'
+import { firstSafeDocumentsDisplayLabel } from '../../lib/displayLabels'
+
+export type DocumentRow = {
+  id: string
+  title: string
+  folderId: string | null
+  folderName: string | null
+  ownerLabel: string
+  sharedWithCount: number
+  updatedAt: string | null
+  archivedAt: string | null
+  isFavorite: boolean
+  capabilities: DocumentCapabilities
+}
+
+export type FolderRow = {
+  id: string
+  name: string
+  parentFolderId: string | null
+  updatedAt: string | null
+  canEdit: boolean
+  visibility: 'owned' | 'contains-visible' | 'ancestor'
+}
+
+export type FolderNode = FolderRow & { children: FolderNode[] }
+export type CollectionCapabilities = {
+  canCreateDocument: boolean
+  canCreateFolder: boolean
+  canLinkDocuments: boolean
+  canInstantiateTemplate: boolean
+  canManageTemplates: boolean
+}
+
+export const EMPTY_COLLECTION_CAPABILITIES: CollectionCapabilities = {
+  canCreateDocument: false,
+  canCreateFolder: false,
+  canLinkDocuments: false,
+  canInstantiateTemplate: false,
+  canManageTemplates: false,
+}
+
+function readCapabilities(record: Record<string, unknown>): DocumentCapabilities {
+  const capabilities = readRecord(record.capabilities) ?? {}
+  return {
+    canView: readBoolean(capabilities, 'canView', 'can_view') ?? true,
+    canComment: readBoolean(capabilities, 'canComment', 'can_comment') ?? false,
+    canEdit: readBoolean(capabilities, 'canEdit', 'can_edit') ?? false,
+    canShare: readBoolean(capabilities, 'canShare', 'can_share') ?? false,
+    canDelete: readBoolean(capabilities, 'canDelete', 'can_delete') ?? false,
+    canCreate: readBoolean(capabilities, 'canCreate', 'can_create') ?? false,
+    canManageTemplates: readBoolean(capabilities, 'canManageTemplates', 'can_manage_templates') ?? false,
+    canArchive: readBoolean(capabilities, 'canArchive', 'can_archive') ?? false,
+    canDuplicate: readBoolean(capabilities, 'canDuplicate', 'can_duplicate') ?? false,
+  }
+}
+
+export function normalizeFolders(payload: unknown): FolderRow[] {
+  return readArrayPayload(payload, 'items', 'data', 'folders').flatMap((value) => {
+    const record = readRecord(value)
+    const id = record ? readString(record, 'id') : null
+    const name = record ? readString(record, 'name') : null
+    if (!record || !id || !name) return []
+    const visibility = readString(record, 'visibility')
+    return [{
+      id, name,
+      parentFolderId: readString(record, 'parentFolderId', 'parent_folder_id'),
+      updatedAt: readString(record, 'updatedAt', 'updated_at'),
+      canEdit: readBoolean(record, 'canEdit', 'can_edit') ?? false,
+      visibility: visibility === 'contains-visible' || visibility === 'ancestor' ? visibility : 'owned',
+    }]
+  })
+}
+
+export function normalizeDocuments(payload: unknown, folders: FolderRow[], unknownOwner: string): DocumentRow[] {
+  const folderMap = new Map(folders.map((folder) => [folder.id, folder]))
+  return readArrayPayload(payload, 'items', 'data', 'documents').flatMap((value) => {
+    const record = readRecord(value)
+    const id = record ? readString(record, 'id') : null
+    const title = record ? readString(record, 'title') : null
+    if (!record || !id || !title) return []
+    const folderId = readString(record, 'folderId', 'folder_id')
+    return [{
+      id, title, folderId,
+      folderName: readString(record, 'folderName', 'folder_name') ?? (folderId ? folderMap.get(folderId)?.name ?? null : null),
+      ownerLabel: firstSafeDocumentsDisplayLabel(
+        readString(
+          record,
+          'ownerLabel',
+          'owner_label',
+          'ownerName',
+          'owner_name',
+          'ownerEmail',
+          'owner_email',
+        ),
+        unknownOwner,
+      ) ?? '',
+      sharedWithCount: readNumber(
+        record,
+        'sharedWithCount',
+        'shared_with_count',
+        'shareCount',
+        'share_count',
+      ) ?? 0,
+      updatedAt: readString(record, 'updatedAt', 'updated_at'),
+      archivedAt: readString(record, 'archivedAt', 'archived_at'),
+      isFavorite: readBoolean(record, 'isFavorite', 'is_favorite') ?? false,
+      capabilities: readCapabilities(record),
+    }]
+  })
+}
+
+export function normalizeCollectionCapabilities(payload: unknown): CollectionCapabilities {
+  const root = readRecord(payload)
+  const capabilities = readRecord(root?.collectionCapabilities ?? root?.collection_capabilities)
+  if (!capabilities) return EMPTY_COLLECTION_CAPABILITIES
+  return {
+    canCreateDocument: readBoolean(capabilities, 'canCreateDocument', 'can_create_document') ?? false,
+    canCreateFolder: readBoolean(capabilities, 'canCreateFolder', 'can_create_folder') ?? false,
+    canLinkDocuments: readBoolean(capabilities, 'canLinkDocuments', 'can_link_documents') ?? false,
+    canInstantiateTemplate: readBoolean(capabilities, 'canInstantiateTemplate', 'can_instantiate_template') ?? false,
+    canManageTemplates: readBoolean(capabilities, 'canManageTemplates', 'can_manage_templates') ?? false,
+  }
+}
+
+export function canWriteToFolder(selectedFolderId: string | null, folder: FolderRow | null): boolean {
+  return selectedFolderId === null || folder?.canEdit === true
+}
+
+export function buildFolderTree(folders: FolderRow[]): FolderNode[] {
+  const nodes = new Map(folders.map((folder) => [folder.id, { ...folder, children: [] as FolderNode[] }]))
+  const roots: FolderNode[] = []
+  for (const node of nodes.values()) {
+    const parent = node.parentFolderId ? nodes.get(node.parentFolderId) : null
+    if (parent) parent.children.push(node)
+    else roots.push(node)
+  }
+  const sort = (items: FolderNode[]) => items
+    .sort((first, second) => first.name.localeCompare(
+      second.name,
+      undefined,
+      { sensitivity: 'base' },
+    ))
+    .forEach((item) => sort(item.children))
+  sort(roots)
+  return roots
+}
+
+export function hasActiveTemplate(payload: unknown): boolean {
+  return readArrayPayload(payload, 'items', 'data', 'templates').some((value) => {
+    const record = readRecord(value)
+    return record ? readBoolean(record, 'isActive', 'is_active') !== false : false
+  })
+}
+
+export function readCreatedId(payload: unknown): string | null {
+  const root = readRecord(payload)
+  if (!root) return null
+  return readString(root, 'id')
+    ?? readString(readRecord(root.document) ?? {}, 'id')
+    ?? readString(readRecord(root.item) ?? {}, 'id')
+    ?? readString(readRecord(root.data) ?? {}, 'id')
+}

package/src/modules/documents/backend/documents/page.meta.ts

@@ -0,0 +1,24 @@
+import React from 'react'
+
+// Page metadata must stay a plain serializable element tree — a lucide component
+// reference does not survive metadata serialization and drops the sidebar icon.
+const documentsIcon = React.createElement('svg', { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2 },
+  React.createElement('path', { d: 'M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z' }),
+  React.createElement('path', { d: 'M14 2v4a2 2 0 0 0 2 2h4' }),
+  React.createElement('path', { d: 'M10 9H8' }),
+  React.createElement('path', { d: 'M16 13H8' }),
+  React.createElement('path', { d: 'M16 17H8' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['documents.view'],
+  pageTitle: 'Documents',
+  pageTitleKey: 'documents.nav.documents',
+  pageGroup: 'Documents',
+  pageGroupKey: 'documents.nav.group',
+  pagePriority: 40,
+  pageOrder: 100,
+  icon: documentsIcon,
+  breadcrumb: [{ label: 'Documents', labelKey: 'documents.nav.documents' }],
+}

package/src/modules/documents/backend/documents/page.tsx

@@ -0,0 +1,5 @@
+import { DocumentsPageClient } from './DocumentsPageClient'
+
+export default function DocumentsPage() {
+  return <DocumentsPageClient />
+}

package/src/modules/documents/backend/documents/templates/TemplatesPageClient.tsx

@@ -0,0 +1,93 @@
+"use client"
+
+import * as React from 'react'
+import dynamic from 'next/dynamic'
+import { Page, PageBody } from '@open-mercato/ui/backend/Page'
+import { ErrorMessage, LoadingMessage } from '@open-mercato/ui/backend/detail'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Dialog, DialogContent, DialogDescription, DialogHeader, DialogTitle } from '@open-mercato/ui/primitives/dialog'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import type { TemplateRow } from '../components/templateUi'
+import { TemplatesTable } from './TemplatesTable'
+import { useTemplatesPage } from './useTemplatesPage'
+
+function TemplateEditorDialogLoading({ error, retry }: { error?: Error | null; retry?: () => void }) {
+  const t = useT()
+  // `next/dynamic` never forwards the caller's `onOpenChange` to a loading
+  // shell, so own the dismissal here. Without it a chunk that fails for good
+  // (a deploy invalidated it) traps the user in a modal Escape cannot close.
+  const [open, setOpen] = React.useState(true)
+  if (!open) return null
+  return (
+    <Dialog open onOpenChange={(next) => { if (!next) setOpen(false) }}>
+      <DialogContent size="xl" dismissible={Boolean(error)}>
+        <DialogHeader>
+          <DialogTitle>{t('documents.templates.actions.manage')}</DialogTitle>
+          <DialogDescription>{t('documents.templates.preview.loading')}</DialogDescription>
+        </DialogHeader>
+        {error ? (
+          <ErrorMessage
+            label={t('documents.templates.error.load')}
+            action={<Button type="button" size="sm" variant="outline" onClick={retry}>{t('documents.actions.retry')}</Button>}
+          />
+        ) : (
+          <div role="status" aria-live="polite"><LoadingMessage label={t('documents.templates.preview.loading')} /></div>
+        )}
+      </DialogContent>
+    </Dialog>
+  )
+}
+
+const TemplateEditorDialog = dynamic(
+  () => import('../components/TemplateEditorDialog').then((module) => module.TemplateEditorDialog),
+  { ssr: false, loading: TemplateEditorDialogLoading },
+)
+
+export function TemplatesPageClient() {
+  const t = useT()
+  const templates = useTemplatesPage()
+  const [editing, setEditing] = React.useState<TemplateRow | null>(null)
+  const [editorOpen, setEditorOpen] = React.useState(false)
+  const openEditor = React.useCallback((template: TemplateRow | null) => {
+    setEditing(template)
+    setEditorOpen(true)
+  }, [])
+  return (
+    <Page>
+      <PageBody>
+        {templates.loadError ? (
+          <ErrorMessage
+            label={templates.loadError}
+            action={<Button type="button" size="sm" variant="outline" onClick={templates.refresh}>{t('documents.actions.retry')}</Button>}
+          />
+        ) : (
+          <TemplatesTable
+          rows={templates.rows}
+          page={templates.page}
+          pageSize={templates.pageSize}
+          total={templates.total}
+          totalPages={templates.totalPages}
+          search={templates.search}
+          isLoading={templates.isLoading}
+          canManageTemplates={templates.canManageTemplates}
+          onSearchChange={templates.setSearch}
+          onPageChange={templates.setPage}
+          onPageSizeChange={templates.setPageSize}
+          onRefresh={templates.refresh}
+          onEdit={openEditor}
+          onDelete={(template) => void templates.deleteTemplate(template)}
+          />
+        )}
+        {templates.canManageTemplates && editorOpen ? <TemplateEditorDialog
+          open
+          template={editing}
+          onOpenChange={(open) => { setEditorOpen(open); if (!open) setEditing(null) }}
+          onSaved={templates.refreshFromFirstPage}
+        /> : null}
+        {templates.ConfirmDialogElement}
+      </PageBody>
+    </Page>
+  )
+}
+
+export default TemplatesPageClient

package/src/modules/documents/backend/documents/templates/TemplatesTable.tsx

@@ -0,0 +1,71 @@
+"use client"
+
+import * as React from 'react'
+import type { LegacyColumnDef as ColumnDef } from '@tanstack/react-table/legacy'
+import { DataTable } from '@open-mercato/ui/backend/DataTable'
+import { RowActions } from '@open-mercato/ui/backend/RowActions'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { StatusBadge } from '@open-mercato/ui/primitives/status-badge'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { DOCUMENTS_ENTITY_IDS } from '../../../lib/constants'
+import { getEntityRegistryEntry } from '../../../lib/entityRegistry'
+import { formatDateTime } from '../documentUi'
+import type { TemplateRow } from '../components/templateUi'
+
+export function TemplatesTable({ rows, page, pageSize, total, totalPages, search, isLoading, canManageTemplates, onSearchChange, onPageChange, onPageSizeChange, onRefresh, onEdit, onDelete }: {
+  rows: TemplateRow[]
+  page: number
+  pageSize: number
+  total: number
+  totalPages: number
+  search: string
+  isLoading: boolean
+  canManageTemplates: boolean
+  onSearchChange: (search: string) => void
+  onPageChange: (page: number) => void
+  onPageSizeChange: (pageSize: number) => void
+  onRefresh: () => void
+  onEdit: (template: TemplateRow | null) => void
+  onDelete: (template: TemplateRow) => void
+}) {
+  const t = useT()
+  const columns = React.useMemo<ColumnDef<TemplateRow>[]>(() => [
+    { accessorKey: 'name', header: t('documents.templates.columns.name'), meta: { alwaysVisible: true, maxWidth: '240px', truncate: true }, cell: ({ row }) => <span className="font-medium">{row.original.name}</span> },
+    { accessorKey: 'description', header: t('documents.templates.columns.description'), meta: { maxWidth: '320px', truncate: true }, cell: ({ row }) => row.original.description ?? <span className="text-muted-foreground">{t('documents.templates.list.noDescription')}</span> },
+    { id: 'slots', header: t('documents.templates.columns.slots'), meta: { maxWidth: '260px', truncate: true }, cell: ({ row }) => row.original.contextSlots.length > 0 ? row.original.contextSlots.map((slot) => t(getEntityRegistryEntry(slot.entityType)?.labelKey ?? 'documents.relatedRecords.restricted')).join(', ') : t('documents.templates.slots.none') },
+    { accessorKey: 'isActive', header: t('documents.templates.columns.active'), cell: ({ row }) => <StatusBadge variant={row.original.isActive ? 'success' : 'neutral'} dot>{t(row.original.isActive ? 'documents.templates.status.active' : 'documents.templates.status.inactive')}</StatusBadge> },
+    { accessorKey: 'updatedAt', header: t('documents.columns.updatedAt'), meta: { maxWidth: '180px' }, cell: ({ row }) => formatDateTime(row.original.updatedAt, t('documents.list.noValue')) },
+  ], [t])
+  return (
+    <DataTable<TemplateRow>
+      title={t('documents.templates.list.title')}
+      actions={canManageTemplates ? <Button type="button" onClick={() => onEdit(null)}>{t('documents.templates.actions.new')}</Button> : undefined}
+      refreshButton={{ label: t('documents.actions.refresh'), onRefresh, isRefreshing: isLoading }}
+      columns={columns}
+      data={rows}
+      isLoading={isLoading}
+      searchValue={search}
+      onSearchChange={onSearchChange}
+      searchPlaceholder={t('documents.templates.list.searchPlaceholder')}
+      emptyState={t('documents.templates.list.empty')}
+      entityId={DOCUMENTS_ENTITY_IDS.documentTemplate}
+      extensionTableId="documents.templates.list"
+      onRowClick={canManageTemplates ? onEdit : undefined}
+      rowClickActionIds={canManageTemplates ? ['edit'] : []}
+      stickyActionsColumn
+      pagination={{
+        page,
+        pageSize,
+        total,
+        totalPages,
+        onPageChange,
+        onPageSizeChange,
+        pageSizeOptions: [25, 50, 100],
+      }}
+      rowActions={canManageTemplates ? (row) => <RowActions items={[
+        { id: 'edit', label: t('documents.actions.edit'), onSelect: () => onEdit(row) },
+        { id: 'delete', label: t('documents.actions.delete'), destructive: true, onSelect: () => onDelete(row) },
+      ]} /> : undefined}
+    />
+  )
+}

package/src/modules/documents/backend/documents/templates/page.meta.ts

@@ -0,0 +1,32 @@
+import React from 'react'
+
+// Page metadata must stay a plain serializable element tree — a lucide component
+// reference does not survive metadata serialization and drops the sidebar icon.
+const documentsTemplatesIcon = React.createElement('svg', { width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: 2 },
+  React.createElement('path', { d: 'M15 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V7Z' }),
+  React.createElement('path', { d: 'M14 2v4a2 2 0 0 0 2 2h4' }),
+  React.createElement('path', { d: 'M14 13H8' }),
+  React.createElement('path', { d: 'M14 17H8' }),
+  React.createElement('path', { d: 'M10 9H8' }),
+)
+
+export const metadata = {
+  requireAuth: true,
+  // The template list API stays on `documents.view` because the
+  // new-from-template dialog needs it, but this page is the management
+  // surface: every action on it, and the single-template read behind its
+  // editor, require `documents.templates.manage`. Gate the page (and the nav
+  // entry it registers) on the same feature instead of advertising a dead end.
+  requireFeatures: ['documents.templates.manage'],
+  pageTitle: 'Document templates',
+  pageTitleKey: 'documents.nav.templates',
+  pageGroup: 'Documents',
+  pageGroupKey: 'documents.nav.group',
+  pagePriority: 40,
+  pageOrder: 110,
+  icon: documentsTemplatesIcon,
+  breadcrumb: [
+    { label: 'Documents', labelKey: 'documents.nav.documents' },
+    { label: 'Document templates', labelKey: 'documents.nav.templates' },
+  ],
+}

package/src/modules/documents/backend/documents/templates/page.tsx

@@ -0,0 +1,5 @@
+import { TemplatesPageClient } from './TemplatesPageClient'
+
+export default function DocumentTemplatesPage() {
+  return <TemplatesPageClient />
+}