@naisys/erp 3.0.0-beta.6

package/dist/routes/step-runs.js

@@ -0,0 +1,324 @@
+import { ErrorResponseSchema, fieldTypeString, getValueFormatHint, OperationRunStatus, StepRunListQuerySchema, StepRunListResponseSchema, StepRunSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { hasPermission } from "../auth-middleware.js";
+import { notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { checkWorkCenterAccess, childItemLinks, formatAuditFields, resolveActions, resolveOpRun, resolveStepRun, } from "../route-helpers.js";
+import { deserializeFieldValue, validateCompletionFields, validateFieldValue, } from "../services/field-value-service.js";
+import { isUserClockedIn } from "../services/labor-ticket-service.js";
+import { getStepRunWithFields, listStepRuns, listStepRunsWithFields, } from "../services/step-run-service.js";
+export function stepRunResource(orderKey, runNo, seqNo) {
+    return `orders/${orderKey}/runs/${runNo}/ops/${seqNo}/steps`;
+}
+async function stepRunItemActions(orderKey, runNo, seqNo, stepSeqNo, opRunId, operationId, opRunStatus, completed, stepRunId, user) {
+    const href = `${API_PREFIX}/${stepRunResource(orderKey, runNo, seqNo)}/${stepSeqNo}`;
+    const isExecutor = hasPermission(user, "order_executor");
+    const isInProgress = opRunStatus === OperationRunStatus.in_progress;
+    // Pre-compute disabled reasons for complete action
+    const wcErr = user ? await checkWorkCenterAccess(operationId, user) : null;
+    const clockedInErr = isExecutor && isInProgress && !completed
+        ? (await isUserClockedIn(opRunId, user.id))
+            ? null
+            : "You must be clocked in to complete steps"
+        : null;
+    const fieldsErr = isExecutor && isInProgress && !completed
+        ? await (async () => {
+            const existing = await getStepRunWithFields(stepRunId);
+            return existing ? validateCompletionFields(existing) : null;
+        })()
+        : null;
+    return resolveActions([
+        {
+            rel: "complete",
+            path: "/complete",
+            method: "POST",
+            title: "Complete",
+            schema: `${API_PREFIX}/schemas/CompleteStepRun`,
+            body: { note: "" },
+            permission: "order_executor",
+            visibleWhen: () => !completed,
+            disabledWhen: () => !isInProgress
+                ? "Parent operation must be in progress"
+                : (wcErr ?? clockedInErr ?? fieldsErr),
+        },
+        {
+            rel: "reopen",
+            path: "/reopen",
+            method: "POST",
+            title: "Reopen",
+            permission: "order_executor",
+            visibleWhen: () => completed,
+            disabledWhen: () => !isInProgress ? "Parent operation must be in progress" : wcErr,
+        },
+    ], href, { status: opRunStatus, user });
+}
+export function buildStepRunActionTemplates(stepRunHref, canUpdate, multiSet, hasAttachmentFields, hasArrayFields) {
+    if (!canUpdate)
+        return [];
+    // Show array example in body hints when there are array fields
+    const valueHint = hasArrayFields ? [""] : "";
+    const batchValueHint = hasArrayFields
+        ? [
+            { fieldSeqNo: 0, value: "" },
+            { fieldSeqNo: 0, value: [""] },
+        ]
+        : [{ fieldSeqNo: 0, value: "" }];
+    return [
+        {
+            rel: "updateField",
+            hrefTemplate: multiSet
+                ? `${stepRunHref}/sets/{setIndex}/fields/{fieldSeqNo}`
+                : `${stepRunHref}/fields/{fieldSeqNo}`,
+            method: "PUT",
+            title: "Update Field Value",
+            schema: `${API_PREFIX}/schemas/UpdateFieldValue`,
+            body: { value: valueHint },
+        },
+        {
+            rel: "batchUpdateFields",
+            hrefTemplate: multiSet
+                ? `${stepRunHref}/sets/{setIndex}/fields`
+                : `${stepRunHref}/fields`,
+            method: "PUT",
+            title: "Batch Update Field Values",
+            schema: `${API_PREFIX}/schemas/BatchUpdateFieldValues`,
+            body: { fieldValues: batchValueHint },
+        },
+        ...(multiSet
+            ? [
+                {
+                    rel: "deleteSet",
+                    hrefTemplate: `${stepRunHref}/sets/{setIndex}`,
+                    method: "DELETE",
+                    title: "Delete Set",
+                },
+            ]
+            : []),
+        ...(hasAttachmentFields
+            ? [
+                {
+                    rel: "uploadAttachment",
+                    hrefTemplate: multiSet
+                        ? `${stepRunHref}/sets/{setIndex}/fields/{fieldSeqNo}/attachments`
+                        : `${stepRunHref}/fields/{fieldSeqNo}/attachments`,
+                    method: "POST",
+                    title: "Upload Attachment",
+                    alternateEncoding: {
+                        contentType: "multipart/form-data",
+                        description: "Upload file as multipart/form-data with field 'file'",
+                        fileFields: ["file"],
+                    },
+                },
+                {
+                    rel: "downloadAttachment",
+                    hrefTemplate: multiSet
+                        ? `${stepRunHref}/sets/{setIndex}/fields/{fieldSeqNo}/attachments/{attachmentId}`
+                        : `${stepRunHref}/fields/{fieldSeqNo}/attachments/{attachmentId}`,
+                    method: "GET",
+                    title: "Download Attachment",
+                },
+                {
+                    rel: "deleteAttachment",
+                    hrefTemplate: multiSet
+                        ? `${stepRunHref}/sets/{setIndex}/fields/{fieldSeqNo}/attachments/{attachmentId}`
+                        : `${stepRunHref}/fields/{fieldSeqNo}/attachments/{attachmentId}`,
+                    method: "DELETE",
+                    title: "Delete Attachment",
+                },
+            ]
+            : []),
+    ];
+}
+/** Compute just the HATEOAS actions + action templates for a step run */
+export async function computeStepRunHateoas(orderKey, runNo, seqNo, stepSeqNo, opRunId, operationId, opRunStatus, completed, stepRunId, multiSet, hasAttachmentFields, hasArrayFields, user) {
+    const canUpdate = hasPermission(user, "order_executor") &&
+        opRunStatus === OperationRunStatus.in_progress;
+    const stepRunHref = `${API_PREFIX}/${stepRunResource(orderKey, runNo, seqNo)}/${stepSeqNo}`;
+    return {
+        _actions: await stepRunItemActions(orderKey, runNo, seqNo, stepSeqNo, opRunId, operationId, opRunStatus, completed, stepRunId, user),
+        _actionTemplates: buildStepRunActionTemplates(stepRunHref, canUpdate, multiSet, hasAttachmentFields, hasArrayFields),
+    };
+}
+const OpSeqNoParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+const StepSeqNoParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+    stepSeqNo: z.coerce.number().int(),
+});
+export async function formatStepRunTransition(orderKey, runNo, seqNo, opRunId, operationId, opRunStatus, user, stepRun) {
+    const stepSeqNo = stepRun.step.seqNo;
+    const multiSet = stepRun.step.multiSet;
+    const fields = stepRun.step.fieldSet?.fields ?? [];
+    const hasAttachmentFields = fields.some((f) => f.type === "attachment");
+    const hasArrayFields = fields.some((f) => f.isArray);
+    const hateoas = await computeStepRunHateoas(orderKey, runNo, seqNo, stepSeqNo, opRunId, operationId, opRunStatus, stepRun.completed, stepRun.id, multiSet, hasAttachmentFields, hasArrayFields, user);
+    return {
+        id: stepRun.id,
+        completed: stepRun.completed,
+        note: stepRun.statusNote ?? null,
+        ...formatAuditFields(stepRun),
+        ...hateoas,
+    };
+}
+export async function formatStepRunWithFields(orderKey, runNo, seqNo, opRunId, operationId, opRunStatus, user, stepRun) {
+    const stepSeqNo = stepRun.step.seqNo;
+    const multiSet = stepRun.step.multiSet;
+    // Determine how many sets exist
+    const storedFieldValues = stepRun.fieldRecord?.fieldValues ?? [];
+    const maxSetIndex = storedFieldValues.reduce((max, fv) => Math.max(max, fv.setIndex), -1);
+    const setCount = Math.max(1, maxSetIndex + 1);
+    // Merge field definitions with stored values + validation + attachments
+    const fieldValues = [];
+    const stepRunHref = `${API_PREFIX}/${stepRunResource(orderKey, runNo, seqNo)}/${stepSeqNo}`;
+    for (let si = 0; si < setCount; si++) {
+        for (const field of stepRun.step.fieldSet?.fields ?? []) {
+            const stored = storedFieldValues.find((fv) => fv.fieldId === field.id && fv.setIndex === si);
+            const value = deserializeFieldValue(stored?.value ?? "", field.isArray);
+            const setPath = multiSet
+                ? `/sets/${si}/fields/${field.seqNo}`
+                : `/fields/${field.seqNo}`;
+            const attachments = field.type === "attachment" && stored
+                ? stored.fieldAttachments.map((sfa) => ({
+                    id: sfa.attachment.publicId,
+                    filename: sfa.attachment.filename,
+                    fileSize: sfa.attachment.fileSize,
+                    downloadHref: `${stepRunHref}${setPath}/attachments/${sfa.attachment.publicId}`,
+                }))
+                : undefined;
+            const fieldType = fieldTypeString(field.type, field.isArray);
+            fieldValues.push({
+                fieldId: field.id,
+                fieldSeqNo: field.seqNo,
+                label: field.label,
+                type: fieldType,
+                valueFormat: getValueFormatHint(fieldType),
+                required: field.required,
+                setIndex: si,
+                value,
+                attachments,
+                validation: validateFieldValue(field.type, field.isArray, field.required, value),
+            });
+        }
+    }
+    const allFields = stepRun.step.fieldSet?.fields ?? [];
+    const hasAttachmentFields = allFields.some((f) => f.type === "attachment");
+    const hasArrayFields = allFields.some((f) => f.isArray);
+    const hateoas = await computeStepRunHateoas(orderKey, runNo, seqNo, stepSeqNo, opRunId, operationId, opRunStatus, stepRun.completed, stepRun.id, multiSet, hasAttachmentFields, hasArrayFields, user);
+    return {
+        id: stepRun.id,
+        operationRunId: stepRun.operationRunId,
+        stepId: stepRun.stepId,
+        seqNo: stepSeqNo,
+        title: stepRun.step.title,
+        instructions: stepRun.step.instructions,
+        multiSet,
+        completed: stepRun.completed,
+        note: stepRun.statusNote ?? null,
+        fieldCount: stepRun.step.fieldSet?.fields.length ?? 0,
+        fieldValues,
+        ...formatAuditFields(stepRun),
+        _links: childItemLinks("/" + stepRunResource(orderKey, runNo, seqNo), stepSeqNo, "Step Runs", "/orders/" + orderKey + "/runs/" + runNo + "/ops/" + seqNo, "Operation Run", "StepRun", "operationRun"),
+        ...hateoas,
+    };
+}
+function formatListStepRun(stepRun) {
+    const stepSeqNo = stepRun.step.seqNo;
+    const fieldCount = stepRun.step.fieldSet?._count.fields ?? 0;
+    return {
+        id: stepRun.id,
+        operationRunId: stepRun.operationRunId,
+        stepId: stepRun.stepId,
+        seqNo: stepSeqNo,
+        title: stepRun.step.title,
+        instructions: stepRun.step.instructions,
+        multiSet: stepRun.step.multiSet,
+        completed: stepRun.completed,
+        note: stepRun.statusNote ?? null,
+        fieldCount,
+        ...formatAuditFields(stepRun),
+    };
+}
+export default function stepRunRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List step runs for an operation run",
+            tags: ["Step Runs"],
+            params: OpSeqNoParamsSchema,
+            querystring: StepRunListQuerySchema,
+            response: {
+                200: StepRunListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const { includeFields } = request.query;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, `Operation run not found`);
+            }
+            if (includeFields) {
+                const items = await listStepRunsWithFields(resolved.opRun.id);
+                const formatted = await Promise.all(items.map(async (stepRun) => {
+                    const { _links, ...rest } = await formatStepRunWithFields(orderKey, runNo, seqNo, resolved.opRun.id, resolved.opRun.operationId, resolved.opRun.status, request.erpUser, stepRun);
+                    return rest;
+                }));
+                return {
+                    items: formatted,
+                    total: items.length,
+                    _links: [selfLink(`/${stepRunResource(orderKey, runNo, seqNo)}`)],
+                    _linkTemplates: [
+                        {
+                            rel: "item",
+                            hrefTemplate: `${API_PREFIX}/${stepRunResource(orderKey, runNo, seqNo)}/{seqNo}`,
+                        },
+                    ],
+                };
+            }
+            const items = await listStepRuns(resolved.opRun.id);
+            return {
+                items: items.map((stepRun) => formatListStepRun(stepRun)),
+                total: items.length,
+                _links: [selfLink(`/${stepRunResource(orderKey, runNo, seqNo)}`)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/${stepRunResource(orderKey, runNo, seqNo)}/{seqNo}`,
+                    },
+                ],
+            };
+        },
+    });
+    // GET by stepSeqNo
+    app.get("/:stepSeqNo", {
+        schema: {
+            description: "Get a single step run by step sequence number",
+            tags: ["Step Runs"],
+            params: StepSeqNoParamsSchema,
+            response: {
+                200: StepRunSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo, stepSeqNo } = request.params;
+            const resolved = await resolveStepRun(orderKey, runNo, seqNo, stepSeqNo);
+            if (!resolved) {
+                return notFound(reply, `Step run not found`);
+            }
+            const stepRun = await getStepRunWithFields(resolved.stepRun.id);
+            if (!stepRun) {
+                return notFound(reply, `Step run not found`);
+            }
+            return formatStepRunWithFields(orderKey, runNo, seqNo, resolved.opRun.id, resolved.opRun.operationId, resolved.opRun.status, request.erpUser, stepRun);
+        },
+    });
+}
+//# sourceMappingURL=step-runs.js.map

package/dist/routes/steps.js

@@ -0,0 +1,283 @@
+import { BatchCreateStepSchema, BatchSeqNoCreateResponseSchema, CreateStepSchema, ErrorResponseSchema, MutateResponseSchema, RevisionStatus, SeqNoCreateResponseSchema, StepListResponseSchema, StepSchema, UpdateStepSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { 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, resolveActions, resolveOperation, } from "../route-helpers.js";
+import { createStep, createSteps, deleteStep, findExisting, getStep, listSteps, updateStep, } from "../services/step-service.js";
+import { formatFieldListResponse } from "./step-fields.js";
+const ParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+const StepParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+    stepSeqNo: z.coerce.number().int(),
+});
+function stepBasePath(orderKey, revNo, opSeqNo) {
+    return `/orders/${orderKey}/revs/${revNo}/ops/${opSeqNo}/steps`;
+}
+function formatStep(orderKey, revNo, opSeqNo, revStatus, user, step) {
+    return {
+        id: step.id,
+        operationId: step.operationId,
+        seqNo: step.seqNo,
+        title: step.title,
+        instructions: step.instructions,
+        multiSet: step.multiSet,
+        fieldCount: step.fieldSet?.fields.length ?? 0,
+        ...formatAuditFields(step),
+        fields: formatFieldListResponse(orderKey, revNo, opSeqNo, step.seqNo, revStatus, user, step.fieldSet?.fields ?? []),
+        _links: childItemLinks(stepBasePath(orderKey, revNo, opSeqNo), step.seqNo, "Steps", `/orders/${orderKey}/revs/${revNo}/ops/${opSeqNo}`, "Operation", "Step"),
+        _actions: draftCrudActions(`${API_PREFIX}${stepBasePath(orderKey, revNo, opSeqNo)}/${step.seqNo}`, "UpdateStep", revStatus, user),
+    };
+}
+const draftCreateDef = {
+    rel: "create",
+    method: "POST",
+    title: "Add Step",
+    schema: `${API_PREFIX}/schemas/CreateStep`,
+    permission: "order_planner",
+    disabledWhen: (ctx) => ctx.status !== RevisionStatus.draft
+        ? "Can only add steps in draft revisions"
+        : null,
+};
+const draftBatchCreateDef = {
+    rel: "batch-create",
+    path: "/batch",
+    method: "POST",
+    title: "Add Steps (Batch)",
+    schema: `${API_PREFIX}/schemas/BatchCreateStep`,
+    permission: "order_planner",
+    disabledWhen: (ctx) => ctx.status !== RevisionStatus.draft
+        ? "Can only add steps in draft revisions"
+        : null,
+};
+function stepListActions(base, revStatus, user) {
+    return resolveActions([draftCreateDef, draftBatchCreateDef], `${API_PREFIX}${base}`, { status: revStatus, user });
+}
+export default function stepRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List steps for an operation",
+            tags: ["Steps"],
+            params: ParamsSchema,
+            response: {
+                200: StepListResponseSchema,
+                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 listSteps(resolved.operation.id);
+            const maxSeq = items.length > 0 ? items[items.length - 1].seqNo : 0;
+            const user = request.erpUser;
+            const base = stepBasePath(orderKey, revNo, seqNo);
+            return {
+                items: items.map((step) => {
+                    const { _links, ...rest } = formatStep(orderKey, revNo, seqNo, resolved.rev.status, user, step);
+                    return rest;
+                }),
+                total: items.length,
+                nextSeqNo: calcNextSeqNo(maxSeq),
+                _links: [selfLink(base)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}${stepBasePath(orderKey, revNo, seqNo)}/{seqNo}`,
+                    },
+                ],
+                _actions: stepListActions(base, resolved.rev.status, user),
+            };
+        },
+    });
+    // BATCH CREATE
+    app.post("/batch", {
+        schema: {
+            description: "Create multiple steps for an operation in one request",
+            tags: ["Steps"],
+            params: ParamsSchema,
+            body: BatchCreateStepSchema,
+            response: {
+                201: BatchSeqNoCreateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const { items } = 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 steps to a ${resolved.rev.status} revision`);
+            }
+            const created = await createSteps(resolved.operation.id, items, userId);
+            const maxSeq = created.length > 0 ? created[created.length - 1].seqNo : 0;
+            const user = request.erpUser;
+            const base = stepBasePath(orderKey, revNo, seqNo);
+            const full = {
+                items: created.map((step) => {
+                    const { _links, ...rest } = formatStep(orderKey, revNo, seqNo, resolved.rev.status, user, step);
+                    return rest;
+                }),
+                total: created.length,
+                nextSeqNo: calcNextSeqNo(maxSeq),
+                _links: [selfLink(base)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}${stepBasePath(orderKey, revNo, seqNo)}/{seqNo}`,
+                    },
+                ],
+                _actions: [],
+            };
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                items: created.map((s) => ({ id: s.id, seqNo: s.seqNo })),
+                total: created.length,
+                _actions: full._actions,
+            });
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Create a step for an operation",
+            tags: ["Steps"],
+            params: ParamsSchema,
+            body: CreateStepSchema,
+            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, instructions, multiSet, } = 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 steps to a ${resolved.rev.status} revision`);
+            }
+            const step = await createStep(resolved.operation.id, requestedSeqNo, title, instructions, multiSet, userId);
+            const full = formatStep(orderKey, revNo, seqNo, resolved.rev.status, request.erpUser, step);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                seqNo: full.seqNo,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // GET by stepSeqNo
+    app.get("/:stepSeqNo", {
+        schema: {
+            description: "Get a step by sequence number",
+            tags: ["Steps"],
+            params: StepParamsSchema,
+            response: {
+                200: StepSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo, stepSeqNo } = request.params;
+            const resolved = await resolveOperation(orderKey, revNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation not found");
+            }
+            const step = await getStep(resolved.operation.id, stepSeqNo);
+            if (!step) {
+                return notFound(reply, `Step ${stepSeqNo} not found`);
+            }
+            return formatStep(orderKey, revNo, seqNo, resolved.rev.status, request.erpUser, step);
+        },
+    });
+    // UPDATE (draft only)
+    app.put("/:stepSeqNo", {
+        schema: {
+            description: "Update a step (draft revision only)",
+            tags: ["Steps"],
+            params: StepParamsSchema,
+            body: UpdateStepSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo, stepSeqNo } = request.params;
+            const { title, instructions, seqNo: newSeqNo, multiSet } = 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 update steps on a ${resolved.rev.status} revision`);
+            }
+            const existing = await findExisting(resolved.operation.id, stepSeqNo);
+            if (!existing) {
+                return notFound(reply, `Step ${stepSeqNo} not found`);
+            }
+            const step = await updateStep(existing.id, { title, instructions, seqNo: newSeqNo, multiSet }, userId);
+            const full = formatStep(orderKey, revNo, seqNo, resolved.rev.status, request.erpUser, step);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE (draft only)
+    app.delete("/:stepSeqNo", {
+        schema: {
+            description: "Delete a step (draft revision only)",
+            tags: ["Steps"],
+            params: StepParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo, stepSeqNo } = 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 delete steps on a ${resolved.rev.status} revision`);
+            }
+            const existing = await findExisting(resolved.operation.id, stepSeqNo);
+            if (!existing) {
+                return notFound(reply, `Step ${stepSeqNo} not found`);
+            }
+            await deleteStep(existing.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=steps.js.map