@open-mercato/core 0.7.1-develop.7178.1.ab93fbaf4e → 0.7.1-develop.7180.1.9717fbbb43

package/src/modules/staff/lib/timesheets-tasks/statusPositions.ts

@@ -0,0 +1,132 @@
+/**
+ * Gap-based ordering arithmetic for the Kanban columns of screen 6.
+ *
+ * Positions are integers spaced `STATUS_POSITION_GAP` apart rather than a dense
+ * 0..n-1 sequence. That is what keeps a drag cheap: the board hands the server a
+ * midpoint between the two columns the pointer was released over, so moving one
+ * column writes exactly one row instead of renumbering every column on the board.
+ *
+ * The dense renumber still exists, but only as the fallback for the one case the
+ * midpoint scheme cannot express — a gap narrow enough that no integer fits
+ * between two neighbours. Then the whole board is compacted back onto the gap
+ * grid, which restores room for the next few thousand drags.
+ */
+
+export const STATUS_POSITION_GAP = 1000
+
+/**
+ * Mirrors the ceiling `positionSchema` accepts in `data/validators.ts`, so a
+ * server-computed position can always be round-tripped back through the API.
+ */
+export const MAX_STATUS_POSITION = 1_000_000
+
+export type StatusPosition = {
+  id: string
+  position: number
+}
+
+export type StatusReorderPlan = {
+  /** Only the rows whose stored position actually has to change. */
+  updates: StatusPosition[]
+  /** True when the gap ran out and the whole board was re-spaced. */
+  compacted: boolean
+  /** Requested ids that do not belong to the project — the caller rejects these. */
+  unknownIds: string[]
+}
+
+/**
+ * Position for a column appended to the right-hand end of the board (the
+ * mockup's "Nowa kolumna / Dodaj status" affordance).
+ */
+export function nextStatusPosition(positions: readonly number[]): number {
+  const finite = positions.filter((value) => Number.isFinite(value))
+  if (finite.length === 0) return STATUS_POSITION_GAP
+  const highest = Math.max(...finite)
+  const next = highest + STATUS_POSITION_GAP
+  if (next <= MAX_STATUS_POSITION) return next
+  // Past the ceiling the board is out of headroom; fall back to the tightest
+  // step that still preserves ordering. A reorder will compact it back later.
+  return Math.min(highest + 1, MAX_STATUS_POSITION)
+}
+
+/** Re-spaces an ordered id list back onto the gap grid. */
+export function compactStatusPositions(ids: readonly string[]): StatusPosition[] {
+  return ids.map((id, index) => ({ id, position: (index + 1) * STATUS_POSITION_GAP }))
+}
+
+type DesiredRow = {
+  id: string
+  currentPosition: number
+  targetPosition: number
+  requested: boolean
+}
+
+function isUsablePosition(value: number): boolean {
+  return Number.isInteger(value) && value >= 0 && value <= MAX_STATUS_POSITION
+}
+
+/**
+ * Turns a reorder request into the minimal set of position writes.
+ *
+ * `current` is every live column of the project; `requested` is the subset the
+ * client moved, carrying its intended sort key. Columns absent from the request
+ * keep the position they already have, so a board can be reordered one column at
+ * a time without the client having to restate the rest.
+ */
+export function planStatusReorder(
+  current: readonly StatusPosition[],
+  requested: readonly StatusPosition[],
+): StatusReorderPlan {
+  const currentById = new Map(current.map((row) => [row.id, row.position]))
+  const unknownIds: string[] = []
+  const requestedById = new Map<string, number>()
+  for (const row of requested) {
+    if (!currentById.has(row.id)) {
+      if (!unknownIds.includes(row.id)) unknownIds.push(row.id)
+      continue
+    }
+    requestedById.set(row.id, row.position)
+  }
+
+  const desired: DesiredRow[] = current.map((row) => ({
+    id: row.id,
+    currentPosition: row.position,
+    targetPosition: requestedById.get(row.id) ?? row.position,
+    requested: requestedById.has(row.id),
+  }))
+
+  desired.sort((left, right) => {
+    if (left.targetPosition !== right.targetPosition) return left.targetPosition - right.targetPosition
+    // A dragged column dropped exactly onto a settled column's key lands ahead of
+    // it, which is where the pointer was released. Two settled columns keep their
+    // previous relative order, then sort by id — so the outcome never depends on
+    // the order rows happened to arrive in.
+    if (left.requested !== right.requested) return left.requested ? -1 : 1
+    if (left.currentPosition !== right.currentPosition) return left.currentPosition - right.currentPosition
+    return left.id < right.id ? -1 : left.id > right.id ? 1 : 0
+  })
+
+  const fitsOnGrid = desired.every(
+    (row, index) =>
+      isUsablePosition(row.targetPosition) &&
+      (index === 0 || row.targetPosition > desired[index - 1].targetPosition),
+  )
+
+  if (fitsOnGrid) {
+    return {
+      updates: desired
+        .filter((row) => row.targetPosition !== row.currentPosition)
+        .map((row) => ({ id: row.id, position: row.targetPosition })),
+      compacted: false,
+      unknownIds,
+    }
+  }
+
+  const compactedPositions = compactStatusPositions(desired.map((row) => row.id))
+  const currentPositionById = new Map(desired.map((row) => [row.id, row.currentPosition]))
+  return {
+    updates: compactedPositions.filter((row) => currentPositionById.get(row.id) !== row.position),
+    compacted: true,
+    unknownIds,
+  }
+}

package/src/modules/staff/lib/timesheets-tasks/statusSlug.ts

@@ -0,0 +1,43 @@
+import { slugifyProjectName } from '../time-tracking/projectCode'
+
+/** Mirrors the `timeSlugSchema` ceiling in `data/validators.ts`. */
+export const TASK_STATUS_SLUG_MAX_LENGTH = 60
+
+export const TASK_STATUS_SLUG_FALLBACK = 'status'
+
+/**
+ * A column's slug is the stable id filters and saved views hold onto, so it is
+ * derived once from the name and then frozen — renaming "W toku" to "In progress"
+ * must not break a filter that was saved against it. The derivation reuses the
+ * project-code transliteration so `Do przeglądu` becomes `do-przegladu` rather
+ * than dropping the diacritics into nothing.
+ */
+export function slugifyTaskStatusName(name: string): string {
+  const slug = slugifyProjectName(name).toLowerCase()
+  if (slug.length <= TASK_STATUS_SLUG_MAX_LENGTH) return slug
+  return slug.slice(0, TASK_STATUS_SLUG_MAX_LENGTH).replace(/-+$/g, '')
+}
+
+function withSuffix(base: string, suffix: string): string {
+  const budget = TASK_STATUS_SLUG_MAX_LENGTH - suffix.length
+  const stem = base.length <= budget ? base : base.slice(0, budget).replace(/-+$/g, '')
+  return `${stem || TASK_STATUS_SLUG_FALLBACK}${suffix}`
+}
+
+/**
+ * Derives a slug that does not collide with the ones already on the board. The
+ * partial unique index is still the authority — this only keeps the common case
+ * from reaching it as a constraint violation.
+ */
+export function deriveTaskStatusSlug(name: string, taken: Iterable<string> = []): string {
+  const base = slugifyTaskStatusName(name) || TASK_STATUS_SLUG_FALLBACK
+  const reserved = new Set(Array.from(taken, (value) => String(value).toLowerCase()))
+  if (!reserved.has(base)) return base
+
+  let candidate = base
+  for (let counter = 2; counter < 10000; counter += 1) {
+    candidate = withSuffix(base, `-${counter}`)
+    if (!reserved.has(candidate)) return candidate
+  }
+  return candidate
+}

package/src/modules/staff/lib/timesheets-tasks/taskHierarchy.ts

@@ -0,0 +1,99 @@
+/**
+ * The depth-1 rule behind D-2, as pure predicates.
+ *
+ * A subtask is not a second kind of record — it is a task with `parent_task_id` set,
+ * carrying its own status, assignee and time entries. What keeps that from turning
+ * into an arbitrary tree (which the board, the drawer checklist and the report rollup
+ * would each have to learn to walk) is a single invariant: **a parent may not itself
+ * have a parent**. One level, no exceptions, enforced on create and on re-parent.
+ *
+ * The consequences the rest of the module relies on:
+ *  - the board can filter `parent_task_id IS NULL` and know it is showing every task
+ *    that is not already displayed inside some other task's drawer;
+ *  - the rollup is `own + Σ children` with no recursion;
+ *  - a soft-delete cascade is one level deep, so it is a single extra write set rather
+ *    than a walk.
+ */
+
+export const SUBTASK_DEPTH_EXCEEDED_CODE = 'subtask_depth_exceeded'
+
+/** A parent may have children; a child may not. Depth is counted in edges. */
+export const MAX_TASK_DEPTH = 1
+
+export type TaskHierarchyNode = {
+  id: string
+  timeProjectId: string
+  parentTaskId?: string | null
+}
+
+/** The task being parented. On create it has no id yet and no children. */
+export type TaskHierarchyChild = {
+  id?: string | null
+  timeProjectId: string
+  /** Live children the task already has. A task with children may not become one. */
+  childCount?: number
+}
+
+export type TaskParentRejection =
+  /** The task was pointed at itself. */
+  | 'self_parent'
+  /** Either the intended parent is already a child, or the task itself has children. */
+  | 'subtask_depth_exceeded'
+  /** §2 — a task lives in exactly one project, and so does its parent. */
+  | 'parent_project_mismatch'
+
+/**
+ * Answers "may `child` be parented to `parent`?" — `null` means yes.
+ *
+ * A missing parent is the caller's to report (it is a 404/422 about an unreachable
+ * record, not a shape violation), so this function is only handed a parent that was
+ * actually loaded inside the caller's scope.
+ */
+export function rejectTaskParent(
+  parent: TaskHierarchyNode,
+  child: TaskHierarchyChild,
+): TaskParentRejection | null {
+  if (child.id && parent.id === child.id) return 'self_parent'
+  if (parent.timeProjectId !== child.timeProjectId) return 'parent_project_mismatch'
+  // The intended parent is itself a subtask — accepting this would make a grandchild.
+  if (parent.parentTaskId != null) return 'subtask_depth_exceeded'
+  // The task being moved already holds children, so it cannot also become one.
+  if ((child.childCount ?? 0) > 0) return 'subtask_depth_exceeded'
+  return null
+}
+
+/** True when the task may still gain children (i.e. it is not itself a child). */
+export function canAcceptChildren(task: Pick<TaskHierarchyNode, 'parentTaskId'>): boolean {
+  return task.parentTaskId == null
+}
+
+export type TaskSoftDeletePlan = {
+  taskId: string
+  /** Live children that go with the parent, in the order they were read. */
+  childIds: string[]
+  /** Everything the delete transaction stamps `deleted_at` on. */
+  allIds: string[]
+}
+
+/**
+ * Soft-deleting a parent takes its children with it, in the same transaction.
+ *
+ * Time entries are deliberately absent from the plan: they keep pointing at the
+ * deleted task so a closed report still resolves its line labels months later. The
+ * cascade is one level because the depth rule guarantees the children have none.
+ */
+export function planTaskSoftDelete(
+  task: TaskHierarchyNode,
+  children: readonly Pick<TaskHierarchyNode, 'id'>[] = [],
+): TaskSoftDeletePlan {
+  const childIds: string[] = []
+  const seen = new Set<string>([task.id])
+  // A child task can never bring a cascade of its own, so the list is empty for one.
+  const candidates = canAcceptChildren(task) ? children : []
+  for (const child of candidates) {
+    if (!child?.id || seen.has(child.id)) continue
+    seen.add(child.id)
+    childIds.push(child.id)
+  }
+  return { taskId: task.id, childIds, allIds: [task.id, ...childIds] }
+}

package/src/modules/staff/lib/timesheets-tasks/taskHoursTotals.ts

@@ -0,0 +1,42 @@
+/**
+ * Column totals for the board (screen 6, `kcol-hours`).
+ *
+ * Every card already carries the inclusive rollup (D-2), which makes a column total a
+ * client-side sum of rows the board is holding anyway — no second endpoint, and no way
+ * for the header to disagree with the cards under it.
+ *
+ * It also makes the total the one place risk R10 can bite: adding a parent's
+ * `loggedMinutes` to its child's adds the child twice, because the parent's figure
+ * already contains it. The board never renders a child as its own card, so in practice
+ * the set is parent-only — but "in practice" is not a guarantee a caller can rely on,
+ * so this helper drops any row whose parent is present in the same set instead of
+ * trusting the caller to have filtered it.
+ */
+
+export type TaskHoursRow = {
+  id: string
+  parentTaskId?: string | null
+  loggedMinutes?: number | null
+}
+
+function toMinutes(value: number | null | undefined): number {
+  if (value === null || value === undefined || !Number.isFinite(value)) return 0
+  return value
+}
+
+/**
+ * Sums `loggedMinutes` across a set of tasks without double-counting.
+ *
+ * Never sum the raw field yourself — use this, or sum `ownMinutes` instead. Those are
+ * the only two ways to total a mixed set correctly.
+ */
+export function sumTaskLoggedMinutes(rows: readonly TaskHoursRow[]): number {
+  const presentIds = new Set(rows.map((row) => row.id))
+  let total = 0
+  for (const row of rows) {
+    // The parent's rollup already contains this row's minutes.
+    if (row.parentTaskId && presentIds.has(row.parentTaskId)) continue
+    total += toMinutes(row.loggedMinutes)
+  }
+  return total
+}

package/src/modules/staff/lib/timesheets-tasks/taskReference.ts

@@ -0,0 +1,108 @@
+/**
+ * Per-project task numbering — the `TT-142` on the card, the drawer title and every
+ * report line that names a task.
+ *
+ * The reference is denormalized (`<project.code>-<sequence_number>`) because it is
+ * quoted in places the task row is no longer joined: a closed report keeps its line
+ * labels after the task is gone, and a client-facing sheet must keep showing the same
+ * number it showed last month. Renaming the project's code therefore does not
+ * retro-number existing tasks — the reference is allocated once and frozen.
+ *
+ * Allocation is the interesting part. Two people creating a task in the same project
+ * at the same moment must not both get `TT-142`, and reading `MAX(sequence_number)`
+ * up front does not prevent that — it only narrows the window. The database is the
+ * arbiter instead: the partial unique index on
+ * `(organization_id, tenant_id, time_project_id, sequence_number) WHERE deleted_at IS NULL`
+ * makes the loser's insert fail, and the loser retries the whole transaction, reading
+ * a max that now includes the winner's row. A gap left by a rolled-back attempt is
+ * cosmetic and deliberately not reclaimed (spec risk R6).
+ */
+
+import { isUniqueViolation } from '@open-mercato/shared/lib/crud/errors'
+
+/** Used when a project somehow has no usable code, so a task can still be numbered. */
+export const TASK_REFERENCE_FALLBACK_CODE = 'TASK'
+
+export const FIRST_TASK_SEQUENCE_NUMBER = 1
+
+/**
+ * Attempts before the conflict is surfaced to the caller. Each retry costs one
+ * aborted transaction, and a project would need this many simultaneous creates
+ * landing on the same number for the last one to give up.
+ */
+export const TASK_REFERENCE_MAX_ATTEMPTS = 5
+
+export type TaskReferenceAllocation = {
+  sequenceNumber: number
+  reference: string
+}
+
+export function normalizeProjectCodeForReference(code: string | null | undefined): string {
+  const trimmed = typeof code === 'string' ? code.trim() : ''
+  return trimmed.length > 0 ? trimmed : TASK_REFERENCE_FALLBACK_CODE
+}
+
+export function nextTaskSequenceNumber(highestSequenceNumber: number | null | undefined): number {
+  if (typeof highestSequenceNumber !== 'number' || !Number.isFinite(highestSequenceNumber)) {
+    return FIRST_TASK_SEQUENCE_NUMBER
+  }
+  const next = Math.floor(highestSequenceNumber) + 1
+  return next < FIRST_TASK_SEQUENCE_NUMBER ? FIRST_TASK_SEQUENCE_NUMBER : next
+}
+
+export function formatTaskReference(code: string | null | undefined, sequenceNumber: number): string {
+  return `${normalizeProjectCodeForReference(code)}-${sequenceNumber}`
+}
+
+/**
+ * The candidate one attempt writes. It is a plain function of what that attempt read
+ * inside its own transaction, so nothing is carried between attempts.
+ */
+export function allocateTaskReference(
+  code: string | null | undefined,
+  highestSequenceNumber: number | null | undefined,
+): TaskReferenceAllocation {
+  const sequenceNumber = nextTaskSequenceNumber(highestSequenceNumber)
+  return { sequenceNumber, reference: formatTaskReference(code, sequenceNumber) }
+}
+
+/**
+ * A losing race shows up as a unique violation on either of the task's two partial
+ * indexes — the `(project, sequence_number)` pair or the denormalized `reference`.
+ * Both mean the same thing here: someone else took this number, take the next one.
+ */
+export function isTaskReferenceConflict(err: unknown): boolean {
+  return isUniqueViolation(err)
+}
+
+export type TaskReferenceRetryOptions = {
+  maxAttempts?: number
+  isConflict?: (err: unknown) => boolean
+}
+
+/**
+ * Runs the create attempt until it wins the number or the budget runs out.
+ *
+ * `runAttempt` MUST re-read the project's highest sequence number inside its own
+ * transaction — that is the whole point of retrying rather than pre-reading. A
+ * non-conflict error is rethrown immediately: only a lost race is worth repeating.
+ */
+export async function withTaskReferenceRetry<T>(
+  runAttempt: (attempt: number) => Promise<T>,
+  options: TaskReferenceRetryOptions = {},
+): Promise<T> {
+  const maxAttempts = Math.max(1, options.maxAttempts ?? TASK_REFERENCE_MAX_ATTEMPTS)
+  const isConflict = options.isConflict ?? isTaskReferenceConflict
+  let lastError: unknown = null
+
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    try {
+      return await runAttempt(attempt)
+    } catch (err) {
+      if (!isConflict(err)) throw err
+      lastError = err
+    }
+  }
+
+  throw lastError
+}

package/src/modules/staff/lib/timesheets-ui/CreateProjectDialog.tsx

@@ -16,7 +16,7 @@ import {
   createProjectFormGroups,
   createProjectFormSchema,
   type ProjectFormValues,
-} from '../../backend/staff/timesheets/projects/projectFormConfig'
+} from '../../backend/staff/time-tracking/projects/projectFormConfig'
 
 type CreateProjectDialogProps = {
   open: boolean
@@ -29,11 +29,25 @@ export function CreateProjectDialog({ open, onOpenChange, onProjectCreated }: Cr
 
   const formSchema = React.useMemo(() => createProjectFormSchema(), [])
   const fields = React.useMemo(() => createProjectFormFields(t), [t])
-  const groups = React.useMemo(() => createProjectFormGroups(t), [t])
+  const groups = React.useMemo(() => createProjectFormGroups(t, { compact: true }), [t])
+
+  /**
+   * `CrudForm` bails out of its own Enter-to-submit handling as soon as a
+   * modifier is held, so the shortcut every other dialog in this feature offers
+   * has to be wired here — on the dialog, submitting the embedded form directly.
+   * Escape stays with Radix's dismissable layer, which this never intercepts.
+   */
+  const handleKeyDown = React.useCallback((event: React.KeyboardEvent<HTMLDivElement>) => {
+    if (!((event.metaKey || event.ctrlKey) && event.key === 'Enter')) return
+    const form = event.currentTarget.querySelector('form')
+    if (!form) return
+    event.preventDefault()
+    form.requestSubmit()
+  }, [])
 
   return (
     <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="sm:max-w-lg">
+      <DialogContent className="sm:max-w-lg" data-testid="create-project-dialog" onKeyDown={handleKeyDown}>
         <DialogHeader>
           <DialogTitle>
             {t('staff.timesheets.projects.form.createTitle', 'Create project')}
@@ -44,7 +58,7 @@ export function CreateProjectDialog({ open, onOpenChange, onProjectCreated }: Cr
           fields={fields}
           groups={groups}
           schema={formSchema}
-          initialValues={{}}
+          initialValues={{ status: 'active', billableByDefault: true, codeManual: false }}
           entityIds={[E.staff.staff_time_project]}
           submitLabel={t('staff.timesheets.projects.form.actions.create', 'Create')}
           extraActions={(