@naisys/erp 3.0.0-beta.3

package/dist/routes/order-revisions.js

@@ -0,0 +1,327 @@
+import { CreateOrderRevisionSchema, ErrorResponseSchema, MutateResponseSchema, OrderRevisionListQuerySchema, OrderRevisionListResponseSchema, OrderRevisionSchema, RevisionCreateResponseSchema, RevisionDiffQuerySchema, RevisionDiffResponseSchema, RevisionStatus, UpdateOrderRevisionSchema, } 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, paginationLinks } from "../hateoas.js";
+import { childItemLinks, formatAuditFields, mutationResult, permGate, resolveActions, resolveOrder, } from "../route-helpers.js";
+import { checkHasOrderRuns, createRevision, deleteRevision, findExisting, getRevision, getRevisionOpSummary, listRevisions, updateRevision, validateDraftStatus, } from "../services/order-revision-service.js";
+import { diffRevisions } from "../services/revision-diff-service.js";
+export function revisionItemActions(parentResource, orderKey, revNo, status, user) {
+    const href = `${API_PREFIX}/${parentResource}/${orderKey}/revs/${revNo}`;
+    return resolveActions([
+        {
+            rel: "update",
+            method: "PUT",
+            title: "Update",
+            schema: `${API_PREFIX}/schemas/UpdateOrderRevision`,
+            permission: "order_planner",
+            statuses: [RevisionStatus.draft, RevisionStatus.approved],
+            disabledWhen: (ctx) => ctx.status === RevisionStatus.approved
+                ? "Revision is no longer in draft"
+                : null,
+        },
+        {
+            rel: "approve",
+            path: "/approve",
+            method: "POST",
+            title: "Approve",
+            permission: "order_planner",
+            statuses: [RevisionStatus.draft, RevisionStatus.approved],
+            disabledWhen: (ctx) => ctx.status === RevisionStatus.approved
+                ? "Revision has already been approved"
+                : null,
+        },
+        {
+            rel: "delete",
+            method: "DELETE",
+            title: "Delete",
+            permission: "order_planner",
+            statuses: [RevisionStatus.draft],
+            hideWithoutPermission: true,
+        },
+        {
+            rel: "cut-order",
+            href: `${API_PREFIX}/orders/${orderKey}/runs`,
+            method: "POST",
+            title: "Cut Order",
+            schema: `${API_PREFIX}/schemas/CreateOrderRun`,
+            permission: "order_manager",
+            statuses: [RevisionStatus.draft, RevisionStatus.approved],
+            disabledWhen: (ctx) => ctx.status === RevisionStatus.draft
+                ? "Revision must be approved before cutting an order run"
+                : null,
+        },
+        {
+            rel: "obsolete",
+            path: "/obsolete",
+            method: "POST",
+            title: "Mark Obsolete",
+            permission: "order_planner",
+            statuses: [RevisionStatus.draft, RevisionStatus.approved],
+            disabledWhen: (ctx) => ctx.status === RevisionStatus.draft
+                ? "Revision must be approved before marking obsolete"
+                : null,
+        },
+    ], href, { status, user });
+}
+const PARENT_RESOURCE = "orders";
+const OrderKeyParamsSchema = z.object({
+    orderKey: z.string(),
+});
+export const RevNoParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+});
+export async function formatRevision(orderKey, user, revision) {
+    const opSummaryRows = await getRevisionOpSummary(revision.id);
+    return {
+        id: revision.id,
+        orderId: revision.orderId,
+        revNo: revision.revNo,
+        status: revision.status,
+        description: revision.description,
+        changeSummary: revision.changeSummary,
+        itemKey: revision.order?.item?.key ?? null,
+        operationSummary: opSummaryRows.map((op) => ({
+            seqNo: op.seqNo,
+            title: op.title,
+        })),
+        ...formatAuditFields(revision),
+        _links: [
+            ...childItemLinks(`/${PARENT_RESOURCE}/${orderKey}/revs`, revision.revNo, "Revisions", `/${PARENT_RESOURCE}/${orderKey}`, "Order", "OrderRevision"),
+            {
+                rel: "operations",
+                href: `${API_PREFIX}/${PARENT_RESOURCE}/${orderKey}/revs/${revision.revNo}/ops`,
+                title: "Operations",
+            },
+        ],
+        _actions: revisionItemActions(PARENT_RESOURCE, orderKey, revision.revNo, revision.status, user),
+    };
+}
+function formatListRevision(orderKey, user, revision) {
+    return {
+        id: revision.id,
+        orderId: revision.orderId,
+        revNo: revision.revNo,
+        status: revision.status,
+        description: revision.description,
+        changeSummary: revision.changeSummary,
+        itemKey: revision.order?.item?.key ?? null,
+        ...formatAuditFields(revision),
+        _actions: revisionItemActions(PARENT_RESOURCE, orderKey, revision.revNo, revision.status, user),
+    };
+}
+export default function orderRevisionRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List revisions for an order",
+            tags: ["Order Revisions"],
+            params: OrderKeyParamsSchema,
+            querystring: OrderRevisionListQuerySchema,
+            response: {
+                200: OrderRevisionListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey } = request.params;
+            const { page, pageSize, status, includeObsolete } = request.query;
+            const order = await resolveOrder(orderKey);
+            if (!order) {
+                return notFound(reply, `Order '${orderKey}' not found`);
+            }
+            const where = {};
+            if (status) {
+                where.status = status;
+            }
+            else if (!includeObsolete) {
+                where.status = { not: RevisionStatus.obsolete };
+            }
+            const [items, total] = await listRevisions(order.id, where, page, pageSize);
+            const revBasePath = `${PARENT_RESOURCE}/${orderKey}/revs`;
+            return {
+                items: items.map((revision) => formatListRevision(orderKey, request.erpUser, revision)),
+                total,
+                page,
+                pageSize,
+                _links: paginationLinks(revBasePath, page, pageSize, total, {
+                    status,
+                    includeObsolete: includeObsolete ? "true" : undefined,
+                }),
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/orders/${orderKey}/revs/{revNo}`,
+                    },
+                ],
+                _actions: [
+                    {
+                        rel: "create",
+                        href: `${API_PREFIX}/${revBasePath}`,
+                        method: "POST",
+                        title: "New Revision",
+                        schema: `${API_PREFIX}/schemas/CreateOrderRevision`,
+                        ...permGate(hasPermission(request.erpUser, "order_planner"), "order_planner"),
+                    },
+                ],
+            };
+        },
+    });
+    // DIFF two revisions
+    app.get("/diff", {
+        schema: {
+            description: "Compare two revisions and return a structured diff",
+            tags: ["Order Revisions"],
+            params: OrderKeyParamsSchema,
+            querystring: RevisionDiffQuerySchema,
+            response: {
+                200: RevisionDiffResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey } = request.params;
+            const { from, to } = request.query;
+            const order = await resolveOrder(orderKey);
+            if (!order) {
+                return notFound(reply, `Order '${orderKey}' not found`);
+            }
+            const diff = await diffRevisions(order.id, from, to);
+            if (!diff) {
+                return notFound(reply, `One or both revisions not found (rev ${from}, rev ${to})`);
+            }
+            return diff;
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Create a new revision for an order",
+            tags: ["Order Revisions"],
+            params: OrderKeyParamsSchema,
+            body: CreateOrderRevisionSchema,
+            response: {
+                201: RevisionCreateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey } = request.params;
+            const { description, changeSummary } = request.body;
+            const userId = request.erpUser.id;
+            const order = await resolveOrder(orderKey);
+            if (!order) {
+                return notFound(reply, `Order '${orderKey}' not found`);
+            }
+            const revision = await createRevision(order.id, { description, changeSummary }, userId);
+            const full = await formatRevision(orderKey, request.erpUser, revision);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                revNo: full.revNo,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // GET by revNo
+    app.get("/:revNo", {
+        schema: {
+            description: "Get a single revision by revision number",
+            tags: ["Order Revisions"],
+            params: RevNoParamsSchema,
+            response: {
+                200: OrderRevisionSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, revNo } = request.params;
+            const order = await resolveOrder(orderKey);
+            if (!order) {
+                return notFound(reply, `Order '${orderKey}' not found`);
+            }
+            const revision = await getRevision(order.id, revNo);
+            if (!revision) {
+                return notFound(reply, `Revision ${revNo} not found for order '${orderKey}'`);
+            }
+            return await formatRevision(orderKey, request.erpUser, revision);
+        },
+    });
+    // UPDATE (draft only)
+    app.put("/:revNo", {
+        schema: {
+            description: "Update a revision (draft status only)",
+            tags: ["Order Revisions"],
+            params: RevNoParamsSchema,
+            body: UpdateOrderRevisionSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo } = request.params;
+            const { description, changeSummary } = request.body;
+            const userId = request.erpUser.id;
+            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}'`);
+            }
+            const statusError = validateDraftStatus(existing.status);
+            if (statusError) {
+                return conflict(reply, statusError);
+            }
+            const revision = await updateRevision(existing.id, { description, changeSummary }, userId);
+            const full = await formatRevision(orderKey, request.erpUser, revision);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE (draft only)
+    app.delete("/:revNo", {
+        schema: {
+            description: "Delete a revision (draft status only)",
+            tags: ["Order Revisions"],
+            params: RevNoParamsSchema,
+            response: {
+                204: z.void(),
+                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}'`);
+            }
+            const statusError = validateDraftStatus(existing.status);
+            if (statusError) {
+                return conflict(reply, statusError);
+            }
+            const runsError = await checkHasOrderRuns(existing.id);
+            if (runsError) {
+                return conflict(reply, runsError);
+            }
+            await deleteRevision(existing.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=order-revisions.js.map

package/dist/routes/order-run-transitions.d.ts

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

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

@@ -0,0 +1,215 @@
+import { CompleteOrderRunSchema, ErrorResponseSchema, OrderRunStatus, OrderRunTransitionSchema, } from "@naisys/erp-shared";
+import { requirePermission } from "../auth-middleware.js";
+import { conflict, notFound, unprocessable } from "../error-handler.js";
+import { resolveOrderRun, useFullSerializer, wantsFullResponse, } from "../route-helpers.js";
+import { checkOpsComplete, completeOrderRun, getReopenTarget, sumOpRunCosts, transitionStatus, validateStatusFor, } from "../services/order-run-service.js";
+import { formatRun, orderRunItemActions, RunNoParamsSchema, } from "./order-runs.js";
+export default function orderRunTransitionRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // START (released -> started)
+    app.post("/:runNo/start", {
+        schema: {
+            description: "Start an order run (released -> started)",
+            tags: ["Order Runs"],
+            params: RunNoParamsSchema,
+            response: {
+                200: OrderRunTransitionSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo } = request.params;
+            const resolved = await resolveOrderRun(orderKey, runNo);
+            if (!resolved) {
+                return notFound(reply, `Order run not found for order '${orderKey}'`);
+            }
+            const statusErr = validateStatusFor("start", resolved.run.status, [
+                OrderRunStatus.released,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const userId = request.erpUser.id;
+            const run = await transitionStatus(resolved.run.id, "start", OrderRunStatus.released, OrderRunStatus.started, userId);
+            if (wantsFullResponse(request)) {
+                useFullSerializer(reply);
+                return formatRun(orderKey, request.erpUser, run);
+            }
+            const itemKey = run.order?.item?.key ?? null;
+            return {
+                status: run.status,
+                _actions: await orderRunItemActions(orderKey, runNo, run.id, run.status, itemKey, request.erpUser),
+            };
+        },
+    });
+    // CLOSE (started -> closed)
+    app.post("/:runNo/close", {
+        schema: {
+            description: "Close an order run (started -> closed)",
+            tags: ["Order Runs"],
+            params: RunNoParamsSchema,
+            response: {
+                200: OrderRunTransitionSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+                422: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo } = request.params;
+            const resolved = await resolveOrderRun(orderKey, runNo);
+            if (!resolved) {
+                return notFound(reply, `Order run not found for order '${orderKey}'`);
+            }
+            const statusErr = validateStatusFor("close", resolved.run.status, [
+                OrderRunStatus.started,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            // Validate all operation runs are completed or skipped
+            const opsErr = await checkOpsComplete(resolved.run.id);
+            if (opsErr)
+                return unprocessable(reply, opsErr);
+            const userId = request.erpUser.id;
+            const cost = await sumOpRunCosts(resolved.run.id);
+            const run = await transitionStatus(resolved.run.id, "close", OrderRunStatus.started, OrderRunStatus.closed, userId, { cost });
+            if (wantsFullResponse(request)) {
+                useFullSerializer(reply);
+                return formatRun(orderKey, request.erpUser, run);
+            }
+            const itemKey = run.order?.item?.key ?? null;
+            return {
+                status: run.status,
+                _actions: await orderRunItemActions(orderKey, runNo, run.id, run.status, itemKey, request.erpUser),
+            };
+        },
+    });
+    // COMPLETE (started -> closed, creates item instance)
+    app.post("/:runNo/complete", {
+        schema: {
+            description: "Complete an order run — creates an item instance and closes the run",
+            tags: ["Order Runs"],
+            params: RunNoParamsSchema,
+            body: CompleteOrderRunSchema,
+            response: {
+                200: OrderRunTransitionSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+                422: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo } = request.params;
+            const resolved = await resolveOrderRun(orderKey, runNo);
+            if (!resolved) {
+                return notFound(reply, `Order run not found for order '${orderKey}'`);
+            }
+            const statusErr = validateStatusFor("complete", resolved.run.status, [
+                OrderRunStatus.started,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            // Validate all operation runs are completed or skipped
+            const opsErr = await checkOpsComplete(resolved.run.id);
+            if (opsErr)
+                return unprocessable(reply, opsErr);
+            const userId = request.erpUser.id;
+            const result = await completeOrderRun(resolved.run.id, resolved.order.id, request.body, userId);
+            if (result.error) {
+                return unprocessable(reply, result.error);
+            }
+            const run = result.run;
+            if (wantsFullResponse(request)) {
+                useFullSerializer(reply);
+                return formatRun(orderKey, request.erpUser, run);
+            }
+            const itemKey = run.order?.item?.key ?? null;
+            return {
+                status: run.status,
+                _actions: await orderRunItemActions(orderKey, runNo, run.id, run.status, itemKey, request.erpUser),
+            };
+        },
+    });
+    // CANCEL (released/started -> cancelled)
+    app.post("/:runNo/cancel", {
+        schema: {
+            description: "Cancel an order run (released/started -> cancelled)",
+            tags: ["Order Runs"],
+            params: RunNoParamsSchema,
+            response: {
+                200: OrderRunTransitionSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo } = request.params;
+            const resolved = await resolveOrderRun(orderKey, runNo);
+            if (!resolved) {
+                return notFound(reply, `Order run not found for order '${orderKey}'`);
+            }
+            const statusErr = validateStatusFor("cancel", resolved.run.status, [
+                OrderRunStatus.released,
+                OrderRunStatus.started,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const userId = request.erpUser.id;
+            const cost = await sumOpRunCosts(resolved.run.id);
+            const run = await transitionStatus(resolved.run.id, "cancel", resolved.run.status, OrderRunStatus.cancelled, userId, cost > 0 ? { cost } : undefined);
+            if (wantsFullResponse(request)) {
+                useFullSerializer(reply);
+                return formatRun(orderKey, request.erpUser, run);
+            }
+            const itemKey = run.order?.item?.key ?? null;
+            return {
+                status: run.status,
+                _actions: await orderRunItemActions(orderKey, runNo, run.id, run.status, itemKey, request.erpUser),
+            };
+        },
+    });
+    // REOPEN (closed -> started, cancelled -> released)
+    app.post("/:runNo/reopen", {
+        schema: {
+            description: "Reopen an order run (closed -> started, cancelled -> released)",
+            tags: ["Order Runs"],
+            params: RunNoParamsSchema,
+            response: {
+                200: OrderRunTransitionSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo } = request.params;
+            const resolved = await resolveOrderRun(orderKey, runNo);
+            if (!resolved) {
+                return notFound(reply, `Order run not found for order '${orderKey}'`);
+            }
+            const statusErr = validateStatusFor("reopen", resolved.run.status, [
+                OrderRunStatus.closed,
+                OrderRunStatus.cancelled,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const reopenTo = getReopenTarget(resolved.run.status);
+            const userId = request.erpUser.id;
+            const run = await transitionStatus(resolved.run.id, "reopen", resolved.run.status, reopenTo, userId);
+            if (wantsFullResponse(request)) {
+                useFullSerializer(reply);
+                return formatRun(orderKey, request.erpUser, run);
+            }
+            const itemKey = run.order?.item?.key ?? null;
+            return {
+                status: run.status,
+                _actions: await orderRunItemActions(orderKey, runNo, run.id, run.status, itemKey, request.erpUser),
+            };
+        },
+    });
+}
+//# sourceMappingURL=order-run-transitions.js.map

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

@@ -0,0 +1,58 @@
+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 OrderRunWithRev } from "../services/order-run-service.js";
+export declare function orderRunItemActions(orderKey: string, runNo: number, runId: number, status: string, itemKey: string | null, user: ErpUser | undefined): Promise<HateoasAction[]>;
+export declare const RunNoParamsSchema: z.ZodObject<{
+    orderKey: z.ZodString;
+    runNo: z.ZodCoercedNumber<unknown>;
+}, z.core.$strip>;
+export declare function formatRun(orderKey: string, user: ErpUser | undefined, run: OrderRunWithRev): 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;
+    runNo: number;
+    orderId: number;
+    orderKey: string;
+    revNo: number;
+    itemKey: string | null;
+    instanceId: number;
+    instanceKey: string;
+    status: import("../generated/prisma/enums.js").OrderRunStatus;
+    priority: import("../generated/prisma/enums.js").OrderRunPriority;
+    cost: number | null;
+    dueAt: string | null;
+    releaseNote: string | null;
+    operationSummary: {
+        seqNo: number;
+        title: string;
+        status: import("../generated/prisma/enums.js").OperationRunStatus;
+    }[];
+}>;
+export default function orderRunRoutes(fastify: FastifyInstance): void;
+//# sourceMappingURL=order-runs.d.ts.map