@naisys/erp 3.0.0-beta.10

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.js

@@ -0,0 +1,283 @@
+import { CreateOperationSchema, ErrorResponseSchema, MutateResponseSchema, OperationListResponseSchema, OperationSchema, RevisionStatus, SeqNoCreateResponseSchema, UpdateOperationSchema, } 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 { calcNextSeqNo, childItemLinks, draftCrudActions, formatAuditFields, mutationResult, permGate, resolveRevision, } from "../route-helpers.js";
+import { createOperation, deleteOperation, findExisting, getOperation, listOperations, updateOperation, } from "../services/operation-service.js";
+import { findWorkCenterByKey } from "../services/work-center-service.js";
+/** Resolve an optional workCenterKey to a workCenterId. Returns undefined (skip), null (clear), or the ID. */
+async function resolveWorkCenterId(workCenterKey) {
+    if (workCenterKey === undefined)
+        return { id: undefined };
+    if (workCenterKey === null)
+        return { id: null };
+    const wc = await findWorkCenterByKey(workCenterKey);
+    if (!wc)
+        return { error: `Work center '${workCenterKey}' not found` };
+    return { id: wc.id };
+}
+const ParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+});
+const OpParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+function opBasePath(orderKey, revNo) {
+    return `/orders/${orderKey}/revs/${revNo}/ops`;
+}
+function formatOperation(orderKey, revNo, revStatus, user, operation, summary) {
+    const base = opBasePath(orderKey, revNo);
+    return {
+        id: operation.id,
+        orderRevId: operation.orderRevId,
+        seqNo: operation.seqNo,
+        title: operation.title,
+        description: operation.description,
+        workCenterKey: operation.workCenter?.key ?? null,
+        ...(summary?.stepCount !== undefined
+            ? { stepCount: summary.stepCount }
+            : {}),
+        ...(summary?.stepSummary ? { stepSummary: summary.stepSummary } : {}),
+        ...(summary?.predecessors ? { predecessors: summary.predecessors } : {}),
+        ...formatAuditFields(operation),
+        _links: [
+            ...childItemLinks(base, operation.seqNo, "Operations", `/orders/${orderKey}/revs/${revNo}`, "Revision", "Operation"),
+            {
+                rel: "steps",
+                href: `${API_PREFIX}${base}/${operation.seqNo}/steps`,
+                title: "Steps",
+            },
+            {
+                rel: "dependencies",
+                href: `${API_PREFIX}${base}/${operation.seqNo}/deps`,
+                title: "Dependencies",
+            },
+            ...(operation.workCenter
+                ? [
+                    {
+                        rel: "workCenter",
+                        href: `${API_PREFIX}/work-centers/${operation.workCenter.key}`,
+                        title: "Work Center",
+                    },
+                ]
+                : []),
+        ],
+        _actions: draftCrudActions(`${API_PREFIX}${base}/${operation.seqNo}`, "UpdateOperation", revStatus, user),
+    };
+}
+export default function operationRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List operations for a revision",
+            tags: ["Operations"],
+            params: ParamsSchema,
+            response: {
+                200: OperationListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, revNo } = request.params;
+            const resolved = await resolveRevision(orderKey, revNo);
+            if (!resolved) {
+                return notFound(reply, `Revision not found`);
+            }
+            const items = await listOperations(resolved.rev.id);
+            const maxSeq = items.length > 0 ? items[items.length - 1].seqNo : 0;
+            const user = request.erpUser;
+            const base = opBasePath(orderKey, revNo);
+            return {
+                items: items.map((operation) => {
+                    const formatted = formatOperation(orderKey, revNo, resolved.rev.status, user, operation, {
+                        stepCount: operation._count.steps,
+                        predecessors: operation.predecessors.map((d) => ({
+                            seqNo: d.predecessor.seqNo,
+                            title: d.predecessor.title,
+                        })),
+                    });
+                    const { _links, ...rest } = formatted;
+                    return rest;
+                }),
+                total: items.length,
+                nextSeqNo: calcNextSeqNo(maxSeq),
+                _links: [selfLink(base)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/orders/${orderKey}/revs/${revNo}/ops/{seqNo}`,
+                    },
+                ],
+                _actions: [
+                    {
+                        rel: "create",
+                        href: `${API_PREFIX}${base}`,
+                        method: "POST",
+                        title: "Add Operation",
+                        schema: `${API_PREFIX}/schemas/CreateOperation`,
+                        ...(!hasPermission(user, "order_planner")
+                            ? permGate(false, "order_planner")
+                            : resolved.rev.status !== RevisionStatus.draft
+                                ? {
+                                    disabled: true,
+                                    disabledReason: "Can only add operations in draft revisions",
+                                }
+                                : {}),
+                    },
+                ],
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Create an operation for a revision",
+            tags: ["Operations"],
+            params: ParamsSchema,
+            body: CreateOperationSchema,
+            response: {
+                201: SeqNoCreateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo } = request.params;
+            const { seqNo: requestedSeqNo, title, description, workCenterKey, predecessorSeqNos, } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveRevision(orderKey, revNo);
+            if (!resolved) {
+                return notFound(reply, `Revision not found`);
+            }
+            if (resolved.rev.status !== RevisionStatus.draft) {
+                return conflict(reply, `Cannot add operations to a ${resolved.rev.status} revision`);
+            }
+            const wcResult = await resolveWorkCenterId(workCenterKey);
+            if ("error" in wcResult) {
+                return notFound(reply, wcResult.error);
+            }
+            const operation = await createOperation(resolved.rev.id, requestedSeqNo, title, description, wcResult.id, predecessorSeqNos, userId);
+            const full = formatOperation(orderKey, revNo, resolved.rev.status, request.erpUser, operation, {
+                stepCount: operation._count.steps,
+                predecessors: operation.predecessors.map((d) => ({
+                    seqNo: d.predecessor.seqNo,
+                    title: d.predecessor.title,
+                })),
+            });
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                seqNo: full.seqNo,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // GET by seqNo
+    app.get("/:seqNo", {
+        schema: {
+            description: "Get an operation by sequence number",
+            tags: ["Operations"],
+            params: OpParamsSchema,
+            response: {
+                200: OperationSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const resolved = await resolveRevision(orderKey, revNo);
+            if (!resolved) {
+                return notFound(reply, `Revision not found`);
+            }
+            const operation = await getOperation(resolved.rev.id, seqNo);
+            if (!operation) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            return formatOperation(orderKey, revNo, resolved.rev.status, request.erpUser, operation, {
+                stepCount: operation.steps.length,
+                stepSummary: operation.steps.map((s) => ({
+                    seqNo: s.seqNo,
+                    title: s.title,
+                })),
+            });
+        },
+    });
+    // UPDATE (draft only)
+    app.put("/:seqNo", {
+        schema: {
+            description: "Update an operation (draft revision only)",
+            tags: ["Operations"],
+            params: OpParamsSchema,
+            body: UpdateOperationSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const { title, description, workCenterKey, seqNo: newSeqNo, } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveRevision(orderKey, revNo);
+            if (!resolved) {
+                return notFound(reply, `Revision not found`);
+            }
+            if (resolved.rev.status !== RevisionStatus.draft) {
+                return conflict(reply, `Cannot update operations on a ${resolved.rev.status} revision`);
+            }
+            const existing = await findExisting(resolved.rev.id, seqNo);
+            if (!existing) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            const wcResult = await resolveWorkCenterId(workCenterKey);
+            if ("error" in wcResult) {
+                return notFound(reply, wcResult.error);
+            }
+            const operation = await updateOperation(existing.id, { title, description, workCenterId: wcResult.id, seqNo: newSeqNo }, userId);
+            const full = formatOperation(orderKey, revNo, resolved.rev.status, request.erpUser, operation);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE (draft only)
+    app.delete("/:seqNo", {
+        schema: {
+            description: "Delete an operation (draft revision only)",
+            tags: ["Operations"],
+            params: OpParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const resolved = await resolveRevision(orderKey, revNo);
+            if (!resolved) {
+                return notFound(reply, `Revision not found`);
+            }
+            if (resolved.rev.status !== RevisionStatus.draft) {
+                return conflict(reply, `Cannot delete operations on a ${resolved.rev.status} revision`);
+            }
+            const existing = await findExisting(resolved.rev.id, seqNo);
+            if (!existing) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            await deleteOperation(existing.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=operations.js.map

package/dist/routes/order-revision-transitions.js

@@ -0,0 +1,86 @@
+import { ErrorResponseSchema, OrderRevisionTransitionSchema, RevisionStatus, } from "@naisys/erp-shared";
+import { requirePermission } from "../auth-middleware.js";
+import { conflict, notFound } from "../error-handler.js";
+import { resolveOrder, useFullSerializer, wantsFullResponse, } from "../route-helpers.js";
+import { findExisting, transitionStatus, } from "../services/order-revision-service.js";
+import { formatRevision, revisionItemActions, RevNoParamsSchema, } from "./order-revisions.js";
+export default function orderRevisionTransitionRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // APPROVE (draft → approved)
+    app.post("/:revNo/approve", {
+        schema: {
+            description: "Approve a draft revision",
+            tags: ["Order Revisions"],
+            params: RevNoParamsSchema,
+            response: {
+                200: OrderRevisionTransitionSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo } = request.params;
+            const order = await resolveOrder(orderKey);
+            if (!order) {
+                return notFound(reply, `Order '${orderKey}' not found`);
+            }
+            const existing = await findExisting(order.id, revNo);
+            if (!existing) {
+                return notFound(reply, `Revision ${revNo} not found for order '${orderKey}'`);
+            }
+            if (existing.status !== RevisionStatus.draft) {
+                return conflict(reply, `Cannot approve revision in ${existing.status} status`);
+            }
+            const userId = request.erpUser.id;
+            const revision = await transitionStatus(existing.id, "approve", RevisionStatus.draft, RevisionStatus.approved, userId);
+            if (wantsFullResponse(request)) {
+                useFullSerializer(reply);
+                return await formatRevision(orderKey, request.erpUser, revision);
+            }
+            return {
+                status: revision.status,
+                _actions: revisionItemActions("orders", orderKey, revNo, revision.status, request.erpUser),
+            };
+        },
+    });
+    // OBSOLETE (approved → obsolete)
+    app.post("/:revNo/obsolete", {
+        schema: {
+            description: "Mark an approved revision as obsolete",
+            tags: ["Order Revisions"],
+            params: RevNoParamsSchema,
+            response: {
+                200: OrderRevisionTransitionSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo } = request.params;
+            const order = await resolveOrder(orderKey);
+            if (!order) {
+                return notFound(reply, `Order '${orderKey}' not found`);
+            }
+            const existing = await findExisting(order.id, revNo);
+            if (!existing) {
+                return notFound(reply, `Revision ${revNo} not found for order '${orderKey}'`);
+            }
+            if (existing.status !== RevisionStatus.approved) {
+                return conflict(reply, `Cannot mark revision as obsolete from ${existing.status} status`);
+            }
+            const userId = request.erpUser.id;
+            const revision = await transitionStatus(existing.id, "obsolete", RevisionStatus.approved, RevisionStatus.obsolete, userId);
+            if (wantsFullResponse(request)) {
+                useFullSerializer(reply);
+                return await formatRevision(orderKey, request.erpUser, revision);
+            }
+            return {
+                status: revision.status,
+                _actions: revisionItemActions("orders", orderKey, revNo, revision.status, request.erpUser),
+            };
+        },
+    });
+}
+//# sourceMappingURL=order-revision-transitions.js.map