@naisys/erp 3.0.0-beta.3

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

package/dist/routes/operation-runs.d.ts

@@ -0,0 +1,112 @@
+import type { FastifyInstance } from "fastify";
+import { z } from "zod/v4";
+import type { ErpUser } from "../auth-middleware.js";
+import { type OpRunWithOp } from "../services/operation-run-service.js";
+export declare const SeqNoParamsSchema: z.ZodObject<{
+    orderKey: z.ZodString;
+    runNo: z.ZodCoercedNumber<unknown>;
+    seqNo: z.ZodCoercedNumber<unknown>;
+}, z.core.$strip>;
+export declare function formatOpRun(orderKey: string, runNo: number, user: ErpUser | undefined, opRun: OpRunWithOp): Promise<{
+    _links: {
+        rel: string;
+        href: string;
+        method?: string | undefined;
+        title?: string | undefined;
+        schema?: string | undefined;
+    }[];
+    _actions: {
+        rel: string;
+        href: string;
+        method: string;
+        title?: string | undefined;
+        schema?: string | undefined;
+        body?: Record<string, unknown> | undefined;
+        alternateEncoding?: {
+            contentType: string;
+            fileFields: string[];
+            description?: string | undefined;
+        } | undefined;
+        disabled?: boolean | undefined;
+        disabledReason?: string | string[] | undefined;
+    }[];
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+    fieldRefSummary?: {
+        seqNo: number;
+        title: string;
+        sourceOpSeqNo: number;
+        sourceOpTitle: string;
+        sourceStepSeqNo: number;
+        sourceStepTitle: string;
+        multiSet: boolean;
+        fieldValues: {
+            fieldId: number;
+            fieldSeqNo: number;
+            label: string;
+            type: string;
+            valueFormat: string;
+            required: boolean;
+            setIndex: number;
+            value: string | string[];
+            validation: {
+                valid: boolean;
+                error?: string | undefined;
+            };
+            attachments?: {
+                id: string;
+                filename: string;
+                fileSize: number;
+                downloadHref?: string | undefined;
+            }[] | undefined;
+        }[];
+    }[] | undefined;
+    id: number;
+    orderRunId: number;
+    operationId: number;
+    seqNo: number;
+    title: string;
+    description: string;
+    workCenterKey: string | null;
+    status: import("../generated/prisma/enums.js").OperationRunStatus;
+    assignedTo: string | null;
+    cost: number | null;
+    note: string | null;
+    completedAt: string | null;
+    stepSummary: {
+        seqNo: number;
+        title: string;
+        completed: boolean;
+    }[];
+}>;
+export declare function formatOpRunTransition(orderKey: string, runNo: number, user: ErpUser | undefined, opRun: OpRunWithOp): Promise<{
+    _actions: {
+        rel: string;
+        href: string;
+        method: string;
+        title?: string | undefined;
+        schema?: string | undefined;
+        body?: Record<string, unknown> | undefined;
+        alternateEncoding?: {
+            contentType: string;
+            fileFields: string[];
+            description?: string | undefined;
+        } | undefined;
+        disabled?: boolean | undefined;
+        disabledReason?: string | string[] | undefined;
+    }[];
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+    id: number;
+    status: import("../generated/prisma/enums.js").OperationRunStatus;
+    assignedTo: string | null;
+    cost: number | null;
+    note: string | null;
+    completedAt: string | null;
+}>;
+export default function operationRunRoutes(fastify: FastifyInstance): void;
+//# sourceMappingURL=operation-runs.d.ts.map

package/dist/routes/operation-runs.js

@@ -0,0 +1,299 @@
+import { ErrorResponseSchema, MutateResponseSchema, OperationRunListResponseSchema, OperationRunSchema, OperationRunStatus, UpdateOperationRunSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { conflict, notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { checkOrderRunStarted, checkWorkCenterAccess, childItemLinks, formatAuditFields, formatDate, resolveActions, resolveOpRun, resolveOrderRun, useFullSerializer, wantsFullResponse, } from "../route-helpers.js";
+import { checkStepsComplete, getOpRun, getOpRunFieldRefSummary, getOpRunStepSummary, listOpRuns, updateOpRun, validateStatusFor, } from "../services/operation-run-service.js";
+function opRunResource(orderKey, runNo) {
+    return `orders/${orderKey}/runs/${runNo}/ops`;
+}
+async function opRunItemActions(orderKey, runNo, seqNo, opRunId, operationId, status, user) {
+    const href = `${API_PREFIX}/${opRunResource(orderKey, runNo)}/${seqNo}`;
+    const isExecutor = hasPermission(user, "order_executor");
+    const stepsErr = isExecutor && status === OperationRunStatus.in_progress
+        ? await checkStepsComplete(opRunId)
+        : null;
+    const wcErr = user ? await checkWorkCenterAccess(operationId, user) : null;
+    return resolveActions([
+        {
+            rel: "assign",
+            method: "PUT",
+            title: "Assign",
+            schema: `${API_PREFIX}/schemas/UpdateOperationRun`,
+            body: { assignedToId: 0 },
+            permission: "order_manager",
+            statuses: [
+                OperationRunStatus.blocked,
+                OperationRunStatus.pending,
+                OperationRunStatus.in_progress,
+            ],
+        },
+        {
+            rel: "add-comment",
+            path: "/comments",
+            method: "POST",
+            title: "Add Comment",
+            schema: `${API_PREFIX}/schemas/CreateOperationRunComment`,
+            body: { body: "" },
+            permission: "order_executor",
+        },
+        {
+            rel: "start",
+            path: "/start",
+            method: "POST",
+            title: "Start",
+            permission: "order_executor",
+            statuses: [OperationRunStatus.blocked, OperationRunStatus.pending],
+            disabledWhen: (ctx) => wcErr ??
+                (ctx.status === OperationRunStatus.blocked
+                    ? "Operation is blocked by incomplete predecessors"
+                    : null),
+        },
+        {
+            rel: "update",
+            method: "PUT",
+            title: "Update",
+            schema: `${API_PREFIX}/schemas/UpdateOperationRun`,
+            body: { assignedToId: 0 },
+            permission: "order_executor",
+            statuses: [OperationRunStatus.pending, OperationRunStatus.in_progress],
+        },
+        {
+            rel: "complete",
+            path: "/complete",
+            method: "POST",
+            title: "Complete",
+            schema: `${API_PREFIX}/schemas/CompleteOperationRun`,
+            body: { note: "" },
+            permission: "order_executor",
+            statuses: [OperationRunStatus.in_progress],
+            disabledWhen: () => wcErr ?? stepsErr,
+        },
+        {
+            rel: "skip",
+            path: "/skip",
+            method: "POST",
+            title: "Skip",
+            permission: "order_manager",
+            statuses: [OperationRunStatus.blocked, OperationRunStatus.pending],
+            disabledWhen: () => wcErr,
+        },
+        {
+            rel: "fail",
+            path: "/fail",
+            method: "POST",
+            title: "Fail",
+            permission: "order_manager",
+            statuses: [OperationRunStatus.in_progress],
+            disabledWhen: () => wcErr,
+        },
+        {
+            rel: "reopen",
+            path: "/reopen",
+            method: "POST",
+            title: "Reopen",
+            permission: "order_manager",
+            statuses: [
+                OperationRunStatus.completed,
+                OperationRunStatus.skipped,
+                OperationRunStatus.failed,
+            ],
+            disabledWhen: () => wcErr,
+        },
+    ], href, { status, user });
+}
+const RunNoParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+});
+export const SeqNoParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+export async function formatOpRun(orderKey, runNo, user, opRun) {
+    const seqNo = opRun.operation.seqNo;
+    const [stepSummaryRows, fieldRefSummary] = await Promise.all([
+        getOpRunStepSummary(opRun.id),
+        getOpRunFieldRefSummary(opRun.operationId, opRun.orderRunId, orderKey, runNo),
+    ]);
+    return {
+        id: opRun.id,
+        orderRunId: opRun.orderRunId,
+        operationId: opRun.operationId,
+        seqNo,
+        title: opRun.operation.title,
+        description: opRun.operation.description,
+        workCenterKey: opRun.operation.workCenter?.key ?? null,
+        status: opRun.status,
+        assignedTo: opRun.assignedTo?.username ?? null,
+        cost: opRun.cost,
+        note: opRun.statusNote ?? null,
+        completedAt: formatDate(opRun.completedAt),
+        stepSummary: stepSummaryRows.map((sr) => ({
+            seqNo: sr.step.seqNo,
+            title: sr.step.title,
+            completed: sr.completed,
+        })),
+        ...(fieldRefSummary.length > 0
+            ? {
+                fieldRefSummary,
+            }
+            : {}),
+        ...formatAuditFields(opRun),
+        _links: [
+            ...childItemLinks("/" + opRunResource(orderKey, runNo), seqNo, "Operation Runs", "/orders/" + orderKey + "/runs/" + runNo, "Order Run", "OperationRun", "run"),
+            {
+                rel: "steps",
+                href: `${API_PREFIX}/${opRunResource(orderKey, runNo)}/${seqNo}/steps`,
+                title: "Step Runs",
+            },
+            {
+                rel: "labor",
+                href: `${API_PREFIX}/${opRunResource(orderKey, runNo)}/${seqNo}/labor`,
+                title: "Labor Tickets",
+            },
+            {
+                rel: "comments",
+                href: `${API_PREFIX}/${opRunResource(orderKey, runNo)}/${seqNo}/comments`,
+                title: "Comments",
+            },
+        ],
+        _actions: await opRunItemActions(orderKey, runNo, seqNo, opRun.id, opRun.operationId, opRun.status, user),
+    };
+}
+export async function formatOpRunTransition(orderKey, runNo, user, opRun) {
+    const seqNo = opRun.operation.seqNo;
+    return {
+        id: opRun.id,
+        status: opRun.status,
+        assignedTo: opRun.assignedTo?.username ?? null,
+        cost: opRun.cost,
+        note: opRun.statusNote ?? null,
+        completedAt: formatDate(opRun.completedAt),
+        ...formatAuditFields(opRun),
+        _actions: await opRunItemActions(orderKey, runNo, seqNo, opRun.id, opRun.operationId, opRun.status, user),
+    };
+}
+function formatListOpRun(opRun) {
+    const seqNo = opRun.operation.seqNo;
+    return {
+        id: opRun.id,
+        orderRunId: opRun.orderRunId,
+        operationId: opRun.operationId,
+        seqNo,
+        title: opRun.operation.title,
+        description: opRun.operation.description,
+        workCenterKey: opRun.operation.workCenter?.key ?? null,
+        status: opRun.status,
+        assignedTo: opRun.assignedTo?.username ?? null,
+        cost: opRun.cost,
+        note: opRun.statusNote ?? null,
+        completedAt: formatDate(opRun.completedAt),
+        ...formatAuditFields(opRun),
+        stepCount: opRun._count.stepRuns,
+        predecessors: opRun.operation.predecessors.map((d) => ({
+            seqNo: d.predecessor.seqNo,
+            title: d.predecessor.title,
+        })),
+    };
+}
+export default function operationRunRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List operation runs for an order run",
+            tags: ["Operation Runs"],
+            params: RunNoParamsSchema,
+            response: {
+                200: OperationRunListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, runNo } = request.params;
+            const resolved = await resolveOrderRun(orderKey, runNo);
+            if (!resolved) {
+                return notFound(reply, `Order run not found`);
+            }
+            const items = await listOpRuns(resolved.run.id);
+            return {
+                items: items.map((opRun) => formatListOpRun(opRun)),
+                total: items.length,
+                _links: [selfLink(`/${opRunResource(orderKey, runNo)}`)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/orders/${orderKey}/runs/${runNo}/ops/{seqNo}`,
+                    },
+                ],
+            };
+        },
+    });
+    // GET by seqNo
+    app.get("/:seqNo", {
+        schema: {
+            description: "Get a single operation run by operation sequence number",
+            tags: ["Operation Runs"],
+            params: SeqNoParamsSchema,
+            response: {
+                200: OperationRunSchema,
+                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 opRun = await getOpRun(resolved.opRun.id);
+            if (!opRun) {
+                return notFound(reply, `Operation run not found`);
+            }
+            return formatOpRun(orderKey, runNo, request.erpUser, opRun);
+        },
+    });
+    // UPDATE (pending/in_progress only)
+    app.put("/:seqNo", {
+        schema: {
+            description: "Update an operation run (pending or in_progress status only)",
+            tags: ["Operation Runs"],
+            params: SeqNoParamsSchema,
+            body: UpdateOperationRunSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, `Operation run not found`);
+            const orderErr = checkOrderRunStarted(resolved.run.status);
+            if (orderErr)
+                return conflict(reply, orderErr);
+            const statusErr = validateStatusFor("update", resolved.opRun.status, [
+                OperationRunStatus.pending,
+                OperationRunStatus.in_progress,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const opRun = await updateOpRun(resolved.opRun.id, request.body, userId);
+            if (wantsFullResponse(request)) {
+                useFullSerializer(reply);
+                return formatOpRun(orderKey, runNo, request.erpUser, opRun);
+            }
+            return {
+                _actions: await opRunItemActions(orderKey, runNo, seqNo, opRun.id, opRun.operationId, opRun.status, request.erpUser),
+            };
+        },
+    });
+}
+//# sourceMappingURL=operation-runs.js.map

package/dist/routes/operations.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+export default function operationRoutes(fastify: FastifyInstance): void;
+//# sourceMappingURL=operations.d.ts.map