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

package/dist/modules/staff/commands/timesheets-tags.js

@@ -0,0 +1,1015 @@
+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 {
+  StaffTimeEntry,
+  StaffTimeEntryTag,
+  StaffTimeTag,
+  StaffTimeTask,
+  StaffTimeTaskTag
+} from "../data/entities.js";
+import {
+  staffTimeTagCreateSchema,
+  staffTimeEntryTagAssignmentSchema,
+  staffTimeTaskTagAssignmentSchema
+} from "../data/validators.js";
+import {
+  applyScopeToWhere,
+  commandActorScope,
+  commandInputScope,
+  ensureOrganizationScope,
+  ensureTenantScope,
+  extractUndoPayload,
+  scopedStaffSnapshotWhere,
+  staffSnapshotScopeFromContext,
+  staffSnapshotScopeFromSnapshot
+} from "./shared.js";
+const staffTimeTagCommandIds = {
+  create: "staff.timesheets.tags.create",
+  update: "staff.timesheets.tags.update",
+  delete: "staff.timesheets.tags.delete",
+  assignTask: "staff.timesheets.tags.assign_task",
+  unassignTask: "staff.timesheets.tags.unassign_task",
+  assignEntry: "staff.timesheets.tags.assign_entry",
+  unassignEntry: "staff.timesheets.tags.unassign_entry"
+};
+const TAG_SLUG_DUPLICATE_CODE = "time_tag_slug_duplicate";
+const TAG_UNKNOWN_IDS_CODE = "time_tag_unknown_ids";
+const TAG_TARGET_LOCKED_CODE = "time_entry_locked";
+const TAG_ASSIGNMENT_SNAPSHOT_LIMIT = 500;
+const tagCrudIndexer = {
+  entityType: "staff:staff_time_tag"
+};
+const taskCrudIndexer = {
+  entityType: "staff:staff_time_task"
+};
+const timeEntryCrudIndexer = {
+  entityType: "staff:staff_time_entry"
+};
+const staffTimeTagUpdateSchema = z.object({
+  id: z.string().uuid(),
+  slug: staffTimeTagCreateSchema.shape.slug.optional(),
+  label: staffTimeTagCreateSchema.shape.label.optional(),
+  color: staffTimeTagCreateSchema.shape.color
+});
+function toTagSnapshot(tag) {
+  return {
+    id: tag.id,
+    tenantId: tag.tenantId,
+    organizationId: tag.organizationId,
+    slug: tag.slug,
+    label: tag.label,
+    color: tag.color ?? null,
+    deletedAt: tag.deletedAt ? tag.deletedAt.toISOString() : null
+  };
+}
+async function loadTagSnapshot(em, id, scope) {
+  const tag = await em.findOne(StaffTimeTag, scopedStaffSnapshotWhere(id, scope));
+  return tag ? toTagSnapshot(tag) : null;
+}
+function slugDuplicateError(translate, slug) {
+  const message = translate(
+    "staff.time_tracking.tags.errors.slugDuplicate",
+    "A tag with this slug already exists."
+  );
+  return new CrudHttpError(409, {
+    code: TAG_SLUG_DUPLICATE_CODE,
+    error: message,
+    slug,
+    fieldErrors: { slug: message }
+  });
+}
+function tagNotFoundError(translate) {
+  return new CrudHttpError(404, {
+    error: translate("staff.time_tracking.tags.errors.notFound", "Tag not found or not accessible.")
+  });
+}
+function unknownTagIdsError(translate, unknownIds) {
+  const message = translate(
+    "staff.time_tracking.tags.errors.unknownIds",
+    "Some tags do not exist in this organization."
+  );
+  return new CrudHttpError(422, {
+    code: TAG_UNKNOWN_IDS_CODE,
+    error: message,
+    unknownIds,
+    fieldErrors: { tagIds: message }
+  });
+}
+function targetNotFoundError(translate, target) {
+  const message = target === "task" ? translate("staff.time_tracking.tags.errors.taskNotFound", "Task not found or not accessible.") : translate("staff.time_tracking.tags.errors.entryNotFound", "Time entry not found or not accessible.");
+  return new CrudHttpError(404, { error: message });
+}
+function snapshotScopeWhere(scope) {
+  const where = {};
+  if (scope?.tenantId) where.tenantId = scope.tenantId;
+  if (scope?.organizationId) where.organizationId = scope.organizationId;
+  return where;
+}
+const taskJunctionOps = {
+  target: "task",
+  resourceKind: "staff.timesheets.task_tag",
+  loadAssignments: async (em, targetId, scope) => {
+    const rows = await em.find(StaffTimeTaskTag, applyScopeToWhere({ taskId: targetId }, scope));
+    return rows.map((row) => ({
+      id: row.id,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId,
+      tagId: row.tagId,
+      targetId: row.taskId
+    }));
+  },
+  loadAssignmentsForSnapshot: async (em, targetId, scope) => {
+    const rows = await em.find(StaffTimeTaskTag, { taskId: targetId, ...snapshotScopeWhere(scope) });
+    return rows.map((row) => ({
+      id: row.id,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId,
+      tagId: row.tagId,
+      targetId: row.taskId
+    }));
+  },
+  loadAssignmentsByTag: async (em, tagId, scope) => {
+    const rows = await em.find(StaffTimeTaskTag, applyScopeToWhere({ tagId }, scope), {
+      limit: TAG_ASSIGNMENT_SNAPSHOT_LIMIT + 1
+    });
+    return rows.map((row) => ({
+      id: row.id,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId,
+      tagId: row.tagId,
+      targetId: row.taskId
+    }));
+  },
+  createAssignment: (em, row) => {
+    em.persist(
+      em.create(StaffTimeTaskTag, {
+        tenantId: row.tenantId,
+        organizationId: row.organizationId,
+        tagId: row.tagId,
+        taskId: row.targetId,
+        createdAt: /* @__PURE__ */ new Date()
+      })
+    );
+  },
+  deleteAssignments: async (em, ids, scope) => em.nativeDelete(StaffTimeTaskTag, applyScopeToWhere({ id: { $in: ids } }, scope)),
+  deleteAssignmentsByTag: async (em, tagId, scope) => em.nativeDelete(StaffTimeTaskTag, applyScopeToWhere({ tagId }, scope)),
+  restoreAssignments: async (em, rows) => {
+    for (const row of rows) {
+      const existing = await em.findOne(StaffTimeTaskTag, {
+        tagId: row.tagId,
+        taskId: row.targetId,
+        tenantId: row.tenantId,
+        organizationId: row.organizationId
+      });
+      if (existing) continue;
+      em.persist(
+        em.create(StaffTimeTaskTag, {
+          id: row.id,
+          tenantId: row.tenantId,
+          organizationId: row.organizationId,
+          tagId: row.tagId,
+          taskId: row.targetId,
+          createdAt: /* @__PURE__ */ new Date()
+        })
+      );
+    }
+  }
+};
+const entryJunctionOps = {
+  target: "time_entry",
+  resourceKind: "staff.timesheets.entry_tag",
+  loadAssignments: async (em, targetId, scope) => {
+    const rows = await em.find(
+      StaffTimeEntryTag,
+      applyScopeToWhere({ timeEntryId: targetId }, scope)
+    );
+    return rows.map((row) => ({
+      id: row.id,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId,
+      tagId: row.tagId,
+      targetId: row.timeEntryId
+    }));
+  },
+  loadAssignmentsForSnapshot: async (em, targetId, scope) => {
+    const rows = await em.find(StaffTimeEntryTag, { timeEntryId: targetId, ...snapshotScopeWhere(scope) });
+    return rows.map((row) => ({
+      id: row.id,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId,
+      tagId: row.tagId,
+      targetId: row.timeEntryId
+    }));
+  },
+  loadAssignmentsByTag: async (em, tagId, scope) => {
+    const rows = await em.find(StaffTimeEntryTag, applyScopeToWhere({ tagId }, scope), {
+      limit: TAG_ASSIGNMENT_SNAPSHOT_LIMIT + 1
+    });
+    return rows.map((row) => ({
+      id: row.id,
+      tenantId: row.tenantId,
+      organizationId: row.organizationId,
+      tagId: row.tagId,
+      targetId: row.timeEntryId
+    }));
+  },
+  createAssignment: (em, row) => {
+    em.persist(
+      em.create(StaffTimeEntryTag, {
+        tenantId: row.tenantId,
+        organizationId: row.organizationId,
+        tagId: row.tagId,
+        timeEntryId: row.targetId,
+        createdAt: /* @__PURE__ */ new Date()
+      })
+    );
+  },
+  deleteAssignments: async (em, ids, scope) => em.nativeDelete(StaffTimeEntryTag, applyScopeToWhere({ id: { $in: ids } }, scope)),
+  deleteAssignmentsByTag: async (em, tagId, scope) => em.nativeDelete(StaffTimeEntryTag, applyScopeToWhere({ tagId }, scope)),
+  restoreAssignments: async (em, rows) => {
+    for (const row of rows) {
+      const existing = await em.findOne(StaffTimeEntryTag, {
+        tagId: row.tagId,
+        timeEntryId: row.targetId,
+        tenantId: row.tenantId,
+        organizationId: row.organizationId
+      });
+      if (existing) continue;
+      em.persist(
+        em.create(StaffTimeEntryTag, {
+          id: row.id,
+          tenantId: row.tenantId,
+          organizationId: row.organizationId,
+          tagId: row.tagId,
+          timeEntryId: row.targetId,
+          createdAt: /* @__PURE__ */ new Date()
+        })
+      );
+    }
+  }
+};
+async function requireKnownTags(em, tagIds, scope, translate) {
+  const unique = Array.from(new Set(tagIds));
+  if (unique.length === 0) return;
+  const tags = await em.find(
+    StaffTimeTag,
+    applyScopeToWhere({ id: { $in: unique }, deletedAt: null }, scope),
+    { fields: ["id"] }
+  );
+  const known = new Set(tags.map((tag) => tag.id));
+  const unknownIds = unique.filter((id) => !known.has(id));
+  if (unknownIds.length > 0) throw unknownTagIdsError(translate, unknownIds);
+}
+const createTagCommand = {
+  id: staffTimeTagCommandIds.create,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeTagCreateSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const existing = await em.findOne(StaffTimeTag, {
+      slug: parsed.data.slug,
+      tenantId: parsed.data.tenantId,
+      organizationId: parsed.data.organizationId,
+      deletedAt: null
+    });
+    return { before: { slugTaken: existing != null } };
+  },
+  async execute(rawInput, ctx) {
+    const parsed = staffTimeTagCreateSchema.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 created = null;
+    try {
+      await withAtomicFlush(
+        em,
+        [
+          async () => {
+            const duplicate = await em.findOne(
+              StaffTimeTag,
+              applyScopeToWhere({ slug: parsed.slug, deletedAt: null }, scope),
+              { fields: ["id"] }
+            );
+            if (duplicate) throw slugDuplicateError(translate, parsed.slug);
+          },
+          () => {
+            created = em.create(StaffTimeTag, {
+              tenantId: parsed.tenantId,
+              organizationId: parsed.organizationId,
+              slug: parsed.slug,
+              label: parsed.label,
+              color: parsed.color ?? null,
+              createdAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date(),
+              deletedAt: null
+            });
+            em.persist(created);
+          }
+        ],
+        { transaction: true, label: staffTimeTagCommandIds.create }
+      );
+    } catch (err) {
+      if (isUniqueViolation(err)) throw slugDuplicateError(translate, parsed.slug);
+      throw err;
+    }
+    const record = created;
+    if (!record) throw tagNotFoundError(translate);
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "created",
+      entity: record,
+      identifiers: { id: record.id, organizationId: record.organizationId, tenantId: record.tenantId },
+      indexer: tagCrudIndexer
+    });
+    return { tagId: record.id };
+  },
+  captureAfter: async (_input, result, ctx) => {
+    const em = ctx.container.resolve("em").fork();
+    const snapshot = await loadTagSnapshot(em, result.tagId, staffSnapshotScopeFromContext(ctx));
+    if (!snapshot) return null;
+    return { snapshot };
+  },
+  buildLog: async ({ result, ctx }) => {
+    const em = ctx.container.resolve("em").fork();
+    const snapshot = await loadTagSnapshot(em, result.tagId, staffSnapshotScopeFromContext(ctx));
+    if (!snapshot) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tags.create", "Create tag"),
+      resourceKind: "staff.timesheets.tag",
+      resourceId: snapshot.id,
+      tenantId: snapshot.tenantId,
+      organizationId: snapshot.organizationId,
+      snapshotAfter: snapshot,
+      payload: {
+        undo: { after: snapshot }
+      }
+    };
+  },
+  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 tag = await em.findOne(StaffTimeTag, scopedStaffSnapshotWhere(after.id, snapshotScope));
+    if (!tag) return;
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          tag.deletedAt = /* @__PURE__ */ new Date();
+          tag.updatedAt = /* @__PURE__ */ new Date();
+        }
+      ],
+      { transaction: true, label: `${staffTimeTagCommandIds.create}.undo` }
+    );
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "deleted",
+      entity: tag,
+      identifiers: { id: tag.id, organizationId: tag.organizationId, tenantId: tag.tenantId },
+      indexer: tagCrudIndexer
+    });
+  }
+};
+const updateTagCommand = {
+  id: staffTimeTagCommandIds.update,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeTagUpdateSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const before = await loadTagSnapshot(em, parsed.data.id, staffSnapshotScopeFromContext(ctx));
+    if (!before) return {};
+    return { before: { snapshot: before } };
+  },
+  async execute(rawInput, ctx) {
+    const parsed = staffTimeTagUpdateSchema.parse(rawInput);
+    const { translate } = await resolveTranslations();
+    const em = ctx.container.resolve("em").fork();
+    const scope = commandActorScope(ctx);
+    const tag = await em.findOne(StaffTimeTag, applyScopeToWhere({ id: parsed.id, deletedAt: null }, scope));
+    if (!tag) throw tagNotFoundError(translate);
+    ensureTenantScope(ctx, tag.tenantId);
+    ensureOrganizationScope(ctx, tag.organizationId);
+    try {
+      await withAtomicFlush(
+        em,
+        [
+          async () => {
+            if (parsed.slug === void 0 || parsed.slug === tag.slug) return;
+            const duplicate = await em.findOne(
+              StaffTimeTag,
+              applyScopeToWhere({ slug: parsed.slug, deletedAt: null, id: { $ne: tag.id } }, scope),
+              { fields: ["id"] }
+            );
+            if (duplicate) throw slugDuplicateError(translate, parsed.slug);
+          },
+          () => {
+            if (parsed.slug !== void 0) tag.slug = parsed.slug;
+            if (parsed.label !== void 0) tag.label = parsed.label;
+            if (parsed.color !== void 0) tag.color = parsed.color ?? null;
+            tag.updatedAt = /* @__PURE__ */ new Date();
+          }
+        ],
+        { transaction: true, label: staffTimeTagCommandIds.update }
+      );
+    } catch (err) {
+      if (isUniqueViolation(err)) throw slugDuplicateError(translate, parsed.slug ?? tag.slug);
+      throw err;
+    }
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "updated",
+      entity: tag,
+      identifiers: { id: tag.id, organizationId: tag.organizationId, tenantId: tag.tenantId },
+      indexer: tagCrudIndexer
+    });
+    return { tagId: tag.id };
+  },
+  buildLog: async ({ snapshots, ctx }) => {
+    const before = snapshots.before?.snapshot;
+    if (!before) return null;
+    const em = ctx.container.resolve("em").fork();
+    const after = await loadTagSnapshot(em, before.id, staffSnapshotScopeFromSnapshot(before));
+    if (!after) return null;
+    const changes = buildChanges(
+      before,
+      after,
+      ["slug", "label", "color"]
+    );
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tags.update", "Update tag"),
+      resourceKind: "staff.timesheets.tag",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      snapshotAfter: after,
+      changes,
+      payload: {
+        undo: { before, after }
+      }
+    };
+  },
+  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 tag = await em.findOne(StaffTimeTag, scopedStaffSnapshotWhere(before.id, snapshotScope));
+    if (!tag) return;
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          tag.slug = before.slug;
+          tag.label = before.label;
+          tag.color = before.color ?? null;
+          tag.updatedAt = /* @__PURE__ */ new Date();
+        }
+      ],
+      { transaction: true, label: `${staffTimeTagCommandIds.update}.undo` }
+    );
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "updated",
+      entity: tag,
+      identifiers: { id: tag.id, organizationId: tag.organizationId, tenantId: tag.tenantId },
+      indexer: tagCrudIndexer
+    });
+  }
+};
+const deleteTagCommand = {
+  id: staffTimeTagCommandIds.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 loadTagSnapshot(em, id, scope);
+    if (!before) return {};
+    const readScope = {
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      requireTenant: true,
+      requireOrganization: true
+    };
+    const taskAssignments = await taskJunctionOps.loadAssignmentsByTag(em, id, readScope);
+    const entryAssignments = await entryJunctionOps.loadAssignmentsByTag(em, id, readScope);
+    const truncated = taskAssignments.length > TAG_ASSIGNMENT_SNAPSHOT_LIMIT || entryAssignments.length > TAG_ASSIGNMENT_SNAPSHOT_LIMIT;
+    return {
+      before: {
+        snapshot: before,
+        taskAssignments: taskAssignments.slice(0, TAG_ASSIGNMENT_SNAPSHOT_LIMIT),
+        entryAssignments: entryAssignments.slice(0, TAG_ASSIGNMENT_SNAPSHOT_LIMIT),
+        assignmentsTruncated: truncated
+      }
+    };
+  },
+  async execute(input, ctx) {
+    const { translate } = await resolveTranslations();
+    const id = input?.id;
+    if (!id) {
+      throw new CrudHttpError(400, {
+        error: translate("staff.time_tracking.tags.errors.idRequired", "Tag id is required.")
+      });
+    }
+    const em = ctx.container.resolve("em").fork();
+    const scope = commandActorScope(ctx);
+    const tag = await em.findOne(StaffTimeTag, applyScopeToWhere({ id, deletedAt: null }, scope));
+    if (!tag) throw tagNotFoundError(translate);
+    ensureTenantScope(ctx, tag.tenantId);
+    ensureOrganizationScope(ctx, tag.organizationId);
+    let removedTaskAssignments = 0;
+    let removedEntryAssignments = 0;
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          removedTaskAssignments = await taskJunctionOps.deleteAssignmentsByTag(em, tag.id, scope);
+          removedEntryAssignments = await entryJunctionOps.deleteAssignmentsByTag(em, tag.id, scope);
+        },
+        () => {
+          tag.deletedAt = /* @__PURE__ */ new Date();
+          tag.updatedAt = /* @__PURE__ */ new Date();
+        }
+      ],
+      { transaction: true, label: staffTimeTagCommandIds.delete }
+    );
+    await emitCrudSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "deleted",
+      entity: tag,
+      identifiers: { id: tag.id, organizationId: tag.organizationId, tenantId: tag.tenantId },
+      indexer: tagCrudIndexer
+    });
+    return { tagId: tag.id, removedTaskAssignments, removedEntryAssignments };
+  },
+  buildLog: async ({ result, snapshots }) => {
+    const prepared = snapshots.before;
+    const before = prepared?.snapshot;
+    if (!before) return null;
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tags.delete", "Delete tag"),
+      resourceKind: "staff.timesheets.tag",
+      resourceId: before.id,
+      tenantId: before.tenantId,
+      organizationId: before.organizationId,
+      snapshotBefore: before,
+      changes: {
+        removedTaskAssignments: { from: result.removedTaskAssignments, to: 0 },
+        removedEntryAssignments: { from: result.removedEntryAssignments, to: 0 }
+      },
+      payload: {
+        undo: {
+          before,
+          taskAssignments: prepared?.taskAssignments ?? null,
+          entryAssignments: prepared?.entryAssignments ?? null,
+          assignmentsTruncated: prepared?.assignmentsTruncated ?? false
+        }
+      }
+    };
+  },
+  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 tag = await em.findOne(StaffTimeTag, scopedStaffSnapshotWhere(before.id, snapshotScope));
+    await withAtomicFlush(
+      em,
+      [
+        () => {
+          if (!tag) {
+            tag = em.create(StaffTimeTag, {
+              id: before.id,
+              tenantId: before.tenantId,
+              organizationId: before.organizationId,
+              slug: before.slug,
+              label: before.label,
+              color: before.color ?? null,
+              createdAt: /* @__PURE__ */ new Date(),
+              updatedAt: /* @__PURE__ */ new Date(),
+              deletedAt: null
+            });
+            em.persist(tag);
+            return;
+          }
+          tag.slug = before.slug;
+          tag.label = before.label;
+          tag.color = before.color ?? null;
+          tag.deletedAt = null;
+          tag.updatedAt = /* @__PURE__ */ new Date();
+        },
+        // Restoring assignments re-reads the junction rows, so it is its own phase.
+        () => taskJunctionOps.restoreAssignments(em, payload?.taskAssignments ?? []),
+        () => entryJunctionOps.restoreAssignments(em, payload?.entryAssignments ?? [])
+      ],
+      { transaction: true, label: `${staffTimeTagCommandIds.delete}.undo` }
+    );
+    await emitCrudUndoSideEffects({
+      dataEngine: ctx.container.resolve("dataEngine"),
+      action: "created",
+      entity: tag,
+      identifiers: { id: before.id, organizationId: before.organizationId, tenantId: before.tenantId },
+      indexer: tagCrudIndexer
+    });
+  }
+};
+async function requireTaskTarget(em, taskId, scope, translate) {
+  const task = await em.findOne(StaffTimeTask, applyScopeToWhere({ id: taskId, deletedAt: null }, scope));
+  if (!task) throw targetNotFoundError(translate, "task");
+  return { id: task.id, tenantId: task.tenantId, organizationId: task.organizationId };
+}
+async function requireEntryTarget(em, timeEntryId, scope, translate) {
+  const entry = await em.findOne(
+    StaffTimeEntry,
+    applyScopeToWhere({ id: timeEntryId, deletedAt: null }, scope)
+  );
+  if (!entry) throw targetNotFoundError(translate, "time_entry");
+  if (entry.lockedReportId) {
+    throw new CrudHttpError(409, {
+      code: TAG_TARGET_LOCKED_CODE,
+      error: translate(
+        "staff.time_tracking.tags.errors.entryLocked",
+        "This time entry is locked in a closed report and its tags cannot be changed."
+      ),
+      lockedReportId: entry.lockedReportId
+    });
+  }
+  return { id: entry.id, tenantId: entry.tenantId, organizationId: entry.organizationId };
+}
+function refreshTargetSideEffects(ops) {
+  return async (ctx, target) => {
+    const dataEngine = ctx.container.resolve("dataEngine");
+    await emitCrudSideEffects({
+      dataEngine,
+      action: "updated",
+      entity: target,
+      identifiers: { id: target.id, organizationId: target.organizationId, tenantId: target.tenantId },
+      indexer: ops.target === "task" ? taskCrudIndexer : timeEntryCrudIndexer
+    });
+  };
+}
+async function runAssignment(ops, requireTarget, parsed, ctx) {
+  ensureTenantScope(ctx, parsed.tenantId);
+  ensureOrganizationScope(ctx, parsed.organizationId);
+  const scope = commandInputScope(ctx, parsed.tenantId, parsed.organizationId);
+  const { translate } = await resolveTranslations();
+  const requestedTagIds = Array.from(new Set(parsed.tagIds));
+  let target = null;
+  let assignedTagIds = [];
+  let alreadyAssignedTagIds = [];
+  let tagIdsAfter = [];
+  const attempt = async () => {
+    const em = ctx.container.resolve("em").fork();
+    await withAtomicFlush(
+      em,
+      [
+        async () => {
+          target = await requireTarget(em, parsed.targetId, scope, translate);
+          await requireKnownTags(em, requestedTagIds, scope, translate);
+          const existing = await ops.loadAssignments(em, parsed.targetId, scope);
+          const existingTagIds = new Set(existing.map((row) => row.tagId));
+          alreadyAssignedTagIds = requestedTagIds.filter((tagId) => existingTagIds.has(tagId));
+          assignedTagIds = requestedTagIds.filter((tagId) => !existingTagIds.has(tagId));
+          tagIdsAfter = Array.from(/* @__PURE__ */ new Set([...existingTagIds, ...requestedTagIds]));
+        },
+        () => {
+          for (const tagId of assignedTagIds) {
+            ops.createAssignment(em, {
+              tenantId: parsed.tenantId,
+              organizationId: parsed.organizationId,
+              tagId,
+              targetId: parsed.targetId
+            });
+          }
+        }
+      ],
+      { transaction: true, label: `${ops.target}.tags.assign` }
+    );
+  };
+  try {
+    await attempt();
+  } catch (err) {
+    if (!isUniqueViolation(err)) throw err;
+    try {
+      await attempt();
+    } catch (retryErr) {
+      if (!isUniqueViolation(retryErr)) throw retryErr;
+      assignedTagIds = [];
+      alreadyAssignedTagIds = requestedTagIds;
+      tagIdsAfter = requestedTagIds;
+    }
+  }
+  const resolvedTarget = target;
+  if (!resolvedTarget) throw targetNotFoundError(translate, ops.target);
+  if (assignedTagIds.length > 0) {
+    await refreshTargetSideEffects(ops)(ctx, resolvedTarget);
+  }
+  return {
+    targetId: parsed.targetId,
+    assignedTagIds,
+    alreadyAssignedTagIds,
+    tagIds: tagIdsAfter
+  };
+}
+async function runUnassignment(ops, requireTarget, parsed, ctx) {
+  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();
+  const requestedTagIds = Array.from(new Set(parsed.tagIds));
+  let target = null;
+  let removedTagIds = [];
+  let notAssignedTagIds = [];
+  let tagIdsAfter = [];
+  await withAtomicFlush(
+    em,
+    [
+      async () => {
+        target = await requireTarget(em, parsed.targetId, scope, translate);
+        const existing = await ops.loadAssignments(em, parsed.targetId, scope);
+        const byTagId = new Map(existing.map((row) => [row.tagId, row]));
+        removedTagIds = requestedTagIds.filter((tagId) => byTagId.has(tagId));
+        notAssignedTagIds = requestedTagIds.filter((tagId) => !byTagId.has(tagId));
+        tagIdsAfter = existing.map((row) => row.tagId).filter((tagId) => !removedTagIds.includes(tagId));
+        const removableIds = removedTagIds.map((tagId) => byTagId.get(tagId)?.id).filter((value) => typeof value === "string");
+        if (removableIds.length > 0) await ops.deleteAssignments(em, removableIds, scope);
+      }
+    ],
+    { transaction: true, label: `${ops.target}.tags.unassign` }
+  );
+  const resolvedTarget = target;
+  if (!resolvedTarget) throw targetNotFoundError(translate, ops.target);
+  if (removedTagIds.length > 0) {
+    await refreshTargetSideEffects(ops)(ctx, resolvedTarget);
+  }
+  return {
+    targetId: parsed.targetId,
+    removedTagIds,
+    notAssignedTagIds,
+    tagIds: tagIdsAfter
+  };
+}
+async function restoreAssignmentState(ops, payload, ctx) {
+  const em = ctx.container.resolve("em").fork();
+  const scope = {
+    tenantId: payload.tenantId,
+    organizationId: payload.organizationId,
+    requireTenant: true,
+    requireOrganization: true
+  };
+  await withAtomicFlush(
+    em,
+    [
+      async () => {
+        if (payload.added.length > 0) {
+          const current = await ops.loadAssignments(em, payload.targetId, scope);
+          const removableIds = current.filter((row) => payload.added.includes(row.tagId)).map((row) => row.id);
+          if (removableIds.length > 0) await ops.deleteAssignments(em, removableIds, scope);
+        }
+      },
+      () => ops.restoreAssignments(em, payload.removed)
+    ],
+    { transaction: true, label: `${ops.target}.tags.undo` }
+  );
+}
+function assignmentLogPayload(ops, parsed, result) {
+  return {
+    target: ops.target,
+    targetId: parsed.targetId,
+    tenantId: parsed.tenantId,
+    organizationId: parsed.organizationId,
+    tagIdsBefore: result.tagIds.filter((tagId) => !result.assignedTagIds.includes(tagId)),
+    tagIdsAfter: result.tagIds,
+    added: result.assignedTagIds,
+    removed: []
+  };
+}
+function unassignmentLogPayload(ops, parsed, result, removedRows) {
+  return {
+    target: ops.target,
+    targetId: parsed.targetId,
+    tenantId: parsed.tenantId,
+    organizationId: parsed.organizationId,
+    tagIdsBefore: [...result.tagIds, ...result.removedTagIds],
+    tagIdsAfter: result.tagIds,
+    added: [],
+    removed: removedRows
+  };
+}
+function toTaskCommandInput(parsed) {
+  return {
+    tenantId: parsed.tenantId,
+    organizationId: parsed.organizationId,
+    targetId: parsed.taskId,
+    tagIds: parsed.tagIds
+  };
+}
+function toEntryCommandInput(parsed) {
+  return {
+    tenantId: parsed.tenantId,
+    organizationId: parsed.organizationId,
+    targetId: parsed.timeEntryId,
+    tagIds: parsed.tagIds
+  };
+}
+const assignTaskTagsCommand = {
+  id: staffTimeTagCommandIds.assignTask,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeTaskTagAssignmentSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const rows = await taskJunctionOps.loadAssignmentsForSnapshot(
+      em,
+      parsed.data.taskId,
+      staffSnapshotScopeFromContext(ctx)
+    );
+    return { before: { tagIds: rows.map((row) => row.tagId) } };
+  },
+  execute: async (rawInput, ctx) => {
+    const parsed = staffTimeTaskTagAssignmentSchema.parse(rawInput);
+    return runAssignment(taskJunctionOps, requireTaskTarget, toTaskCommandInput(parsed), ctx);
+  },
+  buildLog: async ({ input, result, snapshots }) => {
+    const parsed = staffTimeTaskTagAssignmentSchema.parse(input);
+    const commandInput = toTaskCommandInput(parsed);
+    const before = snapshots.before?.tagIds ?? [];
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tags.assign_task", "Assign task tags"),
+      resourceKind: taskJunctionOps.resourceKind,
+      resourceId: commandInput.targetId,
+      tenantId: commandInput.tenantId,
+      organizationId: commandInput.organizationId,
+      snapshotBefore: { tagIds: before },
+      snapshotAfter: { tagIds: result.tagIds },
+      changes: { tagIds: { from: before, to: result.tagIds } },
+      payload: {
+        undo: assignmentLogPayload(taskJunctionOps, commandInput, result)
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    if (!payload) return;
+    await restoreAssignmentState(taskJunctionOps, payload, ctx);
+  }
+};
+const unassignTaskTagsCommand = {
+  id: staffTimeTagCommandIds.unassignTask,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeTaskTagAssignmentSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const rows = await taskJunctionOps.loadAssignmentsForSnapshot(
+      em,
+      parsed.data.taskId,
+      staffSnapshotScopeFromContext(ctx)
+    );
+    return { before: { rows } };
+  },
+  execute: async (rawInput, ctx) => {
+    const parsed = staffTimeTaskTagAssignmentSchema.parse(rawInput);
+    return runUnassignment(taskJunctionOps, requireTaskTarget, toTaskCommandInput(parsed), ctx);
+  },
+  buildLog: async ({ input, result, snapshots }) => {
+    const parsed = staffTimeTaskTagAssignmentSchema.parse(input);
+    const commandInput = toTaskCommandInput(parsed);
+    const rows = snapshots.before?.rows ?? [];
+    const removedRows = rows.filter((row) => result.removedTagIds.includes(row.tagId));
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tags.unassign_task", "Unassign task tags"),
+      resourceKind: taskJunctionOps.resourceKind,
+      resourceId: commandInput.targetId,
+      tenantId: commandInput.tenantId,
+      organizationId: commandInput.organizationId,
+      snapshotBefore: { tagIds: rows.map((row) => row.tagId) },
+      snapshotAfter: { tagIds: result.tagIds },
+      changes: { tagIds: { from: rows.map((row) => row.tagId), to: result.tagIds } },
+      payload: {
+        undo: unassignmentLogPayload(taskJunctionOps, commandInput, result, removedRows)
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    if (!payload) return;
+    await restoreAssignmentState(taskJunctionOps, payload, ctx);
+  }
+};
+const assignEntryTagsCommand = {
+  id: staffTimeTagCommandIds.assignEntry,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeEntryTagAssignmentSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const rows = await entryJunctionOps.loadAssignmentsForSnapshot(
+      em,
+      parsed.data.timeEntryId,
+      staffSnapshotScopeFromContext(ctx)
+    );
+    return { before: { tagIds: rows.map((row) => row.tagId) } };
+  },
+  execute: async (rawInput, ctx) => {
+    const parsed = staffTimeEntryTagAssignmentSchema.parse(rawInput);
+    return runAssignment(entryJunctionOps, requireEntryTarget, toEntryCommandInput(parsed), ctx);
+  },
+  buildLog: async ({ input, result, snapshots }) => {
+    const parsed = staffTimeEntryTagAssignmentSchema.parse(input);
+    const commandInput = toEntryCommandInput(parsed);
+    const before = snapshots.before?.tagIds ?? [];
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tags.assign_entry", "Assign time entry tags"),
+      resourceKind: entryJunctionOps.resourceKind,
+      resourceId: commandInput.targetId,
+      tenantId: commandInput.tenantId,
+      organizationId: commandInput.organizationId,
+      snapshotBefore: { tagIds: before },
+      snapshotAfter: { tagIds: result.tagIds },
+      changes: { tagIds: { from: before, to: result.tagIds } },
+      payload: {
+        undo: assignmentLogPayload(entryJunctionOps, commandInput, result)
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    if (!payload) return;
+    await restoreAssignmentState(entryJunctionOps, payload, ctx);
+  }
+};
+const unassignEntryTagsCommand = {
+  id: staffTimeTagCommandIds.unassignEntry,
+  async prepare(rawInput, ctx) {
+    const parsed = staffTimeEntryTagAssignmentSchema.safeParse(rawInput);
+    if (!parsed.success) return {};
+    const em = ctx.container.resolve("em");
+    const rows = await entryJunctionOps.loadAssignmentsForSnapshot(
+      em,
+      parsed.data.timeEntryId,
+      staffSnapshotScopeFromContext(ctx)
+    );
+    return { before: { rows } };
+  },
+  execute: async (rawInput, ctx) => {
+    const parsed = staffTimeEntryTagAssignmentSchema.parse(rawInput);
+    return runUnassignment(entryJunctionOps, requireEntryTarget, toEntryCommandInput(parsed), ctx);
+  },
+  buildLog: async ({ input, result, snapshots }) => {
+    const parsed = staffTimeEntryTagAssignmentSchema.parse(input);
+    const commandInput = toEntryCommandInput(parsed);
+    const rows = snapshots.before?.rows ?? [];
+    const removedRows = rows.filter((row) => result.removedTagIds.includes(row.tagId));
+    const { translate } = await resolveTranslations();
+    return {
+      actionLabel: translate("staff.audit.timesheets.tags.unassign_entry", "Unassign time entry tags"),
+      resourceKind: entryJunctionOps.resourceKind,
+      resourceId: commandInput.targetId,
+      tenantId: commandInput.tenantId,
+      organizationId: commandInput.organizationId,
+      snapshotBefore: { tagIds: rows.map((row) => row.tagId) },
+      snapshotAfter: { tagIds: result.tagIds },
+      changes: { tagIds: { from: rows.map((row) => row.tagId), to: result.tagIds } },
+      payload: {
+        undo: unassignmentLogPayload(entryJunctionOps, commandInput, result, removedRows)
+      }
+    };
+  },
+  undo: async ({ logEntry, ctx }) => {
+    const payload = extractUndoPayload(logEntry);
+    if (!payload) return;
+    await restoreAssignmentState(entryJunctionOps, payload, ctx);
+  }
+};
+registerCommand(createTagCommand);
+registerCommand(updateTagCommand);
+registerCommand(deleteTagCommand);
+registerCommand(assignTaskTagsCommand);
+registerCommand(unassignTaskTagsCommand);
+registerCommand(assignEntryTagsCommand);
+registerCommand(unassignEntryTagsCommand);
+export {
+  TAG_ASSIGNMENT_SNAPSHOT_LIMIT,
+  TAG_SLUG_DUPLICATE_CODE,
+  TAG_TARGET_LOCKED_CODE,
+  TAG_UNKNOWN_IDS_CODE,
+  staffTimeTagCommandIds,
+  staffTimeTagUpdateSchema
+};
+//# sourceMappingURL=timesheets-tags.js.map