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

package/dist/modules/staff/commands/timesheets-task-statuses.js

@@ -0,0 +1,723 @@
+import { z } from "zod";
+import { registerCommand } from "@open-mercato/shared/lib/commands";
+import { CrudHttpError, isUniqueViolation } from "@open-mercato/shared/lib/crud/errors";
+import { resolveTranslations } from "@open-mercato/shared/lib/i18n/server";
+import { buildChanges, emitCrudSideEffects, emitCrudUndoSideEffects } from "@open-mercato/shared/lib/commands/helpers";
+import { withAtomicFlush } from "@open-mercato/shared/lib/commands/flush";
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { StaffTimeProject, StaffTimeTask, StaffTimeTaskStatus } from "../data/entities.js";
+import {
+  staffTimeTaskStatusCreateSchema,
+  staffTimeTaskStatusUpdateSchema,
+  staffTimeTaskStatusReorderSchema
+} from "../data/validators.js";
+import { deriveTaskStatusSlug } from "../lib/timesheets-tasks/statusSlug.js";
+import { nextStatusPosition, planStatusReorder } from "../lib/timesheets-tasks/statusPositions.js";
+import {
+  applyScopeToWhere,
+  commandActorScope,
+  commandInputScope,
+  ensureOrganizationScope,
+  ensureTenantScope,
+  extractUndoPayload,
+  scopedStaffSnapshotWhere,
+  staffSnapshotScopeFromContext,
+  staffSnapshotScopeFromSnapshot
+} from "./shared.js";
+const logger = createLogger("staff").child({ component: "timesheets-task-statuses" });
+const staffTimeTaskStatusCommandIds = {
+  create: "staff.timesheets.task_statuses.create",
+  update: "staff.timesheets.task_statuses.update",
+  delete: "staff.timesheets.task_statuses.delete",
+  reorder: "staff.timesheets.task_statuses.reorder"
+};
+const TASK_STATUS_LAST_COLUMN_CODE = "task_status_last_column";
+const TASK_STATUS_HAS_TASKS_CODE = "task_status_has_tasks";
+const TASK_STATUS_DEFAULT_REQUIRED_CODE = "task_status_default_required";
+const TASK_STATUS_DONE_REQUIRED_CODE = "task_status_done_required";
+const TASK_STATUS_SLUG_DUPLICATE_CODE = "task_status_slug_duplicate";
+const TASK_STATUS_UNKNOWN_IDS_CODE = "task_status_unknown_ids";
+const taskStatusCrudIndexer = {
+  entityType: "staff:staff_time_task_status"
+};
+function toSnapshot(status) {
+  return {
+    id: status.id,
+    tenantId: status.tenantId,
+    organizationId: status.organizationId,
+    timeProjectId: status.timeProjectId,
+    name: status.name,
+    slug: status.slug,
+    color: status.color ?? null,
+    position: status.position,
+    isDefault: status.isDefault,
+    isDone: status.isDone,
+    deletedAt: status.deletedAt ? status.deletedAt.toISOString() : null
+  };
+}
+function toBoardRow(status) {
+  return {
+    id: status.id,
+    position: status.position,
+    isDefault: status.isDefault,
+    isDone: status.isDone
+  };
+}
+async function loadTaskStatusSnapshot(em, id, scope) {
+  const status = await em.findOne(StaffTimeTaskStatus, scopedStaffSnapshotWhere(id, scope));
+  return status ? toSnapshot(status) : null;
+}
+function boardWhere(timeProjectId, scope) {
+  return applyScopeToWhere({ timeProjectId, deletedAt: null }, scope);
+}
+async function loadBoard(em, timeProjectId, scope) {
+  const statuses = await em.find(StaffTimeTaskStatus, boardWhere(timeProjectId, scope));
+  return statuses.sort((left, right) => left.position - right.position || (left.id < right.id ? -1 : 1));
+}
+async function loadBoardSnapshot(em, timeProjectId, scope) {
+  const statuses = await em.find(StaffTimeTaskStatus, {
+    timeProjectId,
+    deletedAt: null,
+    ...snapshotScopeWhere(scope)
+  });
+  return statuses.map(toBoardRow);
+}
+function snapshotScopeWhere(scope) {
+  const where = {};
+  if (scope?.tenantId) where.tenantId = scope.tenantId;
+  if (scope?.organizationId) where.organizationId = scope.organizationId;
+  return where;
+}
+function slugDuplicateError(translate, slug) {
+  const message = translate(
+    "staff.time_tracking.taskStatuses.errors.slugDuplicate",
+    "A column with this slug already exists on this project."
+  );
+  return new CrudHttpError(409, {
+    code: TASK_STATUS_SLUG_DUPLICATE_CODE,
+    error: message,
+    slug,
+    fieldErrors: { slug: message }
+  });
+}
+function notFoundError(translate) {
+  return new CrudHttpError(404, {
+    error: translate(
+      "staff.time_tracking.taskStatuses.errors.notFound",
+      "Task status not found or not accessible."
+    )
+  });
+}
+function projectNotFoundError(translate) {
+  const message = translate("staff.timesheets.errors.projectNotFound", "Time project not found or not accessible.");
+  return new CrudHttpError(422, {
+    error: message,
+    fieldErrors: { timeProjectId: message }
+  });
+}
+function normalizeBoardFlags(board, preferredDefaultId) {
+  if (board.length === 0) return;
+  const defaults = board.filter((status) => status.isDefault);
+  const preferred = preferredDefaultId ? board.find((status) => status.id === preferredDefaultId) ?? null : null;
+  const winner = preferred ?? defaults[0] ?? board[0];
+  for (const status of board) status.isDefault = status.id === winner.id;
+  if (!board.some((status) => status.isDone)) {
+    board[board.length - 1].isDone = true;
+  }
+}
+async function requireProject(em, timeProjectId, scope, translate) {
+  const project = await em.findOne(
+    StaffTimeProject,
+    applyScopeToWhere({ id: timeProjectId, deletedAt: null }, scope),
+    { fields: ["id"] }
+  );
+  if (!project) throw projectNotFoundError(translate);
+}
+async function restoreBoard(em, boardBefore, scope) {
+  if (!boardBefore || boardBefore.length === 0) return [];
+  const ids = boardBefore.map((row) => row.id);
+  const statuses = await em.find(StaffTimeTaskStatus, {
+    id: { $in: ids },
+    ...snapshotScopeWhere(scope)
+  });
+  const byId = new Map(statuses.map((status) => [status.id, status]));
+  const restored = [];
+  for (const row of boardBefore) {
+    const status = byId.get(row.id);
+    if (!status) continue;
+    status.position = row.position;
+    status.isDefault = row.isDefault;
+    status.isDone = row.isDone;
+    status.updatedAt = /* @__PURE__ */ new Date();
+    restored.push(status);
+  }
+  return restored;
+}
+const createTaskStatusCommand = {
+  id: staffTimeTaskStatusCommandIds.create,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeTaskStatusCreateSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const boardBefore = await loadBoardSnapshot(em, parsed.data.timeProjectId, staffSnapshotScopeFromContext(ctx));
+    return { before: { boardBefore } };
+  },
+  async execute(rawInput, ctx) {
+    const parsed = staffTimeTaskStatusCreateSchema.parse(rawInput);
+    ensureTenantScope(ctx, parsed.tenantId);
+    ensureOrganizationScope(ctx, parsed.organizationId);
+    const scope = commandInputScope(ctx, parsed.tenantId, parsed.organizationId);
+    const { translate } = await resolveTranslations();
+    const em = ctx.container.resolve("em").fork();
+    let board = [];
+    let created = null;
+    try {
+      await withAtomicFlush(
+        em,
+        [
+          async () => {
+            await requireProject(em, parsed.timeProjectId, scope, translate);
+            board = await loadBoard(em, parsed.timeProjectId, scope);
+          },
+          () => {
+            const takenSlugs = board.map((status) => status.slug.toLowerCase());
+            const slug = parsed.slug ? parsed.slug.toLowerCase() : deriveTaskStatusSlug(parsed.name, takenSlugs);
+            if (takenSlugs.includes(slug)) throw slugDuplicateError(translate, slug);
+            const isFirstColumn = board.length === 0;
+            created = em.create(StaffTimeTaskStatus, {
+              tenantId: parsed.tenantId,
+              organizationId: parsed.organizationId,
+              timeProjectId: parsed.timeProjectId,
+              name: parsed.name,
+              slug,
+              color: parsed.color ?? null,
+              position: parsed.position ?? nextStatusPosition(board.map((status) => status.position)),
+              // The first column of a board is necessarily both the landing column
+              // and the terminal one, whatever the request asked for.
+              isDefault: isFirstColumn ? true : parsed.isDefault ?? false,
+              isDone: isFirstColumn ? true : parsed.isDone ?? false,
+              createdAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date(),
+              deletedAt: null
+            });
+            em.persist(created);
+            normalizeBoardFlags([...board, created], created.isDefault ? created.id : null);
+          }
+        ],
+        { transaction: true, label: staffTimeTaskStatusCommandIds.create }
+      );
+    } catch (err) {
+      if (isUniqueViolation(err)) throw slugDuplicateError(translate, parsed.slug ?? parsed.name);
+      throw err;
+    }
+    const record = created;
+    if (!record) throw notFoundError(translate);
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "created",
+      entity: record,
+      identifiers: { id: record.id, organizationId: record.organizationId, tenantId: record.tenantId },
+      indexer: taskStatusCrudIndexer
+    });
+    return { taskStatusId: record.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = ctx.container.resolve("em").fork();
+    const snapshot = await loadTaskStatusSnapshot(em, result.taskStatusId, staffSnapshotScopeFromContext(ctx));
+    if (!snapshot) return null;
+    return { snapshot };
+  },
+  buildLog: async ({ result, snapshots, ctx }) => {
+    const em = ctx.container.resolve("em").fork();
+    const snapshot = await loadTaskStatusSnapshot(em, result.taskStatusId, staffSnapshotScopeFromContext(ctx));
+    if (!snapshot) return null;
+    const boardBefore = snapshots.before?.boardBefore ?? null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.task_statuses.create", "Create task status"),
+      resourceKind: "staff.timesheets.task_status",
+      resourceId: snapshot.id,
+      tenantId: snapshot.tenantId,
+      organizationId: snapshot.organizationId,
+      snapshotAfter: snapshot,
+      payload: {
+        undo: {
+          after: snapshot,
+          boardBefore
+        }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const after = payload?.after;
+    if (!after) return;
+    const snapshotScope = staffSnapshotScopeFromSnapshot(after);
+    const em = ctx.container.resolve("em").fork();
+    const status = await em.findOne(StaffTimeTaskStatus, scopedStaffSnapshotWhere(after.id, snapshotScope));
+    if (!status) return;
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          status.deletedAt = /* @__PURE__ */ new Date();
+          status.updatedAt = /* @__PURE__ */ new Date();
+        },
+        // The board is re-read here, so it has to be its own phase.
+        () => restoreBoard(em, payload?.boardBefore, snapshotScope)
+      ],
+      { transaction: true, label: `${staffTimeTaskStatusCommandIds.create}.undo` }
+    );
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "deleted",
+      entity: status,
+      identifiers: { id: status.id, organizationId: status.organizationId, tenantId: status.tenantId },
+      indexer: taskStatusCrudIndexer
+    });
+  }
+};
+const updateTaskStatusCommand = {
+  id: staffTimeTaskStatusCommandIds.update,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeTaskStatusUpdateSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const scope = staffSnapshotScopeFromContext(ctx);
+    const before = await loadTaskStatusSnapshot(em, parsed.data.id, scope);
+    if (!before) return {};
+    const boardBefore = await loadBoardSnapshot(em, before.timeProjectId, scope);
+    return { before: { snapshot: before, boardBefore } };
+  },
+  async execute(rawInput, ctx) {
+    const parsed = staffTimeTaskStatusUpdateSchema.parse(rawInput);
+    const { translate } = await resolveTranslations();
+    const em = ctx.container.resolve("em").fork();
+    const scope = commandActorScope(ctx);
+    const status = await em.findOne(
+      StaffTimeTaskStatus,
+      applyScopeToWhere({ id: parsed.id, deletedAt: null }, scope)
+    );
+    if (!status) throw notFoundError(translate);
+    ensureTenantScope(ctx, status.tenantId);
+    ensureOrganizationScope(ctx, status.organizationId);
+    let board = [];
+    try {
+      await withAtomicFlush(
+        em,
+        [
+          async () => {
+            board = await loadBoard(em, status.timeProjectId, scope);
+          },
+          () => {
+            if (parsed.name !== void 0) status.name = parsed.name;
+            if (parsed.color !== void 0) status.color = parsed.color ?? null;
+            if (parsed.isDefault === false && status.isDefault) {
+              throw new CrudHttpError(409, {
+                code: TASK_STATUS_DEFAULT_REQUIRED_CODE,
+                error: translate(
+                  "staff.time_tracking.taskStatuses.errors.defaultRequired",
+                  "A project needs one default column. Mark another column as the default instead."
+                )
+              });
+            }
+            if (parsed.isDone === false && status.isDone && board.filter((row) => row.isDone).length <= 1) {
+              throw new CrudHttpError(409, {
+                code: TASK_STATUS_DONE_REQUIRED_CODE,
+                error: translate(
+                  "staff.time_tracking.taskStatuses.errors.doneRequired",
+                  "A project needs at least one done column. Mark another column as done first."
+                )
+              });
+            }
+            if (parsed.isDone !== void 0) status.isDone = parsed.isDone;
+            if (parsed.isDefault === true) status.isDefault = true;
+            if (parsed.position !== void 0) {
+              const plan = planStatusReorder(
+                board.map((row) => ({ id: row.id, position: row.position })),
+                [{ id: status.id, position: parsed.position }]
+              );
+              const byId = new Map(board.map((row) => [row.id, row]));
+              for (const update of plan.updates) {
+                const target = byId.get(update.id);
+                if (!target) continue;
+                target.position = update.position;
+                target.updatedAt = /* @__PURE__ */ new Date();
+              }
+              if (plan.compacted) {
+                logger.debug("Compacted task status board", {
+                  timeProjectId: status.timeProjectId,
+                  updates: plan.updates.length
+                });
+              }
+            }
+            normalizeBoardFlags(board, parsed.isDefault === true ? status.id : null);
+            status.updatedAt = /* @__PURE__ */ new Date();
+          }
+        ],
+        { transaction: true, label: staffTimeTaskStatusCommandIds.update }
+      );
+    } catch (err) {
+      if (isUniqueViolation(err)) throw slugDuplicateError(translate, status.slug);
+      throw err;
+    }
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "updated",
+      entity: status,
+      identifiers: { id: status.id, organizationId: status.organizationId, tenantId: status.tenantId },
+      indexer: taskStatusCrudIndexer
+    });
+    return { taskStatusId: status.id };
+  },
+  buildLog: async ({ snapshots, ctx }) => {
+    const prepared = snapshots.before;
+    const before = prepared?.snapshot;
+    if (!before) return null;
+    const em = ctx.container.resolve("em").fork();
+    const after = await loadTaskStatusSnapshot(em, before.id, staffSnapshotScopeFromSnapshot(before));
+    if (!after) return null;
+    const changes = buildChanges(
+      before,
+      after,
+      ["name", "color", "position", "isDefault", "isDone"]
+    );
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.task_statuses.update", "Update task status"),
+      resourceKind: "staff.timesheets.task_status",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      snapshotAfter: after,
+      changes,
+      payload: {
+        undo: {
+          before,
+          after,
+          boardBefore: prepared?.boardBefore ?? null
+        }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const snapshotScope = staffSnapshotScopeFromSnapshot(before);
+    const em = ctx.container.resolve("em").fork();
+    const status = await em.findOne(StaffTimeTaskStatus, scopedStaffSnapshotWhere(before.id, snapshotScope));
+    if (!status) return;
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          status.name = before.name;
+          status.color = before.color ?? null;
+          status.updatedAt = /* @__PURE__ */ new Date();
+        },
+        // Positions and flags belong to the whole board, and restoring them
+        // re-reads the sibling rows.
+        () => restoreBoard(em, payload?.boardBefore, snapshotScope)
+      ],
+      { transaction: true, label: `${staffTimeTaskStatusCommandIds.update}.undo` }
+    );
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "updated",
+      entity: status,
+      identifiers: { id: status.id, organizationId: status.organizationId, tenantId: status.tenantId },
+      indexer: taskStatusCrudIndexer
+    });
+  }
+};
+const deleteTaskStatusCommand = {
+  id: staffTimeTaskStatusCommandIds.delete,
+  async prepare(input, ctx) {
+    const id = input?.id;
+    if (!id) return {};
+    const em = ctx.container.resolve("em");
+    const scope = staffSnapshotScopeFromContext(ctx);
+    const before = await loadTaskStatusSnapshot(em, id, scope);
+    if (!before) return {};
+    const boardBefore = await loadBoardSnapshot(em, before.timeProjectId, scope);
+    return { before: { snapshot: before, boardBefore } };
+  },
+  async execute(input, ctx) {
+    const { translate } = await resolveTranslations();
+    const id = input?.id;
+    if (!id) {
+      throw new CrudHttpError(400, {
+        error: translate("staff.time_tracking.taskStatuses.errors.idRequired", "Task status id is required.")
+      });
+    }
+    const em = ctx.container.resolve("em").fork();
+    const scope = commandActorScope(ctx);
+    const status = await em.findOne(
+      StaffTimeTaskStatus,
+      applyScopeToWhere({ id, deletedAt: null }, scope)
+    );
+    if (!status) throw notFoundError(translate);
+    ensureTenantScope(ctx, status.tenantId);
+    ensureOrganizationScope(ctx, status.organizationId);
+    let survivors = [];
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          const board = await loadBoard(em, status.timeProjectId, scope);
+          survivors = board.filter((row) => row.id !== status.id);
+          if (survivors.length === 0) {
+            throw new CrudHttpError(409, {
+              code: TASK_STATUS_LAST_COLUMN_CODE,
+              error: translate(
+                "staff.time_tracking.taskStatuses.errors.lastColumn",
+                "A project needs at least one column. Add another column before removing this one."
+              )
+            });
+          }
+          const taskCount = await em.count(
+            StaffTimeTask,
+            applyScopeToWhere({ taskStatusId: status.id, deletedAt: null }, scope)
+          );
+          if (taskCount > 0) {
+            throw new CrudHttpError(409, {
+              code: TASK_STATUS_HAS_TASKS_CODE,
+              error: translate(
+                "staff.time_tracking.taskStatuses.errors.hasTasks",
+                "This column still holds tasks. Move them to another column before removing it."
+              ),
+              taskCount
+            });
+          }
+        },
+        () => {
+          status.deletedAt = /* @__PURE__ */ new Date();
+          status.updatedAt = /* @__PURE__ */ new Date();
+          normalizeBoardFlags(survivors, null);
+        }
+      ],
+      { transaction: true, label: staffTimeTaskStatusCommandIds.delete }
+    );
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "deleted",
+      entity: status,
+      identifiers: { id: status.id, organizationId: status.organizationId, tenantId: status.tenantId },
+      indexer: taskStatusCrudIndexer
+    });
+    return { taskStatusId: status.id };
+  },
+  buildLog: async ({ snapshots }) => {
+    const prepared = snapshots.before;
+    const before = prepared?.snapshot;
+    if (!before) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.task_statuses.delete", "Delete task status"),
+      resourceKind: "staff.timesheets.task_status",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      payload: {
+        undo: {
+          before,
+          boardBefore: prepared?.boardBefore ?? null
+        }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const before = payload?.before;
+    if (!before) return;
+    const snapshotScope = staffSnapshotScopeFromSnapshot(before);
+    const em = ctx.container.resolve("em").fork();
+    let status = await em.findOne(StaffTimeTaskStatus, scopedStaffSnapshotWhere(before.id, snapshotScope));
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          if (!status) {
+            status = em.create(StaffTimeTaskStatus, {
+              id: before.id,
+              tenantId: before.tenantId,
+              organizationId: before.organizationId,
+              timeProjectId: before.timeProjectId,
+              name: before.name,
+              slug: before.slug,
+              color: before.color ?? null,
+              position: before.position,
+              isDefault: before.isDefault,
+              isDone: before.isDone,
+              createdAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date(),
+              deletedAt: null
+            });
+            em.persist(status);
+            return;
+          }
+          status.name = before.name;
+          status.slug = before.slug;
+          status.color = before.color ?? null;
+          status.position = before.position;
+          status.isDefault = before.isDefault;
+          status.isDone = before.isDone;
+          status.deletedAt = null;
+          status.updatedAt = /* @__PURE__ */ new Date();
+        },
+        () => restoreBoard(em, payload?.boardBefore, snapshotScope)
+      ],
+      { transaction: true, label: `${staffTimeTaskStatusCommandIds.delete}.undo` }
+    );
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "created",
+      entity: status,
+      identifiers: {
+        id: before.id,
+        organizationId: before.organizationId,
+        tenantId: before.tenantId
+      },
+      indexer: taskStatusCrudIndexer
+    });
+  }
+};
+const reorderTaskStatusCommandSchema = staffTimeTaskStatusReorderSchema.extend({
+  timeProjectId: z.string().uuid()
+});
+const reorderTaskStatusesCommand = {
+  id: staffTimeTaskStatusCommandIds.reorder,
+  async prepare(rawInput, ctx) {
+    const parsed = reorderTaskStatusCommandSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const boardBefore = await loadBoardSnapshot(em, parsed.data.timeProjectId, staffSnapshotScopeFromContext(ctx));
+    return { before: { timeProjectId: parsed.data.timeProjectId, boardBefore } };
+  },
+  async execute(rawInput, ctx) {
+    const parsed = reorderTaskStatusCommandSchema.parse(rawInput);
+    const { translate } = await resolveTranslations();
+    const em = ctx.container.resolve("em").fork();
+    const scope = commandActorScope(ctx);
+    let board = [];
+    let updatedIds = [];
+    let compacted = false;
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          await requireProject(em, parsed.timeProjectId, scope, translate);
+          board = await loadBoard(em, parsed.timeProjectId, scope);
+        },
+        () => {
+          const plan = planStatusReorder(
+            board.map((row) => ({ id: row.id, position: row.position })),
+            parsed.statuses
+          );
+          if (plan.unknownIds.length > 0) {
+            throw new CrudHttpError(422, {
+              code: TASK_STATUS_UNKNOWN_IDS_CODE,
+              error: translate(
+                "staff.time_tracking.taskStatuses.errors.unknownIds",
+                "Some columns do not belong to this project."
+              ),
+              unknownIds: plan.unknownIds
+            });
+          }
+          const byId = new Map(board.map((row) => [row.id, row]));
+          for (const update of plan.updates) {
+            const target = byId.get(update.id);
+            if (!target) continue;
+            target.position = update.position;
+            target.updatedAt = /* @__PURE__ */ new Date();
+          }
+          updatedIds = plan.updates.map((update) => update.id);
+          compacted = plan.compacted;
+        }
+      ],
+      { transaction: true, label: staffTimeTaskStatusCommandIds.reorder }
+    );
+    const dataEngine = ctx.container.resolve("dataEngine");
+    for (const status of board) {
+      if (!updatedIds.includes(status.id)) continue;
+      await emitCrudSideEffects({
+        dataEngine,
+        action: "updated",
+        entity: status,
+        identifiers: { id: status.id, organizationId: status.organizationId, tenantId: status.tenantId },
+        indexer: taskStatusCrudIndexer
+      });
+    }
+    return { timeProjectId: parsed.timeProjectId, updatedIds, compacted };
+  },
+  buildLog: async ({ result, snapshots, ctx }) => {
+    const prepared = snapshots.before;
+    const boardBefore = prepared?.boardBefore ?? null;
+    if (!boardBefore || boardBefore.length === 0) return null;
+    const em = ctx.container.resolve("em").fork();
+    const scope = staffSnapshotScopeFromContext(ctx);
+    const boardAfter = await loadBoardSnapshot(em, result.timeProjectId, scope);
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.task_statuses.reorder", "Reorder task statuses"),
+      resourceKind: "staff.timesheets.task_status",
+      resourceId: result.timeProjectId,
+      tenantId: scope?.tenantId ?? null,
+      organizationId: ctx.selectedOrganizationId ?? ctx.auth?.orgId ?? null,
+      snapshotBefore: { statuses: boardBefore },
+      snapshotAfter: { statuses: boardAfter },
+      payload: {
+        undo: {
+          boardBefore
+        }
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    const boardBefore = payload?.boardBefore;
+    if (!boardBefore || boardBefore.length === 0) return;
+    const em = ctx.container.resolve("em").fork();
+    const snapshotScope = staffSnapshotScopeFromContext(ctx);
+    let restored = [];
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          restored = await restoreBoard(em, boardBefore, snapshotScope);
+        }
+      ],
+      {
+        transaction: true,
+        label: `${staffTimeTaskStatusCommandIds.reorder}.undo`
+      }
+    );
+    const dataEngine = ctx.container.resolve("dataEngine");
+    for (const status of restored) {
+      await emitCrudUndoSideEffects({
+        dataEngine,
+        action: "updated",
+        entity: status,
+        identifiers: { id: status.id, organizationId: status.organizationId, tenantId: status.tenantId },
+        indexer: taskStatusCrudIndexer
+      });
+    }
+  }
+};
+registerCommand(createTaskStatusCommand);
+registerCommand(updateTaskStatusCommand);
+registerCommand(deleteTaskStatusCommand);
+registerCommand(reorderTaskStatusesCommand);
+export {
+  TASK_STATUS_DEFAULT_REQUIRED_CODE,
+  TASK_STATUS_DONE_REQUIRED_CODE,
+  TASK_STATUS_HAS_TASKS_CODE,
+  TASK_STATUS_LAST_COLUMN_CODE,
+  TASK_STATUS_SLUG_DUPLICATE_CODE,
+  TASK_STATUS_UNKNOWN_IDS_CODE,
+  staffTimeTaskStatusCommandIds
+};
+//# sourceMappingURL=timesheets-task-statuses.js.map