@things-factory/worklist 10.1.248 → 10.1.249

package/dist-server/controllers/activity-approval/approval-line.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TERMINATED_JUDGMENTS = exports.FIRST_ORDER = void 0;
+exports.isApprovalStep = isApprovalStep;
+exports.isReferenceStep = isReferenceStep;
+exports.lineItemFor = lineItemFor;
+exports.firstApprovalOrder = firstApprovalOrder;
+exports.referenceSteps = referenceSteps;
+exports.referencesToNotify = referencesToNotify;
+exports.nextApproval = nextApproval;
+exports.isLastApproval = isLastApproval;
+exports.needsApproval = needsApproval;
+exports.isApproved = isApproved;
+exports.isTerminated = isTerminated;
+exports.isReferenceOrder = isReferenceOrder;
+/**
+ * 결재선에서 다음 결재자를 찾는다.
+ *
+ * ── 왜 따로 뺐나 ───────────────────────────────────────────────────────────
+ * 같은 규칙이 두 파일에 나뉘어 있었다.
+ *
+ *   submit.ts    첫 결재를 `order: 1` 로 만들고 `approvalLine[0]` 을 넣는다
+ *   approve.ts   `order` 를 승인하면 `approvalLine[order]` 를 다음 결재자로 삼는다
+ *
+ * `order` 와 배열 자리가 1만큼 다르다. 지금은 맞게 짝이 맞는데, 한쪽만 고치면 결재자가 한 명 빠지거나
+ * 같은 사람이 두 번 들어간다. 그리고 **오류가 안 난다** — 결재가 다 끝나고 나서야 안다.
+ *
+ * 그래서 한 자리에 적고 양쪽이 이것을 부른다.
+ *
+ * `order` 는 사람이 세는 수다 — 1차 결재, 2차 결재. 배열은 0부터이므로 그 차이를 여기서만 다룬다.
+ */
+/**
+ * 이 항목이 **결재**인가 — 비어 있으면 결재다.
+ *
+ * 지금 도는 결재선에는 이 칸이 없다(gangsters·dataset·quotation·accounting). 그 항목들이 전부 결재자로
+ * 읽혀야 거동이 안 바뀐다. 그래서 「참조라고 적힌 것만 참조」다.
+ */
+function isApprovalStep(item) {
+    return !!item && item.participation !== 'reference';
+}
+/** 이 항목이 참조인가 — 의견만 내고 결재를 막지 않는다. */
+function isReferenceStep(item) {
+    return !!item && item.participation === 'reference';
+}
+/**
+ * 이 차례의 결재자는 결재선의 어느 줄인가. `order` 는 1부터.
+ *
+ * **참조 항목도 자리를 차지한다.** `order` 는 배열 자리 그대로다 — 다시 매기면 이미 쌓인 행의 뜻이
+ * 바뀐다. 그래서 결재자의 차례가 1·3·4 처럼 띄엄띄엄해질 수 있고, 그것이 맞다.
+ *
+ * 이 함수는 그 자리에 무엇이 있든 돌려준다. 결재인지 아닌지는 부르는 쪽이 본다(§`nextApproval`).
+ */
+function lineItemFor(approvalLine, order) {
+    if (!approvalLine?.length || order < 1) {
+        return undefined;
+    }
+    return approvalLine[order - 1];
+}
+/**
+ * 첫 **결재자**는 몇 번째 자리인가 — 앞에 참조가 있으면 건너뛴다.
+ *
+ * 결재선이 참조로만 이루어져 있으면 `undefined` 다. 그때는 결재 없이 끝난다(§`needsApproval`).
+ */
+function firstApprovalOrder(approvalLine) {
+    if (!approvalLine?.length)
+        return undefined;
+    const index = approvalLine.findIndex(isApprovalStep);
+    return index < 0 ? undefined : index + 1;
+}
+/**
+ * 이 결재선의 참조들 — **언제 알릴지와 함께.**
+ *
+ * `notifyAfter` 가 없으면 `0` 으로 답한다. 0 은 「상신 즉시」다 — 아직 아무 결재도 끝나지 않은 시점.
+ */
+function referenceSteps(approvalLine) {
+    if (!approvalLine?.length)
+        return [];
+    return approvalLine
+        .map((item, index) => ({ item, order: index + 1, notifyAfter: Number(item.notifyAfter ?? 0) || 0 }))
+        .filter(x => isReferenceStep(x.item));
+}
+/** 이번에 알려야 할 참조들 — `afterOrder` 번째 결재가 막 끝났을 때. 상신 직후는 `0`. */
+function referencesToNotify(approvalLine, afterOrder) {
+    return referenceSteps(approvalLine)
+        .filter(x => x.notifyAfter === afterOrder)
+        .map(({ item, order }) => ({ item, order }));
+}
+/** 첫 결재의 차례. */
+exports.FIRST_ORDER = 1;
+/**
+ * 이 차례를 승인하면 다음 결재자가 있나. 없으면 이것이 마지막이다.
+ *
+ * **참조는 건너뛴다.** 참조자가 아직 안 읽었어도 결재는 다음 결재자로 넘어간다 — 막게 만들면 그 사람이
+ * 휴가일 때 결재가 선다. 막아야 하는 자격은 합의이고, 그것은 아직 없다.
+ */
+function nextApproval(approvalLine, order) {
+    if (!approvalLine?.length)
+        return undefined;
+    for (let next = order + 1; next <= approvalLine.length; next++) {
+        const item = lineItemFor(approvalLine, next);
+        if (isApprovalStep(item))
+            return { item: item, order: next };
+    }
+    return undefined;
+}
+/** 이 차례가 마지막인가. */
+function isLastApproval(approvalLine, order) {
+    return !nextApproval(approvalLine, order);
+}
+/**
+ * 결재가 필요한가 — **결재자가 하나라도 있어야 한다.**
+ *
+ * 비어 있으면 결재 없이 끝난다. 그리고 **참조만 있는 결재선도 결재 없이 끝난다** — 참조는 막지 않으므로
+ * 기다릴 것이 없다. 참조가 있다고 결재를 기다리게 하면, 그 사람이 승인 권한도 없이 결재를 세운다.
+ */
+function needsApproval(approvalLine) {
+    return firstApprovalOrder(approvalLine) !== undefined;
+}
+/**
+ * 이 판정이 「승인했다」인가.
+ *
+ * ── 옛 표기를 여기서 흡수한다 ──────────────────────────────────────────────
+ * 2026-08-31 전에는 다음 결재자가 있으면 승인을 `escalated` 로 적었다. **그 행은 고치지 않는다** —
+ * 승인 기록을 뒤에서 고쳐 쓰는 것은 규제 산업이 금지하는 바로 그 행위다.
+ *
+ * 대신 읽는 자리 하나에서 옛 표기를 새 뜻으로 읽는다. 이 규율이 두 곳으로 늘어나면 한쪽만 고쳐지는
+ * 날이 온다. 「승인했나」를 묻는 코드는 전부 이것을 부른다.
+ */
+function isApproved(judgment) {
+    return judgment === 'approved' || judgment === 'escalated';
+}
+/**
+ * 더 기다릴 것이 없는 판정들 — **목록 질의와 이 파일이 같은 값을 본다.**
+ *
+ * 목록 질의가 이 배열을 그대로 쓴다. 두 벌로 두면 값이 늘 때 한쪽만 늘고, 그 판정을 받은 행이 대기
+ * 목록에 영원히 남는다 — 실제로 그렇게 됐다(아래).
+ */
+exports.TERMINATED_JUDGMENTS = ['approved', 'escalated', 'delegated', 'rejected', 'aborted', 'closed'];
+/**
+ * 이 판정이 끝난 것인가 — 더 기다릴 것이 없나.
+ *
+ * ── `aborted` 가 빠져 있었다 (2026-09-01) ─────────────────────────────────
+ * 스레드를 중단하면 그 스레드의 대기 결재가 `aborted` 로 닫힌다(§`activity-thread/_abort.ts`).
+ * 그런데 **목록 질의도 이 함수도 그 값을 「끝난 것」으로 세지 않았다.**
+ *
+ * 그래서 중단된 건의 결재가 그 사람의 **승인 대기 목록에 영원히 남았다.** 눌러 봐야 이미 끝난 건이고,
+ * 목록에서 사라지지도 않는다. 닫는 쪽은 제대로 닫았는데 읽는 쪽이 그것을 못 읽었다.
+ */
+function isTerminated(judgment) {
+    return exports.TERMINATED_JUDGMENTS.includes(judgment ?? '');
+}
+/**
+ * Is the seat at this turn declared as a **reference** — someone who comments but does not decide?
+ *
+ * ── Why this is a function and not two inline calls ────────────────────────
+ * ApprovalParticipation has said from the start that a reference only comments and does not affect
+ * the judgment. create-approval, the escalation in approve(), and both list queries honour that.
+ * The two places where a person presses a button did not: approve() and reject() never asked whether
+ * the row they are about to stamp is an approver's row.
+ *
+ * A reference row is created with judgment Pending, so it passes every check those two functions do
+ * make. Approving one stamps it as a real approval and then nextApproval() picks the approver that
+ * sits *after* that seat, which moves the approval a step forward. With no approver after it, one
+ * reference ends the whole thread. Rejecting is worse: an activity with rejectionIsFinal cannot be
+ * restarted, so the case closes for good.
+ *
+ * Writing the check inline in both callers would put the rule back in two places, which is the
+ * reason this file exists.
+ *
+ * ── The approval line is the authority, not the row ───────────────────────
+ * The capacity is also copied onto ActivityApproval.participation. approve() already lets the
+ * approval line decide who comes next (nextApproval(approvalLine, order)); letting the row decide
+ * who may judge would put two authorities in one function, with nothing to settle a disagreement.
+ * The line is loaded either way, so this costs no extra read. (2026-09-09, architect's ruling)
+ *
+ * ── False when the seat is not in the line ────────────────────────────────
+ * That answers "not declared a reference", which is not the same as "is an approver". One boolean
+ * cannot carry both facts, so this function reports only what is written down and the caller
+ * refuses on a definite yes. A missing seat means the line grew shorter after submission; telling
+ * that person they are a reference would state something the data does not say. Whether the line
+ * can be edited after submission is being measured separately.
+ */
+function isReferenceOrder(approvalLine, order) {
+    return isReferenceStep(lineItemFor(approvalLine, order));
+}
+//# sourceMappingURL=approval-line.js.map

package/dist-server/controllers/activity-approval/approval-line.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-line.js","sourceRoot":"","sources":["../../../server/controllers/activity-approval/approval-line.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * **타입만 가져온다.** 값으로 가져오면 `@things-factory/organization` 이 실려 오고, 그것이 auth-base 의\n * 라우터까지 끌고 온다. 순수 규칙 하나를 시험하려는데 서버가 통째로 뜬다.\n */\nimport type { ApprovalLineItem } from '@things-factory/organization'\n\n/**\n * 결재선에서 다음 결재자를 찾는다.\n *\n * ── 왜 따로 뺐나 ───────────────────────────────────────────────────────────\n * 같은 규칙이 두 파일에 나뉘어 있었다.\n *\n *   submit.ts    첫 결재를 `order: 1` 로 만들고 `approvalLine[0]` 을 넣는다\n *   approve.ts   `order` 를 승인하면 `approvalLine[order]` 를 다음 결재자로 삼는다\n *\n * `order` 와 배열 자리가 1만큼 다르다. 지금은 맞게 짝이 맞는데, 한쪽만 고치면 결재자가 한 명 빠지거나\n * 같은 사람이 두 번 들어간다. 그리고 **오류가 안 난다** — 결재가 다 끝나고 나서야 안다.\n *\n * 그래서 한 자리에 적고 양쪽이 이것을 부른다.\n *\n * `order` 는 사람이 세는 수다 — 1차 결재, 2차 결재. 배열은 0부터이므로 그 차이를 여기서만 다룬다.\n */\n\n/**\n * 이 항목이 **결재**인가 — 비어 있으면 결재다.\n *\n * 지금 도는 결재선에는 이 칸이 없다(gangsters·dataset·quotation·accounting). 그 항목들이 전부 결재자로\n * 읽혀야 거동이 안 바뀐다. 그래서 「참조라고 적힌 것만 참조」다.\n */\nexport function isApprovalStep(item: ApprovalLineItem | undefined): boolean {\n  return !!item && (item as any).participation !== 'reference'\n}\n\n/** 이 항목이 참조인가 — 의견만 내고 결재를 막지 않는다. */\nexport function isReferenceStep(item: ApprovalLineItem | undefined): boolean {\n  return !!item && (item as any).participation === 'reference'\n}\n\n/**\n * 이 차례의 결재자는 결재선의 어느 줄인가. `order` 는 1부터.\n *\n * **참조 항목도 자리를 차지한다.** `order` 는 배열 자리 그대로다 — 다시 매기면 이미 쌓인 행의 뜻이\n * 바뀐다. 그래서 결재자의 차례가 1·3·4 처럼 띄엄띄엄해질 수 있고, 그것이 맞다.\n *\n * 이 함수는 그 자리에 무엇이 있든 돌려준다. 결재인지 아닌지는 부르는 쪽이 본다(§`nextApproval`).\n */\nexport function lineItemFor(approvalLine: ApprovalLineItem[] | undefined, order: number): ApprovalLineItem | undefined {\n  if (!approvalLine?.length || order < 1) {\n    return undefined\n  }\n\n  return approvalLine[order - 1]\n}\n\n/**\n * 첫 **결재자**는 몇 번째 자리인가 — 앞에 참조가 있으면 건너뛴다.\n *\n * 결재선이 참조로만 이루어져 있으면 `undefined` 다. 그때는 결재 없이 끝난다(§`needsApproval`).\n */\nexport function firstApprovalOrder(approvalLine: ApprovalLineItem[] | undefined): number | undefined {\n  if (!approvalLine?.length) return undefined\n\n  const index = approvalLine.findIndex(isApprovalStep)\n  return index < 0 ? undefined : index + 1\n}\n\n/**\n * 이 결재선의 참조들 — **언제 알릴지와 함께.**\n *\n * `notifyAfter` 가 없으면 `0` 으로 답한다. 0 은 「상신 즉시」다 — 아직 아무 결재도 끝나지 않은 시점.\n */\nexport function referenceSteps(\n  approvalLine: ApprovalLineItem[] | undefined\n): { item: ApprovalLineItem; order: number; notifyAfter: number }[] {\n  if (!approvalLine?.length) return []\n\n  return approvalLine\n    .map((item, index) => ({ item, order: index + 1, notifyAfter: Number((item as any).notifyAfter ?? 0) || 0 }))\n    .filter(x => isReferenceStep(x.item))\n}\n\n/** 이번에 알려야 할 참조들 — `afterOrder` 번째 결재가 막 끝났을 때. 상신 직후는 `0`. */\nexport function referencesToNotify(\n  approvalLine: ApprovalLineItem[] | undefined,\n  afterOrder: number\n): { item: ApprovalLineItem; order: number }[] {\n  return referenceSteps(approvalLine)\n    .filter(x => x.notifyAfter === afterOrder)\n    .map(({ item, order }) => ({ item, order }))\n}\n\n/** 첫 결재의 차례. */\nexport const FIRST_ORDER = 1\n\n/**\n * 이 차례를 승인하면 다음 결재자가 있나. 없으면 이것이 마지막이다.\n *\n * **참조는 건너뛴다.** 참조자가 아직 안 읽었어도 결재는 다음 결재자로 넘어간다 — 막게 만들면 그 사람이\n * 휴가일 때 결재가 선다. 막아야 하는 자격은 합의이고, 그것은 아직 없다.\n */\nexport function nextApproval(\n  approvalLine: ApprovalLineItem[] | undefined,\n  order: number\n): { item: ApprovalLineItem; order: number } | undefined {\n  if (!approvalLine?.length) return undefined\n\n  for (let next = order + 1; next <= approvalLine.length; next++) {\n    const item = lineItemFor(approvalLine, next)\n    if (isApprovalStep(item)) return { item: item!, order: next }\n  }\n\n  return undefined\n}\n\n/** 이 차례가 마지막인가. */\nexport function isLastApproval(approvalLine: ApprovalLineItem[] | undefined, order: number): boolean {\n  return !nextApproval(approvalLine, order)\n}\n\n/**\n * 결재가 필요한가 — **결재자가 하나라도 있어야 한다.**\n *\n * 비어 있으면 결재 없이 끝난다. 그리고 **참조만 있는 결재선도 결재 없이 끝난다** — 참조는 막지 않으므로\n * 기다릴 것이 없다. 참조가 있다고 결재를 기다리게 하면, 그 사람이 승인 권한도 없이 결재를 세운다.\n */\nexport function needsApproval(approvalLine: ApprovalLineItem[] | undefined): boolean {\n  return firstApprovalOrder(approvalLine) !== undefined\n}\n\n/**\n * 이 판정이 「승인했다」인가.\n *\n * ── 옛 표기를 여기서 흡수한다 ──────────────────────────────────────────────\n * 2026-08-31 전에는 다음 결재자가 있으면 승인을 `escalated` 로 적었다. **그 행은 고치지 않는다** —\n * 승인 기록을 뒤에서 고쳐 쓰는 것은 규제 산업이 금지하는 바로 그 행위다.\n *\n * 대신 읽는 자리 하나에서 옛 표기를 새 뜻으로 읽는다. 이 규율이 두 곳으로 늘어나면 한쪽만 고쳐지는\n * 날이 온다. 「승인했나」를 묻는 코드는 전부 이것을 부른다.\n */\nexport function isApproved(judgment: string | undefined): boolean {\n  return judgment === 'approved' || judgment === 'escalated'\n}\n\n/**\n * 더 기다릴 것이 없는 판정들 — **목록 질의와 이 파일이 같은 값을 본다.**\n *\n * 목록 질의가 이 배열을 그대로 쓴다. 두 벌로 두면 값이 늘 때 한쪽만 늘고, 그 판정을 받은 행이 대기\n * 목록에 영원히 남는다 — 실제로 그렇게 됐다(아래).\n */\nexport const TERMINATED_JUDGMENTS = ['approved', 'escalated', 'delegated', 'rejected', 'aborted', 'closed'] as const\n\n/**\n * 이 판정이 끝난 것인가 — 더 기다릴 것이 없나.\n *\n * ── `aborted` 가 빠져 있었다 (2026-09-01) ─────────────────────────────────\n * 스레드를 중단하면 그 스레드의 대기 결재가 `aborted` 로 닫힌다(§`activity-thread/_abort.ts`).\n * 그런데 **목록 질의도 이 함수도 그 값을 「끝난 것」으로 세지 않았다.**\n *\n * 그래서 중단된 건의 결재가 그 사람의 **승인 대기 목록에 영원히 남았다.** 눌러 봐야 이미 끝난 건이고,\n * 목록에서 사라지지도 않는다. 닫는 쪽은 제대로 닫았는데 읽는 쪽이 그것을 못 읽었다.\n */\nexport function isTerminated(judgment: string | undefined): boolean {\n  return (TERMINATED_JUDGMENTS as readonly string[]).includes(judgment ?? '')\n}\n\n/**\n * Is the seat at this turn declared as a **reference** — someone who comments but does not decide?\n *\n * ── Why this is a function and not two inline calls ────────────────────────\n * ApprovalParticipation has said from the start that a reference only comments and does not affect\n * the judgment. create-approval, the escalation in approve(), and both list queries honour that.\n * The two places where a person presses a button did not: approve() and reject() never asked whether\n * the row they are about to stamp is an approver's row.\n *\n * A reference row is created with judgment Pending, so it passes every check those two functions do\n * make. Approving one stamps it as a real approval and then nextApproval() picks the approver that\n * sits *after* that seat, which moves the approval a step forward. With no approver after it, one\n * reference ends the whole thread. Rejecting is worse: an activity with rejectionIsFinal cannot be\n * restarted, so the case closes for good.\n *\n * Writing the check inline in both callers would put the rule back in two places, which is the\n * reason this file exists.\n *\n * ── The approval line is the authority, not the row ───────────────────────\n * The capacity is also copied onto ActivityApproval.participation. approve() already lets the\n * approval line decide who comes next (nextApproval(approvalLine, order)); letting the row decide\n * who may judge would put two authorities in one function, with nothing to settle a disagreement.\n * The line is loaded either way, so this costs no extra read. (2026-09-09, architect's ruling)\n *\n * ── False when the seat is not in the line ────────────────────────────────\n * That answers \"not declared a reference\", which is not the same as \"is an approver\". One boolean\n * cannot carry both facts, so this function reports only what is written down and the caller\n * refuses on a definite yes. A missing seat means the line grew shorter after submission; telling\n * that person they are a reference would state something the data does not say. Whether the line\n * can be edited after submission is being measured separately.\n */\nexport function isReferenceOrder(approvalLine: ApprovalLineItem[] | undefined, order: number): boolean {\n  return isReferenceStep(lineItemFor(approvalLine, order))\n}\n"]}

package/dist-server/controllers/activity-approval/approve.d.ts

@@ -0,0 +1,5 @@
+import { ActivityApproval } from '../../service/activity-approval/activity-approval.js';
+export declare function approve({ id, comment }: {
+    id: string;
+    comment: string;
+}, context: ResolverContext): Promise<ActivityApproval>;

package/dist-server/controllers/activity-approval/approve.js

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.approve = approve;
+const opinion_js_1 = require("./opinion.js");
+const activity_thread_js_1 = require("../../service/activity-thread/activity-thread.js");
+const activity_approval_js_1 = require("../../service/activity-approval/activity-approval.js");
+const common_js_1 = require("../common.js");
+const check_authority_js_1 = require("./check-authority.js");
+const approval_line_js_1 = require("./approval-line.js");
+const create_approval_js_1 = require("./create-approval.js");
+const claim_js_1 = require("./claim.js");
+const approval_notice_js_1 = require("../../service/approval-notice/approval-notice.js");
+async function approve({ id, comment }, context) {
+    const { domain, user, tx } = context.state;
+    var repository = tx.getRepository(activity_approval_js_1.ActivityApproval);
+    var activityApproval = await repository.findOne({
+        where: { domain: { id: domain.id }, id }
+    });
+    if (!activityApproval) {
+        throw new Error(context.t('error.activity-approval not found', {
+            activityApproval: id
+        }));
+    }
+    await (0, check_authority_js_1.checkAuthority)(activityApproval, context);
+    /*
+      Prerequisite of Approval
+      - Previous judgment should be 'pending'
+    */
+    if (activityApproval.judgment !== activity_approval_js_1.ActivityApprovalJudgment.Pending) {
+        throw new Error(context.t(`error.activity-approval is already terminated`, {
+            activityApproval: id,
+            actual: activityApproval.judgment
+        }));
+    }
+    var activityThread = await tx.getRepository(activity_thread_js_1.ActivityThread).findOne({
+        where: { domain: { id: domain.id }, id: activityApproval.activityThreadId },
+        relations: ['activityInstance']
+    });
+    /*
+     * 여기까지 오면 스레드가 있어야 한다. 없는 채로 아래를 읽으면 `TypeError` 가 나고, 그 오류로는
+     * 무엇이 없는지 알 수 없다.
+     */
+    if (!activityThread) {
+        throw new Error(context.t('error.activity-thread not found', { activityThread: activityApproval.activityThreadId }));
+    }
+    if (!activityThread.activityInstance) {
+        throw new Error(context.t('error.activity-instance not found', { activityThread: activityThread.id }));
+    }
+    const approvalLine = activityThread.activityInstance.approvalLine;
+    const order = activityApproval.order;
+    /*
+     * A reference does not judge.
+     *
+     * The three checks above all pass for a reference row: it exists, checkAuthority says it belongs
+     * to this user, and its judgment is still Pending. Without this refusal the approval is recorded
+     * as real and nextApproval() then picks the approver sitting after that seat, moving the approval
+     * a step forward; with no approver after it, one reference ends the thread.
+     *
+     * This stands before claimPendingApproval, the first write. Throwing after the claim would leave
+     * the row already stamped with a judgment.
+     *
+     * The message says what this person can do instead of reporting a missing permission. A reference
+     * seat is a different seat, not a blocked one — comments are theirs to leave.
+     */
+    if ((0, approval_line_js_1.isReferenceOrder)(approvalLine, order)) {
+        throw new Error(context.t('error.activity-approval is reference only'));
+    }
+    /* 다음 결재자가 누구인지는 한 자리가 정한다 — `approval-line.ts`. */
+    const next = (0, approval_line_js_1.nextApproval)(approvalLine, order);
+    /*
+     * **여기서 잡는다.** 위의 검사는 읽은 시점의 것이라 그 사이에 남이 처리할 수 있다. 잡기가 첫 쓰기여야
+     * 진 쪽이 다음 결재자를 만들기 전에 물러난다.
+     */
+    if (!(await (0, claim_js_1.claimPendingApproval)(tx, activityApproval, activity_approval_js_1.ActivityApprovalJudgment.Approved))) {
+        /* 「이미 끝났다」보다 **그 사람이 할 일**을 말한다 — 목록을 새로 읽으면 지금 상태가 보인다. */
+        throw new Error(context.t('error.activity-approval taken by someone else', { activityApproval: id }));
+    }
+    /*
+     * **승인한 사람은 승인한 것이다** (2026-08-31, 아키텍트 확인).
+     *
+     * 앞서는 다음 결재자가 있으면 `Escalated` 로 적었다. 그러면 「누가 승인했나」를 물을 때 중간 결재자가
+     * 전부 「상신함」으로 나오고, **승인한 것과 그냥 넘긴 것이 구별되지 않는다.** 규제 산업에서는 결재
+     * 이력이 곧 근거라 이것이 결함이다.
+     *
+     * 다음으로 넘어간 사실은 `transaction` 이 그대로 들고 있으므로 잃는 것이 없다.
+     */
+    const result = await tx.getRepository(activity_approval_js_1.ActivityApproval).save({
+        ...activityApproval,
+        judgment: activity_approval_js_1.ActivityApprovalJudgment.Approved,
+        ...(0, opinion_js_1.stampedComment)(comment),
+        transaction: next ? 'escalate' : 'approve',
+        /*
+         * **누가 처리했는지 남긴다.**
+         *
+         * 역할로 걸린 결재는 `approver` 가 비어 있고 `approverRole` 만 있다. 처리해도 그 자리가 비어 있으면
+         * 두 가지가 함께 무너진다 — 그 역할을 가진 사람들의 **대기 목록에 영원히 남고**(`approver IS NULL`
+         * 로 걸리므로), 정작 처리한 사람의 **완료 목록에는 안 나온다**(`approver = 나` 로 거르므로).
+         *
+         * 그리고 결재 이력에서 「누가 승인했나」는 역할이 아니라 사람이어야 한다.
+         */
+        approver: activityApproval.approver ?? user,
+        updater: user,
+        terminatedAt: new Date(),
+        terminator: user
+    });
+    /*
+     * **이번 결재가 끝나서 알릴 참조들.** `notifyAfter` 가 이 차례를 가리키는 참조가 여기 온다.
+     *
+     * 다음 결재자를 세우는 것과 **무관하게** 만든다 — 참조는 막지 않으므로, 이것이 실패해도 결재는 간다.
+     */
+    const refs = await (0, create_approval_js_1.createReferences)({ references: (0, approval_line_js_1.referencesToNotify)(approvalLine, order), activityThread }, context);
+    for (const f of refs.failed) {
+        console.warn(`[worklist] 참조자를 세우지 못했다 (결재선 ${f.order}번째) — ${f.reason}`);
+    }
+    if (next) {
+        /* 다음 결재자에게 넘긴다 — 행을 만드는 자리는 한 곳이다(§`create-approval.ts`). */
+        await (0, create_approval_js_1.createApproval)({ item: next.item, order: next.order, participation: 'approval', activityThread, transaction: 'escalate' }, context);
+        activityThread = await tx.getRepository(activity_thread_js_1.ActivityThread).save({
+            ...activityThread,
+            transaction: 'escalate',
+            reason: comment,
+            state: activity_thread_js_1.ActivityThreadStatus.Escalated,
+            updater: user
+        });
+    }
+    else {
+        activityThread = await tx.getRepository(activity_thread_js_1.ActivityThread).save({
+            ...activityThread,
+            transaction: 'approve',
+            reason: comment,
+            state: activity_thread_js_1.ActivityThreadStatus.Ended,
+            terminatedAt: new Date(),
+            terminator: user,
+            updater: user
+        });
+        /* The last approval ended it - the requester is told (ADR-0164). The next approver's turn is told where its row is made. */
+        await (0, approval_notice_js_1.noticeApproval)(context, { kind: 'approved', approvalId: result.id });
+    }
+    await (0, common_js_1.updateActivityInstanceState)(activityThread.activityInstanceId, { causedBy: [activityThread] }, context);
+    return result;
+}
+//# sourceMappingURL=approve.js.map

package/dist-server/controllers/activity-approval/approve.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approve.js","sourceRoot":"","sources":["../../../server/controllers/activity-approval/approve.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApprovalLineItem } from '@things-factory/organization'\nimport { stampedComment } from './opinion.js'\nimport { ActivityThread, ActivityThreadStatus } from '../../service/activity-thread/activity-thread.js'\nimport { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval.js'\nimport { updateActivityInstanceState } from '../common.js'\nimport { checkAuthority } from './check-authority.js'\nimport { isReferenceOrder, nextApproval, referencesToNotify } from './approval-line.js'\nimport { createApproval, createReferences } from './create-approval.js'\nimport { claimPendingApproval } from './claim.js'\nimport { noticeApproval } from '../../service/approval-notice/approval-notice.js'\n\nexport async function approve(\n  { id, comment }: { id: string; comment: string },\n  context: ResolverContext\n): Promise<ActivityApproval> {\n  const { domain, user, tx } = context.state\n\n  var repository = tx.getRepository(ActivityApproval)\n\n  var activityApproval = await repository.findOne({\n    where: { domain: { id: domain.id }, id }\n  })\n\n  if (!activityApproval) {\n    throw new Error(\n      context.t('error.activity-approval not found', {\n        activityApproval: id\n      })\n    )\n  }\n\n  await checkAuthority(activityApproval, context)\n\n  /* \n    Prerequisite of Approval\n    - Previous judgment should be 'pending'\n  */\n  if (activityApproval.judgment !== ActivityApprovalJudgment.Pending) {\n    throw new Error(\n      context.t(`error.activity-approval is already terminated`, {\n        activityApproval: id,\n        actual: activityApproval.judgment\n      })\n    )\n  }\n\n  var activityThread = await tx.getRepository(ActivityThread).findOne({\n    where: { domain: { id: domain.id }, id: activityApproval.activityThreadId },\n    relations: ['activityInstance']\n  })\n\n  /*\n   * 여기까지 오면 스레드가 있어야 한다. 없는 채로 아래를 읽으면 `TypeError` 가 나고, 그 오류로는\n   * 무엇이 없는지 알 수 없다.\n   */\n  if (!activityThread) {\n    throw new Error(context.t('error.activity-thread not found', { activityThread: activityApproval.activityThreadId }))\n  }\n\n  if (!activityThread.activityInstance) {\n    throw new Error(context.t('error.activity-instance not found', { activityThread: activityThread.id }))\n  }\n\n  const approvalLine: ApprovalLineItem[] = activityThread.activityInstance.approvalLine\n  const order = activityApproval.order\n\n  /*\n   * A reference does not judge.\n   *\n   * The three checks above all pass for a reference row: it exists, checkAuthority says it belongs\n   * to this user, and its judgment is still Pending. Without this refusal the approval is recorded\n   * as real and nextApproval() then picks the approver sitting after that seat, moving the approval\n   * a step forward; with no approver after it, one reference ends the thread.\n   *\n   * This stands before claimPendingApproval, the first write. Throwing after the claim would leave\n   * the row already stamped with a judgment.\n   *\n   * The message says what this person can do instead of reporting a missing permission. A reference\n   * seat is a different seat, not a blocked one — comments are theirs to leave.\n   */\n  if (isReferenceOrder(approvalLine, order)) {\n    throw new Error(context.t('error.activity-approval is reference only'))\n  }\n\n  /* 다음 결재자가 누구인지는 한 자리가 정한다 — `approval-line.ts`. */\n  const next = nextApproval(approvalLine, order)\n\n  /*\n   * **여기서 잡는다.** 위의 검사는 읽은 시점의 것이라 그 사이에 남이 처리할 수 있다. 잡기가 첫 쓰기여야\n   * 진 쪽이 다음 결재자를 만들기 전에 물러난다.\n   */\n  if (!(await claimPendingApproval(tx, activityApproval, ActivityApprovalJudgment.Approved))) {\n    /* 「이미 끝났다」보다 **그 사람이 할 일**을 말한다 — 목록을 새로 읽으면 지금 상태가 보인다. */\n    throw new Error(context.t('error.activity-approval taken by someone else', { activityApproval: id }))\n  }\n\n  /*\n   * **승인한 사람은 승인한 것이다** (2026-08-31, 아키텍트 확인).\n   *\n   * 앞서는 다음 결재자가 있으면 `Escalated` 로 적었다. 그러면 「누가 승인했나」를 물을 때 중간 결재자가\n   * 전부 「상신함」으로 나오고, **승인한 것과 그냥 넘긴 것이 구별되지 않는다.** 규제 산업에서는 결재\n   * 이력이 곧 근거라 이것이 결함이다.\n   *\n   * 다음으로 넘어간 사실은 `transaction` 이 그대로 들고 있으므로 잃는 것이 없다.\n   */\n  const result = await tx.getRepository(ActivityApproval).save({\n    ...activityApproval,\n    judgment: ActivityApprovalJudgment.Approved,\n    ...stampedComment(comment),\n    transaction: next ? 'escalate' : 'approve',\n    /*\n     * **누가 처리했는지 남긴다.**\n     *\n     * 역할로 걸린 결재는 `approver` 가 비어 있고 `approverRole` 만 있다. 처리해도 그 자리가 비어 있으면\n     * 두 가지가 함께 무너진다 — 그 역할을 가진 사람들의 **대기 목록에 영원히 남고**(`approver IS NULL`\n     * 로 걸리므로), 정작 처리한 사람의 **완료 목록에는 안 나온다**(`approver = 나` 로 거르므로).\n     *\n     * 그리고 결재 이력에서 「누가 승인했나」는 역할이 아니라 사람이어야 한다.\n     */\n    approver: activityApproval.approver ?? user,\n    updater: user,\n    terminatedAt: new Date(),\n    terminator: user\n  })\n\n  /*\n   * **이번 결재가 끝나서 알릴 참조들.** `notifyAfter` 가 이 차례를 가리키는 참조가 여기 온다.\n   *\n   * 다음 결재자를 세우는 것과 **무관하게** 만든다 — 참조는 막지 않으므로, 이것이 실패해도 결재는 간다.\n   */\n  const refs = await createReferences(\n    { references: referencesToNotify(approvalLine, order), activityThread },\n    context\n  )\n  for (const f of refs.failed) {\n    console.warn(`[worklist] 참조자를 세우지 못했다 (결재선 ${f.order}번째) — ${f.reason}`)\n  }\n\n  if (next) {\n    /* 다음 결재자에게 넘긴다 — 행을 만드는 자리는 한 곳이다(§`create-approval.ts`). */\n    await createApproval(\n      { item: next.item, order: next.order, participation: 'approval', activityThread, transaction: 'escalate' },\n      context\n    )\n\n    activityThread = await tx.getRepository(ActivityThread).save({\n      ...activityThread,\n      transaction: 'escalate',\n      reason: comment,\n      state: ActivityThreadStatus.Escalated,\n      updater: user\n    })\n  } else {\n    activityThread = await tx.getRepository(ActivityThread).save({\n      ...activityThread,\n      transaction: 'approve',\n      reason: comment,\n      state: ActivityThreadStatus.Ended,\n      terminatedAt: new Date(),\n      terminator: user,\n      updater: user\n    })\n\n    /* The last approval ended it - the requester is told (ADR-0164). The next approver's turn is told where its row is made. */\n    await noticeApproval(context, { kind: 'approved', approvalId: result.id })\n  }\n\n  await updateActivityInstanceState(activityThread.activityInstanceId, { causedBy: [activityThread] }, context)\n\n  return result\n}\n"]}

package/dist-server/controllers/activity-approval/check-authority.d.ts

@@ -0,0 +1,8 @@
+import { ActivityApproval } from '../../service/activity-approval/activity-approval.js';
+/**
+ * 이 사람이 이 결재 행을 다룰 수 있나 — approve · reject · abort · delegate · save 가 함께 쓴다.
+ *
+ * 그 자리의 결재자이거나, 역할로 걸린 자리면 그 역할을 가진 사람이다. 상신자인지는 묻지 않는다 —
+ * 상신자도 결재 자리에 서면 결재한다(2026-10-23 사용자, ADR-0052 ② 를 거둠).
+ */
+export declare function checkAuthority(activityApproval: ActivityApproval, context: ResolverContext): Promise<void>;

package/dist-server/controllers/activity-approval/check-authority.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAuthority = checkAuthority;
+const shell_1 = require("@things-factory/shell");
+const auth_base_1 = require("@things-factory/auth-base");
+/**
+ * 이 사람이 이 결재 행을 다룰 수 있나 — approve · reject · abort · delegate · save 가 함께 쓴다.
+ *
+ * 그 자리의 결재자이거나, 역할로 걸린 자리면 그 역할을 가진 사람이다. 상신자인지는 묻지 않는다 —
+ * 상신자도 결재 자리에 서면 결재한다(2026-10-23 사용자, ADR-0052 ② 를 거둠).
+ */
+async function checkAuthority(activityApproval, context) {
+    const { user, tx } = context.state;
+    if (activityApproval.approverId && activityApproval.approverId === user.id) {
+        return;
+    }
+    if (!activityApproval.approver && activityApproval.approverRoleId) {
+        const roles = (await (0, shell_1.getRepository)(auth_base_1.User, tx).findOne({
+            where: { id: user.id },
+            relations: ['roles']
+        }))?.roles;
+        if (roles.find(role => role.id == activityApproval.approverRoleId)) {
+            activityApproval.approver = user;
+            return;
+        }
+    }
+    throw new Error(context.t(`error.not authorized to handle this task`));
+}
+//# sourceMappingURL=check-authority.js.map

package/dist-server/controllers/activity-approval/check-authority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-authority.js","sourceRoot":"","sources":["../../../server/controllers/activity-approval/check-authority.ts"],"names":[],"mappings":";;AAUA,wCAsBC;AAhCD,iDAAqD;AACrD,yDAAgD;AAGhD;;;;;GAKG;AACI,KAAK,UAAU,cAAc,CAAC,gBAAkC,EAAE,OAAwB;IAC/F,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,KAAK,CAAA;IAElC,IAAI,gBAAgB,CAAC,UAAU,IAAI,gBAAgB,CAAC,UAAU,KAAK,IAAI,CAAC,EAAE,EAAE,CAAC;QAC3E,OAAM;IACR,CAAC;IAED,IAAI,CAAC,gBAAgB,CAAC,QAAQ,IAAI,gBAAgB,CAAC,cAAc,EAAE,CAAC;QAClE,MAAM,KAAK,GAAG,CACZ,MAAM,IAAA,qBAAa,EAAC,gBAAI,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC;YACpC,KAAK,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE;YACtB,SAAS,EAAE,CAAC,OAAO,CAAC;SACrB,CAAC,CACH,EAAE,KAAK,CAAA;QAER,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,gBAAgB,CAAC,cAAc,CAAC,EAAE,CAAC;YACnE,gBAAgB,CAAC,QAAQ,GAAG,IAAI,CAAA;YAChC,OAAM;QACR,CAAC;IACH,CAAC;IAED,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,0CAA0C,CAAC,CAAC,CAAA;AACxE,CAAC","sourcesContent":["import { getRepository } from '@things-factory/shell'\nimport { User } from '@things-factory/auth-base'\nimport { ActivityApproval } from '../../service/activity-approval/activity-approval.js'\n\n/**\n * 이 사람이 이 결재 행을 다룰 수 있나 — approve · reject · abort · delegate · save 가 함께 쓴다.\n *\n * 그 자리의 결재자이거나, 역할로 걸린 자리면 그 역할을 가진 사람이다. 상신자인지는 묻지 않는다 —\n * 상신자도 결재 자리에 서면 결재한다(2026-10-23 사용자, ADR-0052 ② 를 거둠).\n */\nexport async function checkAuthority(activityApproval: ActivityApproval, context: ResolverContext) {\n  const { user, tx } = context.state\n\n  if (activityApproval.approverId && activityApproval.approverId === user.id) {\n    return\n  }\n\n  if (!activityApproval.approver && activityApproval.approverRoleId) {\n    const roles = (\n      await getRepository(User, tx).findOne({\n        where: { id: user.id },\n        relations: ['roles']\n      })\n    )?.roles\n\n    if (roles.find(role => role.id == activityApproval.approverRoleId)) {\n      activityApproval.approver = user\n      return\n    }\n  }\n\n  throw new Error(context.t(`error.not authorized to handle this task`))\n}\n"]}

package/dist-server/controllers/activity-approval/claim.d.ts

@@ -0,0 +1,42 @@
+import { EntityManager } from 'typeorm';
+import { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval.js';
+/**
+ * 이 결재를 내가 잡는다 — **대기 중인 것만, 한 번만.**
+ *
+ * ── 왜 필요한가 ────────────────────────────────────────────────────────────
+ * 승인·반려·위임이 다 같은 모양으로 시작한다. 읽고 → 「대기 중인가」 보고 → 저장한다. 그 사이에 아무
+ * 잠금이 없다.
+ *
+ * 역할로 걸린 결재는 **여러 명이 같은 건을 본다.** 대기 목록에 뜬 것을 두 사람이 누르는 것은 공유
+ * 대기열의 평범한 실패 방식이다. 지금은 둘 다 검사를 통과하고 **둘 다 다음 결재자를 만든다** — 같은
+ * 차례의 결재가 두 벌 서서 결재선이 갈라진다. 오류는 안 난다.
+ *
+ * ── 검사와 쓰기를 한 문장으로 ──────────────────────────────────────────────
+ * `WHERE judgment = ''` 를 갱신에 붙인다. 늦게 온 쪽은 0줄을 고치고, 그것으로 「남이 먼저 처리했다」를
+ * 안다.
+ *
+ * 두 트랜잭션이 겹치면 뒤엣것이 행 잠금 앞에서 멈춰 섰다가, 앞엣것이 커밋한 뒤 조건을 **다시 보고**
+ * 0줄을 얻는다. 세 드라이버 다 그렇게 동작한다 — postgres 는 잠금이 풀린 뒤 조건을 다시 보고, mysql
+ * InnoDB 는 갱신 시 최신 커밋본을 읽고, sqlite 는 쓰기를 아예 직렬화한다.
+ *
+ * ── 잡고 나면 그 행은 이 트랜잭션 것이다 ───────────────────────────────────
+ * 잡는 순간 행 잠금을 쥐므로, 나머지는 평범하게 저장해도 된다. 그래서 여기서는 **판정 하나만** 원자적으로
+ * 바꾼다 — 지키려는 규칙이 「대기 중인 것만 처리할 수 있다」 하나이기 때문이다.
+ *
+ * ── 왜 `@VersionColumn` 이 아닌가 ──────────────────────────────────────────
+ * 버전 칸은 컬럼을 늘려 마이그레이션이 필요하고, 이 규칙과 무관한 저장(의견 수정)까지 충돌시킨다.
+ * 이미 코드에 있는 검사를 그대로 갱신 문장으로 옮기는 편이 정확하고, 스키마를 안 건드려 배포해도
+ * 기존 데이터에 영향이 없다. (2026-08-31, 사용자 결정)
+ *
+ * ── 잡은 뒤의 저장은 안전하다 ─────────────────────────────────────────────
+ * 부르는 쪽은 잡기 뒤에 `save({ ...approval, judgment, comment, … })` 로 나머지를 쓴다. 손에 든
+ * `approval` 은 잡기 **전에** 읽은 것이라 판정이 낡았는데, 그 저장이 판정을 다시 명시하므로 되돌리지
+ * 않는다. 그리고 잡는 순간 행 잠금을 쥐었으므로 그 사이에 남이 끼어들 수 없다.
+ *
+ * 한 문장으로 합치지 않은 이유는 관계 칸 때문이다 — `updater`·`terminator`·`originalApproval` 이
+ * 엔티티 객체이고, `save()` 는 이것을 FK 로 풀어 주지만 `UpdateQueryBuilder.set()` 은 버전에 따라
+ * 다르다. 풀리지 않으면 「누가 처리했나」가 비고 **오류는 안 난다.**
+ *
+ * @returns 잡았으면 참. 거짓이면 **남이 먼저 처리했다** — 부르는 쪽이 던져서 트랜잭션을 물려야 한다.
+ */
+export declare function claimPendingApproval(tx: EntityManager, approval: ActivityApproval, judgment: ActivityApprovalJudgment): Promise<boolean>;

package/dist-server/controllers/activity-approval/claim.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimPendingApproval = claimPendingApproval;
+const activity_approval_js_1 = require("../../service/activity-approval/activity-approval.js");
+/**
+ * 이 결재를 내가 잡는다 — **대기 중인 것만, 한 번만.**
+ *
+ * ── 왜 필요한가 ────────────────────────────────────────────────────────────
+ * 승인·반려·위임이 다 같은 모양으로 시작한다. 읽고 → 「대기 중인가」 보고 → 저장한다. 그 사이에 아무
+ * 잠금이 없다.
+ *
+ * 역할로 걸린 결재는 **여러 명이 같은 건을 본다.** 대기 목록에 뜬 것을 두 사람이 누르는 것은 공유
+ * 대기열의 평범한 실패 방식이다. 지금은 둘 다 검사를 통과하고 **둘 다 다음 결재자를 만든다** — 같은
+ * 차례의 결재가 두 벌 서서 결재선이 갈라진다. 오류는 안 난다.
+ *
+ * ── 검사와 쓰기를 한 문장으로 ──────────────────────────────────────────────
+ * `WHERE judgment = ''` 를 갱신에 붙인다. 늦게 온 쪽은 0줄을 고치고, 그것으로 「남이 먼저 처리했다」를
+ * 안다.
+ *
+ * 두 트랜잭션이 겹치면 뒤엣것이 행 잠금 앞에서 멈춰 섰다가, 앞엣것이 커밋한 뒤 조건을 **다시 보고**
+ * 0줄을 얻는다. 세 드라이버 다 그렇게 동작한다 — postgres 는 잠금이 풀린 뒤 조건을 다시 보고, mysql
+ * InnoDB 는 갱신 시 최신 커밋본을 읽고, sqlite 는 쓰기를 아예 직렬화한다.
+ *
+ * ── 잡고 나면 그 행은 이 트랜잭션 것이다 ───────────────────────────────────
+ * 잡는 순간 행 잠금을 쥐므로, 나머지는 평범하게 저장해도 된다. 그래서 여기서는 **판정 하나만** 원자적으로
+ * 바꾼다 — 지키려는 규칙이 「대기 중인 것만 처리할 수 있다」 하나이기 때문이다.
+ *
+ * ── 왜 `@VersionColumn` 이 아닌가 ──────────────────────────────────────────
+ * 버전 칸은 컬럼을 늘려 마이그레이션이 필요하고, 이 규칙과 무관한 저장(의견 수정)까지 충돌시킨다.
+ * 이미 코드에 있는 검사를 그대로 갱신 문장으로 옮기는 편이 정확하고, 스키마를 안 건드려 배포해도
+ * 기존 데이터에 영향이 없다. (2026-08-31, 사용자 결정)
+ *
+ * ── 잡은 뒤의 저장은 안전하다 ─────────────────────────────────────────────
+ * 부르는 쪽은 잡기 뒤에 `save({ ...approval, judgment, comment, … })` 로 나머지를 쓴다. 손에 든
+ * `approval` 은 잡기 **전에** 읽은 것이라 판정이 낡았는데, 그 저장이 판정을 다시 명시하므로 되돌리지
+ * 않는다. 그리고 잡는 순간 행 잠금을 쥐었으므로 그 사이에 남이 끼어들 수 없다.
+ *
+ * 한 문장으로 합치지 않은 이유는 관계 칸 때문이다 — `updater`·`terminator`·`originalApproval` 이
+ * 엔티티 객체이고, `save()` 는 이것을 FK 로 풀어 주지만 `UpdateQueryBuilder.set()` 은 버전에 따라
+ * 다르다. 풀리지 않으면 「누가 처리했나」가 비고 **오류는 안 난다.**
+ *
+ * @returns 잡았으면 참. 거짓이면 **남이 먼저 처리했다** — 부르는 쪽이 던져서 트랜잭션을 물려야 한다.
+ */
+async function claimPendingApproval(tx, approval, judgment) {
+    /*
+     * 대기로 잡으면 조건이 통과하는데 판정이 그대로라 **두 번째 호출도 통과한다.** 잡는 뜻이 없어진다.
+     *
+     * `Pending` 은 빈 문자열이라 이 한 줄에 함께 걸린다 — 타입 검사도 그렇게 좁혀 준다.
+     */
+    if (!judgment) {
+        throw new Error('claimPendingApproval: a claim must move the judgment out of pending');
+    }
+    const result = await tx
+        .createQueryBuilder()
+        .update(activity_approval_js_1.ActivityApproval)
+        .set({ judgment })
+        .where('id = :id', { id: approval.id })
+        /*
+         * 대기 중은 빈 문자열이다(`ActivityApprovalJudgment.Pending`). `IS NULL` 도 함께 보는 이유는 기본값이
+         * 안 들어간 옛 행이 있을 수 있어서다 — 그런 행을 못 잡으면 그 결재는 영영 처리되지 않는다.
+         */
+        .andWhere('(judgment = :pending OR judgment IS NULL)', { pending: activity_approval_js_1.ActivityApprovalJudgment.Pending })
+        .execute();
+    /*
+     * `?? 0` here is deliberate, and it is the opposite of the same expression elsewhere.
+     *
+     * A missing row count means we do not know whether this claim took. For a conditional update
+     * that hands one person an approval, not knowing has to read as "did not get it": refusing a
+     * claim costs a retry, while granting one on an unknown result lets two people judge the same
+     * request. The unknown value maps to the conservative answer on purpose.
+     *
+     * Elsewhere the same `?? 0` was a defect — a missing count drawn as 「0 waiting」 — so the two
+     * are worth telling apart rather than tidying into one habit.
+     */
+    return (result.affected ?? 0) > 0;
+}
+//# sourceMappingURL=claim.js.map

package/dist-server/controllers/activity-approval/claim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claim.js","sourceRoot":"","sources":["../../../server/controllers/activity-approval/claim.ts"],"names":[],"mappings":";;AA2CA,oDAsCC;AA/ED,+FAAiH;AAEjH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACI,KAAK,UAAU,oBAAoB,CACxC,EAAiB,EACjB,QAA0B,EAC1B,QAAkC;IAElC;;;;OAIG;IACH,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAA;IACxF,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,EAAE;SACpB,kBAAkB,EAAE;SACpB,MAAM,CAAC,uCAAgB,CAAC;SACxB,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC;SACjB,KAAK,CAAC,UAAU,EAAE,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC;QACvC;;;WAGG;SACF,QAAQ,CAAC,2CAA2C,EAAE,EAAE,OAAO,EAAE,+CAAwB,CAAC,OAAO,EAAE,CAAC;SACpG,OAAO,EAAE,CAAA;IAEZ;;;;;;;;;;OAUG;IACH,OAAO,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,GAAG,CAAC,CAAA;AACnC,CAAC","sourcesContent":["import { EntityManager } from 'typeorm'\n\nimport { ActivityApproval, ActivityApprovalJudgment } from '../../service/activity-approval/activity-approval.js'\n\n/**\n * 이 결재를 내가 잡는다 — **대기 중인 것만, 한 번만.**\n *\n * ── 왜 필요한가 ────────────────────────────────────────────────────────────\n * 승인·반려·위임이 다 같은 모양으로 시작한다. 읽고 → 「대기 중인가」 보고 → 저장한다. 그 사이에 아무\n * 잠금이 없다.\n *\n * 역할로 걸린 결재는 **여러 명이 같은 건을 본다.** 대기 목록에 뜬 것을 두 사람이 누르는 것은 공유\n * 대기열의 평범한 실패 방식이다. 지금은 둘 다 검사를 통과하고 **둘 다 다음 결재자를 만든다** — 같은\n * 차례의 결재가 두 벌 서서 결재선이 갈라진다. 오류는 안 난다.\n *\n * ── 검사와 쓰기를 한 문장으로 ──────────────────────────────────────────────\n * `WHERE judgment = ''` 를 갱신에 붙인다. 늦게 온 쪽은 0줄을 고치고, 그것으로 「남이 먼저 처리했다」를\n * 안다.\n *\n * 두 트랜잭션이 겹치면 뒤엣것이 행 잠금 앞에서 멈춰 섰다가, 앞엣것이 커밋한 뒤 조건을 **다시 보고**\n * 0줄을 얻는다. 세 드라이버 다 그렇게 동작한다 — postgres 는 잠금이 풀린 뒤 조건을 다시 보고, mysql\n * InnoDB 는 갱신 시 최신 커밋본을 읽고, sqlite 는 쓰기를 아예 직렬화한다.\n *\n * ── 잡고 나면 그 행은 이 트랜잭션 것이다 ───────────────────────────────────\n * 잡는 순간 행 잠금을 쥐므로, 나머지는 평범하게 저장해도 된다. 그래서 여기서는 **판정 하나만** 원자적으로\n * 바꾼다 — 지키려는 규칙이 「대기 중인 것만 처리할 수 있다」 하나이기 때문이다.\n *\n * ── 왜 `@VersionColumn` 이 아닌가 ──────────────────────────────────────────\n * 버전 칸은 컬럼을 늘려 마이그레이션이 필요하고, 이 규칙과 무관한 저장(의견 수정)까지 충돌시킨다.\n * 이미 코드에 있는 검사를 그대로 갱신 문장으로 옮기는 편이 정확하고, 스키마를 안 건드려 배포해도\n * 기존 데이터에 영향이 없다. (2026-08-31, 사용자 결정)\n *\n * ── 잡은 뒤의 저장은 안전하다 ─────────────────────────────────────────────\n * 부르는 쪽은 잡기 뒤에 `save({ ...approval, judgment, comment, … })` 로 나머지를 쓴다. 손에 든\n * `approval` 은 잡기 **전에** 읽은 것이라 판정이 낡았는데, 그 저장이 판정을 다시 명시하므로 되돌리지\n * 않는다. 그리고 잡는 순간 행 잠금을 쥐었으므로 그 사이에 남이 끼어들 수 없다.\n *\n * 한 문장으로 합치지 않은 이유는 관계 칸 때문이다 — `updater`·`terminator`·`originalApproval` 이\n * 엔티티 객체이고, `save()` 는 이것을 FK 로 풀어 주지만 `UpdateQueryBuilder.set()` 은 버전에 따라\n * 다르다. 풀리지 않으면 「누가 처리했나」가 비고 **오류는 안 난다.**\n *\n * @returns 잡았으면 참. 거짓이면 **남이 먼저 처리했다** — 부르는 쪽이 던져서 트랜잭션을 물려야 한다.\n */\nexport async function claimPendingApproval(\n  tx: EntityManager,\n  approval: ActivityApproval,\n  judgment: ActivityApprovalJudgment\n): Promise<boolean> {\n  /*\n   * 대기로 잡으면 조건이 통과하는데 판정이 그대로라 **두 번째 호출도 통과한다.** 잡는 뜻이 없어진다.\n   *\n   * `Pending` 은 빈 문자열이라 이 한 줄에 함께 걸린다 — 타입 검사도 그렇게 좁혀 준다.\n   */\n  if (!judgment) {\n    throw new Error('claimPendingApproval: a claim must move the judgment out of pending')\n  }\n\n  const result = await tx\n    .createQueryBuilder()\n    .update(ActivityApproval)\n    .set({ judgment })\n    .where('id = :id', { id: approval.id })\n    /*\n     * 대기 중은 빈 문자열이다(`ActivityApprovalJudgment.Pending`). `IS NULL` 도 함께 보는 이유는 기본값이\n     * 안 들어간 옛 행이 있을 수 있어서다 — 그런 행을 못 잡으면 그 결재는 영영 처리되지 않는다.\n     */\n    .andWhere('(judgment = :pending OR judgment IS NULL)', { pending: ActivityApprovalJudgment.Pending })\n    .execute()\n\n  /*\n   * `?? 0` here is deliberate, and it is the opposite of the same expression elsewhere.\n   *\n   * A missing row count means we do not know whether this claim took. For a conditional update\n   * that hands one person an approval, not knowing has to read as \"did not get it\": refusing a\n   * claim costs a retry, while granting one on an unknown result lets two people judge the same\n   * request. The unknown value maps to the conservative answer on purpose.\n   *\n   * Elsewhere the same `?? 0` was a defect — a missing count drawn as 「0 waiting」 — so the two\n   * are worth telling apart rather than tidying into one habit.\n   */\n  return (result.affected ?? 0) > 0\n}\n"]}

package/dist-server/controllers/activity-approval/create-approval.d.ts

@@ -0,0 +1,41 @@
+import type { ApprovalLineItem } from '@things-factory/organization';
+import { ActivityApproval } from '../../service/activity-approval/activity-approval.js';
+import type { ActivityThread } from '../../service/activity-thread/activity-thread.js';
+/** 이 항목이 무슨 자격으로 서나 — 행에도 적는다(목록 질의가 참조를 걸러야 한다). */
+export type Participation = 'approval' | 'reference';
+/**
+ * 결재선 항목 하나로 행을 만든다.
+ *
+ * 역할로 걸린 것은 `approverRole` 만 채워지고 `approver` 는 비어 있다 — 그 역할을 가진 사람 여럿이 같은
+ * 건을 본다. 처리하는 사람이 정해지는 것은 누른 순간이다(§`approve.ts`).
+ */
+export declare function createApproval(args: {
+    item: ApprovalLineItem;
+    order: number;
+    participation: Participation;
+    activityThread: ActivityThread;
+    /** 이 행이 왜 생겼나 — `submit` · `escalate` · `notify`. */
+    transaction: string;
+}, context: ResolverContext): Promise<ActivityApproval>;
+/**
+ * 이번에 알려야 할 참조들의 행을 만든다 — **하나가 실패해도 결재를 세우지 않는다.**
+ *
+ * 참조는 막지 않는 자격이다. 그런데 참조자를 못 찾아 던지면 그 예외가 상신·승인을 통째로 물린다 —
+ * 막지 않기로 한 것이 막게 된다.
+ *
+ * 그래서 실패를 삼키지 않되 **던지지도 않는다.** 못 만든 참조를 이유와 함께 돌려주고, 부르는 쪽이
+ * 그것을 기록한다.
+ */
+export declare function createReferences(args: {
+    references: {
+        item: ApprovalLineItem;
+        order: number;
+    }[];
+    activityThread: ActivityThread;
+}, context: ResolverContext): Promise<{
+    created: ActivityApproval[];
+    failed: {
+        order: number;
+        reason: string;
+    }[];
+}>;