@naisys/erp 3.0.0-beta.10

package/dist/routes/operation-field-refs.js

@@ -0,0 +1,263 @@
+import { CreateFieldRefSchema, ErrorResponseSchema, FieldRefListResponseSchema, RevisionStatus, SeqNoCreateResponseSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { requirePermission } from "../auth-middleware.js";
+import erpDb from "../erpDb.js";
+import { conflict, notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { calcNextSeqNo, childItemLinks, mutationResult, resolveActions, resolveOperation, } from "../route-helpers.js";
+import { checkDuplicateSource, createFieldRef, deleteFieldRef, findExistingFieldRef, listFieldRefs, } from "../services/field-ref-service.js";
+const ParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+const RefParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+    refSeqNo: z.coerce.number().int(),
+});
+function basePath(orderKey, revNo, seqNo) {
+    return `/orders/${orderKey}/revs/${revNo}/ops/${seqNo}/field-refs`;
+}
+function formatFieldRef(orderKey, revNo, seqNo, revStatus, user, ref) {
+    const base = basePath(orderKey, revNo, seqNo);
+    return {
+        id: ref.id,
+        seqNo: ref.seqNo,
+        title: ref.title,
+        sourceOpSeqNo: ref.sourceStep.operation.seqNo,
+        sourceOpTitle: ref.sourceStep.operation.title,
+        sourceStepSeqNo: ref.sourceStep.seqNo,
+        sourceStepTitle: ref.sourceStep.title,
+        fields: (ref.sourceStep.fieldSet?.fields ?? []).map((f) => ({
+            seqNo: f.seqNo,
+            label: f.label,
+            type: f.type,
+        })),
+        createdAt: ref.createdAt.toISOString(),
+        createdBy: ref.createdBy.username,
+        _links: childItemLinks(base, ref.seqNo, "Field Refs", `/orders/${orderKey}/revs/${revNo}/ops/${seqNo}`, "Operation", "FieldRef"),
+        _actions: deleteAction(`${API_PREFIX}${base}/${ref.seqNo}`, revStatus, user),
+    };
+}
+function deleteAction(href, revStatus, user) {
+    return resolveActions([
+        {
+            rel: "delete",
+            method: "DELETE",
+            title: "Remove Reference",
+            permission: "order_planner",
+            statuses: [RevisionStatus.draft],
+            hideWithoutPermission: true,
+        },
+    ], href, { status: revStatus, user });
+}
+const draftCreateDef = {
+    rel: "create",
+    method: "POST",
+    title: "Add Field Reference",
+    schema: `${API_PREFIX}/schemas/CreateFieldRef`,
+    permission: "order_planner",
+    disabledWhen: (ctx) => ctx.status !== RevisionStatus.draft
+        ? "Can only add field references in draft revisions"
+        : null,
+};
+// Schema for the /available response
+const AvailableStepSchema = z.object({
+    opSeqNo: z.number(),
+    opTitle: z.string(),
+    stepSeqNo: z.number(),
+    stepTitle: z.string(),
+    stepId: z.number(),
+    fieldCount: z.number(),
+});
+const AvailableStepsResponseSchema = z.object({
+    items: z.array(AvailableStepSchema),
+});
+export default function operationFieldRefRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST available steps with fields (for the "add reference" dialog)
+    app.get("/available", {
+        schema: {
+            description: "List steps with fields in the same revision that can be referenced",
+            tags: ["Operation Field Refs"],
+            params: ParamsSchema,
+            response: {
+                200: AvailableStepsResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const resolved = await resolveOperation(orderKey, revNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation not found");
+            }
+            // Find all steps in this revision that have fields
+            const steps = await erpDb.step.findMany({
+                where: {
+                    operation: { orderRevId: resolved.rev.id },
+                    fieldSetId: { not: null },
+                    fieldSet: { fields: { some: {} } },
+                },
+                select: {
+                    id: true,
+                    seqNo: true,
+                    title: true,
+                    operation: { select: { seqNo: true, title: true } },
+                    fieldSet: { select: { _count: { select: { fields: true } } } },
+                },
+                orderBy: [{ operation: { seqNo: "asc" } }, { seqNo: "asc" }],
+            });
+            // Exclude steps already referenced by this operation
+            const existingRefs = await erpDb.operationFieldRef.findMany({
+                where: { operationId: resolved.operation.id },
+                select: { sourceStepId: true },
+            });
+            const refSet = new Set(existingRefs.map((r) => r.sourceStepId));
+            return {
+                items: steps
+                    .filter((s) => !refSet.has(s.id))
+                    .map((s) => ({
+                    opSeqNo: s.operation.seqNo,
+                    opTitle: s.operation.title,
+                    stepSeqNo: s.seqNo,
+                    stepTitle: s.title,
+                    stepId: s.id,
+                    fieldCount: s.fieldSet?._count.fields ?? 0,
+                })),
+            };
+        },
+    });
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List field references for an operation",
+            tags: ["Operation Field Refs"],
+            params: ParamsSchema,
+            response: {
+                200: FieldRefListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const resolved = await resolveOperation(orderKey, revNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation not found");
+            }
+            const items = await listFieldRefs(resolved.operation.id);
+            const maxSeq = items.length > 0 ? items[items.length - 1].seqNo : 0;
+            const base = basePath(orderKey, revNo, seqNo);
+            return {
+                items: items.map((ref) => {
+                    const { _links, ...rest } = formatFieldRef(orderKey, revNo, seqNo, resolved.rev.status, request.erpUser, ref);
+                    return rest;
+                }),
+                total: items.length,
+                nextSeqNo: calcNextSeqNo(maxSeq),
+                _links: [selfLink(base)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}${base}/{seqNo}`,
+                    },
+                ],
+                _actions: resolveActions([draftCreateDef], `${API_PREFIX}${base}`, {
+                    status: resolved.rev.status,
+                    user: request.erpUser,
+                }),
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Add a field reference to an operation (draft revision only)",
+            tags: ["Operation Field Refs"],
+            params: ParamsSchema,
+            body: CreateFieldRefSchema,
+            response: {
+                201: SeqNoCreateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const { seqNo: requestedSeqNo, title, sourceOpSeqNo, sourceStepSeqNo, } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOperation(orderKey, revNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation not found");
+            }
+            if (resolved.rev.status !== RevisionStatus.draft) {
+                return conflict(reply, `Cannot add field references to a ${resolved.rev.status} revision`);
+            }
+            // Resolve source step
+            const sourceOp = await erpDb.operation.findFirst({
+                where: { orderRevId: resolved.rev.id, seqNo: sourceOpSeqNo },
+            });
+            if (!sourceOp) {
+                return notFound(reply, `Source operation ${sourceOpSeqNo} not found`);
+            }
+            const sourceStep = await erpDb.step.findFirst({
+                where: { operationId: sourceOp.id, seqNo: sourceStepSeqNo },
+                select: { id: true, fieldSetId: true },
+            });
+            if (!sourceStep) {
+                return notFound(reply, `Source step ${sourceStepSeqNo} not found in operation ${sourceOpSeqNo}`);
+            }
+            if (!sourceStep.fieldSetId) {
+                return conflict(reply, "Source step has no fields");
+            }
+            // Check for duplicate
+            const dup = await checkDuplicateSource(resolved.operation.id, sourceStep.id);
+            if (dup) {
+                return conflict(reply, "This step is already referenced");
+            }
+            const ref = await createFieldRef(resolved.operation.id, requestedSeqNo, title, sourceStep.id, userId);
+            const full = formatFieldRef(orderKey, revNo, seqNo, resolved.rev.status, request.erpUser, ref);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                seqNo: full.seqNo,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE
+    app.delete("/:refSeqNo", {
+        schema: {
+            description: "Remove a field reference from an operation (draft revision only)",
+            tags: ["Operation Field Refs"],
+            params: RefParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo, refSeqNo } = request.params;
+            const resolved = await resolveOperation(orderKey, revNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation not found");
+            }
+            if (resolved.rev.status !== RevisionStatus.draft) {
+                return conflict(reply, `Cannot remove field references from a ${resolved.rev.status} revision`);
+            }
+            const existing = await findExistingFieldRef(resolved.operation.id, refSeqNo);
+            if (!existing) {
+                return notFound(reply, `Field reference ${refSeqNo} not found`);
+            }
+            await deleteFieldRef(existing.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=operation-field-refs.js.map

package/dist/routes/operation-run-comments.js

@@ -0,0 +1,108 @@
+import { CreateOperationRunCommentSchema, CreateResponseSchema, ErrorResponseSchema, OperationRunCommentListResponseSchema, OperationRunCommentType, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { requirePermission } from "../auth-middleware.js";
+import { notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { mutationResult, resolveActions, resolveOpRun, } from "../route-helpers.js";
+import { createComment, listComments, } from "../services/operation-run-comment-service.js";
+function commentResource(orderKey, runNo, seqNo) {
+    return `orders/${orderKey}/runs/${runNo}/ops/${seqNo}/comments`;
+}
+function commentListActions(orderKey, runNo, seqNo, user) {
+    return resolveActions([
+        {
+            rel: "create",
+            method: "POST",
+            title: "Add Comment",
+            schema: `${API_PREFIX}/schemas/CreateOperationRunComment`,
+            permission: "order_executor",
+        },
+    ], `${API_PREFIX}/${commentResource(orderKey, runNo, seqNo)}`, { user });
+}
+function formatComment(orderKey, runNo, seqNo, comment) {
+    return {
+        id: comment.id,
+        operationRunId: comment.operationRunId,
+        type: comment.type,
+        body: comment.body,
+        createdAt: comment.createdAt.toISOString(),
+        createdBy: comment.createdBy.username,
+        _links: [
+            selfLink(`/${commentResource(orderKey, runNo, seqNo)}/${comment.id}`),
+        ],
+    };
+}
+const CommentParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+export default function operationRunCommentRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List comments for an operation run",
+            tags: ["Operation Run Comments"],
+            params: CommentParamsSchema,
+            response: {
+                200: OperationRunCommentListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation run not found");
+            }
+            const items = await listComments(resolved.opRun.id);
+            return {
+                items: items.map((c) => {
+                    const { _links, ...rest } = formatComment(orderKey, runNo, seqNo, c);
+                    return rest;
+                }),
+                total: items.length,
+                _links: [selfLink(`/${commentResource(orderKey, runNo, seqNo)}`)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/${commentResource(orderKey, runNo, seqNo)}/{id}`,
+                    },
+                ],
+                _actions: commentListActions(orderKey, runNo, seqNo, request.erpUser),
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Add a comment to an operation run",
+            tags: ["Operation Run Comments"],
+            params: CommentParamsSchema,
+            body: CreateOperationRunCommentSchema,
+            response: {
+                201: CreateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const { type, body } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation run not found");
+            }
+            const comment = await createComment(resolved.opRun.id, type ?? OperationRunCommentType.note, body, userId);
+            const full = formatComment(orderKey, runNo, seqNo, comment);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                _links: full._links,
+            });
+        },
+    });
+}
+//# sourceMappingURL=operation-run-comments.js.map

package/dist/routes/operation-run-transitions.js

@@ -0,0 +1,249 @@
+import { ErrorResponseSchema, OperationRunStatus, OperationRunTransitionSlimSchema, OrderRunStatus, TransitionNoteSchema, } from "@naisys/erp-shared";
+import { requirePermission } from "../auth-middleware.js";
+import { conflict, notFound, unprocessable } from "../error-handler.js";
+import { checkOrderRunStarted, checkWorkCenterAccess, mutationResult, resolveOpRun, } from "../route-helpers.js";
+import { clockIn, clockOutAllForOpRun, isUserClockedIn, sumLaborTicketCosts, } from "../services/labor-ticket-service.js";
+import { checkPredecessorsComplete, checkStepsComplete, reblockSuccessors, transitionStatus, unblockSuccessors, validateStatusFor, } from "../services/operation-run-service.js";
+import { transitionStatus as transitionOrderRunStatus } from "../services/order-run-service.js";
+import { formatOpRunTransition, SeqNoParamsSchema } from "./operation-runs.js";
+export default function operationRunTransitionRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // START (pending → in_progress)
+    app.post("/:seqNo/start", {
+        schema: {
+            description: "Start an operation run (pending → in_progress)",
+            tags: ["Operation Runs"],
+            params: SeqNoParamsSchema,
+            body: TransitionNoteSchema,
+            response: {
+                200: OperationRunTransitionSlimSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+                422: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const { note } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, `Operation run not found`);
+            const wcErr = await checkWorkCenterAccess(resolved.opRun.operationId, request.erpUser);
+            if (wcErr)
+                return conflict(reply, wcErr);
+            // Auto-start the order run if it's still in released status
+            if (resolved.run.status === OrderRunStatus.released) {
+                await transitionOrderRunStatus(resolved.run.id, "start", OrderRunStatus.released, OrderRunStatus.started, userId);
+            }
+            else {
+                const orderErr = checkOrderRunStarted(resolved.run.status);
+                if (orderErr)
+                    return conflict(reply, orderErr);
+            }
+            const statusErr = validateStatusFor("start", resolved.opRun.status, [
+                OperationRunStatus.pending,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const priorErr = await checkPredecessorsComplete(resolved.run.id, resolved.opRun.operationId);
+            if (priorErr)
+                return unprocessable(reply, priorErr);
+            const opRun = await transitionStatus(resolved.opRun.id, "start", OperationRunStatus.pending, OperationRunStatus.in_progress, userId, { assignedToId: userId, statusNote: note ?? null });
+            await clockIn(resolved.opRun.id, userId, userId);
+            const full = await formatOpRunTransition(orderKey, runNo, request.erpUser, opRun);
+            return mutationResult(request, reply, full, {
+                status: opRun.status,
+                _actions: full._actions,
+            });
+        },
+    });
+    // COMPLETE (in_progress → completed)
+    app.post("/:seqNo/complete", {
+        schema: {
+            description: "Complete an operation run (in_progress → completed)",
+            tags: ["Operation Runs"],
+            params: SeqNoParamsSchema,
+            body: TransitionNoteSchema,
+            response: {
+                200: OperationRunTransitionSlimSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+                422: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const { note } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, `Operation run not found`);
+            const wcErr = await checkWorkCenterAccess(resolved.opRun.operationId, request.erpUser);
+            if (wcErr)
+                return conflict(reply, wcErr);
+            const orderErr = checkOrderRunStarted(resolved.run.status);
+            if (orderErr)
+                return conflict(reply, orderErr);
+            const statusErr = validateStatusFor("complete", resolved.opRun.status, [
+                OperationRunStatus.in_progress,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const clockedIn = await isUserClockedIn(resolved.opRun.id, userId);
+            if (!clockedIn)
+                return conflict(reply, `You must be clocked in to complete an operation`);
+            const stepsErr = await checkStepsComplete(resolved.opRun.id);
+            if (stepsErr)
+                return unprocessable(reply, stepsErr);
+            await clockOutAllForOpRun(resolved.opRun.id, userId);
+            const cost = await sumLaborTicketCosts(resolved.opRun.id);
+            const opRun = await transitionStatus(resolved.opRun.id, "complete", OperationRunStatus.in_progress, OperationRunStatus.completed, userId, {
+                completedAt: new Date(),
+                cost,
+                statusNote: note ?? null,
+            });
+            await unblockSuccessors(resolved.run.id, resolved.opRun.operationId, userId);
+            const full = await formatOpRunTransition(orderKey, runNo, request.erpUser, opRun);
+            return mutationResult(request, reply, full, {
+                status: opRun.status,
+                _actions: full._actions,
+            });
+        },
+    });
+    // SKIP (pending → skipped)
+    app.post("/:seqNo/skip", {
+        schema: {
+            description: "Skip an operation run (pending → skipped)",
+            tags: ["Operation Runs"],
+            params: SeqNoParamsSchema,
+            body: TransitionNoteSchema,
+            response: {
+                200: OperationRunTransitionSlimSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const { note } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, `Operation run not found`);
+            const wcErr = await checkWorkCenterAccess(resolved.opRun.operationId, request.erpUser);
+            if (wcErr)
+                return conflict(reply, wcErr);
+            const orderErr = checkOrderRunStarted(resolved.run.status);
+            if (orderErr)
+                return conflict(reply, orderErr);
+            const statusErr = validateStatusFor("skip", resolved.opRun.status, [
+                OperationRunStatus.blocked,
+                OperationRunStatus.pending,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const cost = await sumLaborTicketCosts(resolved.opRun.id);
+            const opRun = await transitionStatus(resolved.opRun.id, "skip", resolved.opRun.status, OperationRunStatus.skipped, userId, { ...(cost > 0 ? { cost } : undefined), statusNote: note ?? null });
+            await unblockSuccessors(resolved.run.id, resolved.opRun.operationId, userId);
+            const full = await formatOpRunTransition(orderKey, runNo, request.erpUser, opRun);
+            return mutationResult(request, reply, full, {
+                status: opRun.status,
+                _actions: full._actions,
+            });
+        },
+    });
+    // FAIL (in_progress → failed)
+    app.post("/:seqNo/fail", {
+        schema: {
+            description: "Fail an operation run (in_progress → failed)",
+            tags: ["Operation Runs"],
+            params: SeqNoParamsSchema,
+            body: TransitionNoteSchema,
+            response: {
+                200: OperationRunTransitionSlimSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const { note } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, `Operation run not found`);
+            const wcErr = await checkWorkCenterAccess(resolved.opRun.operationId, request.erpUser);
+            if (wcErr)
+                return conflict(reply, wcErr);
+            const orderErr = checkOrderRunStarted(resolved.run.status);
+            if (orderErr)
+                return conflict(reply, orderErr);
+            const statusErr = validateStatusFor("fail", resolved.opRun.status, [
+                OperationRunStatus.in_progress,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            await clockOutAllForOpRun(resolved.opRun.id, userId);
+            const cost = await sumLaborTicketCosts(resolved.opRun.id);
+            const opRun = await transitionStatus(resolved.opRun.id, "fail", OperationRunStatus.in_progress, OperationRunStatus.failed, userId, { ...(cost > 0 ? { cost } : undefined), statusNote: note ?? null });
+            const full = await formatOpRunTransition(orderKey, runNo, request.erpUser, opRun);
+            return mutationResult(request, reply, full, {
+                status: opRun.status,
+                _actions: full._actions,
+            });
+        },
+    });
+    // REOPEN (completed/skipped/failed → in_progress/pending)
+    app.post("/:seqNo/reopen", {
+        schema: {
+            description: "Reopen an operation run (completed → in_progress)",
+            tags: ["Operation Runs"],
+            params: SeqNoParamsSchema,
+            body: TransitionNoteSchema,
+            response: {
+                200: OperationRunTransitionSlimSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const { note } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, `Operation run not found`);
+            const wcErr = await checkWorkCenterAccess(resolved.opRun.operationId, request.erpUser);
+            if (wcErr)
+                return conflict(reply, wcErr);
+            const orderErr = checkOrderRunStarted(resolved.run.status);
+            if (orderErr)
+                return conflict(reply, orderErr);
+            const statusErr = validateStatusFor("reopen", resolved.opRun.status, [
+                OperationRunStatus.completed,
+                OperationRunStatus.skipped,
+                OperationRunStatus.failed,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const reopenTo = resolved.opRun.status === OperationRunStatus.skipped
+                ? OperationRunStatus.pending
+                : OperationRunStatus.in_progress;
+            const opRun = await transitionStatus(resolved.opRun.id, "reopen", resolved.opRun.status, reopenTo, userId, { completedAt: null, statusNote: note ?? null });
+            // Re-block successor ops that are still pending
+            await reblockSuccessors(resolved.run.id, resolved.opRun.operationId, userId);
+            const full = await formatOpRunTransition(orderKey, runNo, request.erpUser, opRun);
+            return mutationResult(request, reply, full, {
+                status: opRun.status,
+                _actions: full._actions,
+            });
+        },
+    });
+}
+//# sourceMappingURL=operation-run-transitions.js.map