@naisys/erp 3.0.0-beta.3

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.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance } from "fastify";
+export default function orderRevisionTransitionRoutes(fastify: FastifyInstance): void;
+//# sourceMappingURL=order-revision-transitions.d.ts.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

package/dist/routes/order-revisions.d.ts

@@ -0,0 +1,51 @@
+import type { HateoasAction } from "@naisys/common";
+import type { FastifyInstance } from "fastify";
+import { z } from "zod/v4";
+import type { ErpUser } from "../auth-middleware.js";
+import { type OrderRevisionWithRelations } from "../services/order-revision-service.js";
+export declare function revisionItemActions(parentResource: string, orderKey: string, revNo: number, status: string, user: ErpUser | undefined): HateoasAction[];
+export declare const RevNoParamsSchema: z.ZodObject<{
+    orderKey: z.ZodString;
+    revNo: z.ZodCoercedNumber<unknown>;
+}, z.core.$strip>;
+export declare function formatRevision(orderKey: string, user: ErpUser | undefined, revision: OrderRevisionWithRelations): 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;
+    id: number;
+    orderId: number;
+    revNo: number;
+    status: import("../generated/prisma/enums.js").RevisionStatus;
+    description: string;
+    changeSummary: string | null;
+    itemKey: string | null;
+    operationSummary: {
+        seqNo: number;
+        title: string;
+    }[];
+}>;
+export default function orderRevisionRoutes(fastify: FastifyInstance): void;
+//# sourceMappingURL=order-revisions.d.ts.map