@naisys/erp 3.0.0-beta.3

package/dist/routes/order-runs.js

@@ -0,0 +1,335 @@
+import { CreateOrderRunSchema, ErrorResponseSchema, MutateResponseSchema, OrderRunListQuerySchema, OrderRunListResponseSchema, OrderRunSchema, OrderRunStatus, RunCreateResponseSchema, UpdateOrderRunSchema, } 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, resolveActions, resolveOrder, resolveOrderRun, } from "../route-helpers.js";
+import { checkOpsComplete, createOrderRun, deleteOrderRun, findLatestApprovedRevision, findOrderRevision, getOrderRun, getOrderRunOpSummary, listOrderRuns, updateOrderRun, validateStatusFor, } from "../services/order-run-service.js";
+function runResource(orderKey) {
+    return `orders/${orderKey}/runs`;
+}
+export async function orderRunItemActions(orderKey, runNo, runId, status, itemKey, user) {
+    const href = `${API_PREFIX}/${runResource(orderKey)}/${runNo}`;
+    const isExecutor = hasPermission(user, "order_executor");
+    const opsErr = isExecutor && status === OrderRunStatus.started
+        ? await checkOpsComplete(runId)
+        : null;
+    return resolveActions([
+        {
+            rel: "start",
+            path: "/start",
+            method: "POST",
+            title: "Start",
+            permission: "order_executor",
+            statuses: [OrderRunStatus.released],
+        },
+        {
+            rel: "complete",
+            path: "/complete",
+            method: "POST",
+            title: "Complete",
+            schema: `${API_PREFIX}/schemas/CompleteOrderRun`,
+            permission: "order_executor",
+            statuses: [OrderRunStatus.started],
+            visibleWhen: (ctx) => !!ctx.itemKey,
+            disabledWhen: (ctx) => ctx.opsErr,
+        },
+        {
+            rel: "close",
+            path: "/close",
+            method: "POST",
+            title: "Close",
+            permission: "order_executor",
+            statuses: [OrderRunStatus.started],
+            visibleWhen: (ctx) => !ctx.itemKey,
+            disabledWhen: (ctx) => ctx.opsErr,
+        },
+        {
+            rel: "update",
+            method: "PUT",
+            title: "Update",
+            schema: `${API_PREFIX}/schemas/UpdateOrderRun`,
+            permission: "order_manager",
+            statuses: [OrderRunStatus.released, OrderRunStatus.started],
+        },
+        {
+            rel: "cancel",
+            path: "/cancel",
+            method: "POST",
+            title: "Cancel",
+            permission: "order_manager",
+            statuses: [OrderRunStatus.released, OrderRunStatus.started],
+        },
+        {
+            rel: "delete",
+            method: "DELETE",
+            title: "Delete",
+            permission: "order_manager",
+            statuses: [OrderRunStatus.released],
+        },
+        {
+            rel: "reopen",
+            path: "/reopen",
+            method: "POST",
+            title: "Reopen",
+            permission: "order_manager",
+            statuses: [OrderRunStatus.closed, OrderRunStatus.cancelled],
+        },
+    ], href, { status, user, itemKey, opsErr });
+}
+const OrderKeyParamsSchema = z.object({
+    orderKey: z.string(),
+});
+export const RunNoParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+});
+export async function formatRun(orderKey, user, run) {
+    const itemKey = run.order?.item?.key ?? null;
+    const instance = run.itemInstances[0] ?? null;
+    const links = [
+        ...childItemLinks("/" + runResource(orderKey), run.runNo, "Runs", "/orders/" + orderKey, "Order", "OrderRun", "order"),
+        {
+            rel: "operations",
+            href: `${API_PREFIX}/${runResource(orderKey)}/${run.runNo}/ops`,
+            title: "Operation Runs",
+        },
+    ];
+    if (itemKey) {
+        links.push({
+            rel: "completion-fields",
+            href: `${API_PREFIX}/items/${itemKey}/fields`,
+            title: "Completion Fields",
+        });
+    }
+    if (instance) {
+        links.push({
+            rel: "itemInstance",
+            href: `${API_PREFIX}/items/${itemKey}/instances/${instance.id}`,
+            title: "Item Instance",
+        });
+    }
+    const opSummaryRows = await getOrderRunOpSummary(run.id);
+    return {
+        id: run.id,
+        runNo: run.runNo,
+        orderId: run.orderId,
+        orderKey,
+        revNo: run.orderRev.revNo,
+        itemKey,
+        instanceId: instance?.id ?? null,
+        instanceKey: instance?.key ?? null,
+        status: run.status,
+        priority: run.priority,
+        cost: run.cost,
+        dueAt: run.dueAt,
+        releaseNote: run.releaseNote,
+        operationSummary: opSummaryRows.map((r) => ({
+            seqNo: r.operation.seqNo,
+            title: r.operation.title,
+            status: r.status,
+        })),
+        ...formatAuditFields(run),
+        _links: links,
+        _actions: await orderRunItemActions(orderKey, run.runNo, run.id, run.status, itemKey, user),
+    };
+}
+function formatListRun(orderKey, run) {
+    const itemKey = run.order?.item?.key ?? null;
+    const instance = run.itemInstances[0] ?? null;
+    return {
+        id: run.id,
+        runNo: run.runNo,
+        orderId: run.orderId,
+        orderKey,
+        revNo: run.orderRev.revNo,
+        itemKey,
+        instanceId: instance?.id ?? null,
+        instanceKey: instance?.key ?? null,
+        status: run.status,
+        priority: run.priority,
+        cost: run.cost,
+        dueAt: run.dueAt,
+        releaseNote: run.releaseNote,
+        ...formatAuditFields(run),
+    };
+}
+export default function orderRunRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List order runs for an order",
+            tags: ["Order Runs"],
+            params: OrderKeyParamsSchema,
+            querystring: OrderRunListQuerySchema,
+            response: {
+                200: OrderRunListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey } = request.params;
+            const { page, pageSize, status, priority, search } = request.query;
+            const order = await resolveOrder(orderKey);
+            if (!order) {
+                return notFound(reply, `Order '${orderKey}' not found`);
+            }
+            const where = { orderId: order.id };
+            if (status)
+                where.status = status;
+            if (priority)
+                where.priority = priority;
+            if (search) {
+                where.OR = [{ releaseNote: { contains: search } }];
+            }
+            const { items, total } = await listOrderRuns(where, page, pageSize);
+            const resource = runResource(orderKey);
+            return {
+                items: items.map((run) => formatListRun(orderKey, run)),
+                total,
+                page,
+                pageSize,
+                _links: paginationLinks(resource, page, pageSize, total, {
+                    status,
+                    priority,
+                    search,
+                }),
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/orders/${orderKey}/runs/{runNo}`,
+                    },
+                ],
+            };
+        },
+    });
+    // CREATE (cut order)
+    app.post("/", {
+        schema: {
+            description: "Create a new order run for an order",
+            tags: ["Order Runs"],
+            params: OrderKeyParamsSchema,
+            body: CreateOrderRunSchema,
+            response: {
+                201: RunCreateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { orderKey } = request.params;
+            const { revNo, priority, dueAt, releaseNote } = request.body;
+            const userId = request.erpUser.id;
+            const order = await resolveOrder(orderKey);
+            if (!order) {
+                return notFound(reply, `Order '${orderKey}' not found`);
+            }
+            const orderId = order.id;
+            // Resolve revision: explicit revNo or latest approved
+            const orderRev = revNo
+                ? await findOrderRevision(orderId, revNo)
+                : await findLatestApprovedRevision(orderId);
+            if (!orderRev) {
+                return notFound(reply, revNo
+                    ? `Order revision ${revNo} not found for order '${orderKey}'`
+                    : `No approved revision found for order '${orderKey}'`);
+            }
+            const run = await createOrderRun(orderId, orderRev.id, { priority, dueAt, releaseNote }, userId);
+            const full = await formatRun(orderKey, request.erpUser, run);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                runNo: full.runNo,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // GET by runNo
+    app.get("/:runNo", {
+        schema: {
+            description: "Get a single order run by run number",
+            tags: ["Order Runs"],
+            params: RunNoParamsSchema,
+            response: {
+                200: OrderRunSchema,
+                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 for order '${orderKey}'`);
+            }
+            const run = await getOrderRun(resolved.run.id);
+            if (!run) {
+                return notFound(reply, `Order run not found`);
+            }
+            return formatRun(orderKey, request.erpUser, run);
+        },
+    });
+    // UPDATE (released/started only)
+    app.put("/:runNo", {
+        schema: {
+            description: "Update an order run (released or started status only)",
+            tags: ["Order Runs"],
+            params: RunNoParamsSchema,
+            body: UpdateOrderRunSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo } = request.params;
+            const data = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOrderRun(orderKey, runNo);
+            if (!resolved) {
+                return notFound(reply, `Order run not found for order '${orderKey}'`);
+            }
+            const statusErr = validateStatusFor("update", resolved.run.status, [
+                OrderRunStatus.released,
+                OrderRunStatus.started,
+            ]);
+            if (statusErr)
+                return conflict(reply, statusErr);
+            const run = await updateOrderRun(resolved.run.id, data, userId);
+            const full = await formatRun(orderKey, request.erpUser, run);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE (released only)
+    app.delete("/:runNo", {
+        schema: {
+            description: "Delete an order run (released status only)",
+            tags: ["Order Runs"],
+            params: RunNoParamsSchema,
+            response: {
+                204: z.void(),
+                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}'`);
+            }
+            if (resolved.run.status !== OrderRunStatus.released) {
+                return conflict(reply, `Cannot delete order run in ${resolved.run.status} status`);
+            }
+            await deleteOrderRun(resolved.run.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=order-runs.js.map

package/dist/routes/orders.d.ts

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

package/dist/routes/orders.js

@@ -0,0 +1,262 @@
+import { CreateOrderSchema, ErrorResponseSchema, KeyCreateResponseSchema, MutateResponseSchema, OrderListQuerySchema, OrderListResponseSchema, OrderSchema, OrderStatus, UpdateOrderSchema, } 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, collectionLink, paginationLinks, schemaLink, selfLink, } from "../hateoas.js";
+import { formatAuditFields, mutationResult, permGate, resolveActions, } from "../route-helpers.js";
+import { checkHasRevisions, createOrder, deleteOrder, findExisting, listOrders, resolveItemKey, updateOrder, } from "../services/order-service.js";
+function orderLinks(resource, key, schemaName) {
+    return [
+        selfLink(`/${resource}/${key}`),
+        collectionLink(resource),
+        schemaLink(schemaName),
+    ];
+}
+function orderActions(resource, key, status, user) {
+    const href = `${API_PREFIX}/${resource}/${key}`;
+    return resolveActions([
+        {
+            rel: "update",
+            method: "PUT",
+            title: "Update",
+            schema: `${API_PREFIX}/schemas/UpdateOrder`,
+            permission: "order_planner",
+        },
+        {
+            rel: "archive",
+            method: "PUT",
+            title: "Archive",
+            body: { status: OrderStatus.archived },
+            permission: "order_planner",
+            statuses: [OrderStatus.active],
+        },
+        {
+            rel: "activate",
+            method: "PUT",
+            title: "Activate",
+            body: { status: OrderStatus.active },
+            permission: "order_planner",
+            statuses: [OrderStatus.archived],
+        },
+        {
+            rel: "delete",
+            method: "DELETE",
+            title: "Delete",
+            permission: "order_manager",
+        },
+    ], href, { status, user });
+}
+function revisionCollectionLink(parentResource, key) {
+    return {
+        rel: "revisions",
+        href: `${API_PREFIX}/${parentResource}/${key}/revs`,
+        title: "Revisions",
+    };
+}
+function runsCollectionLink(parentResource, key) {
+    return {
+        rel: "runs",
+        href: `${API_PREFIX}/${parentResource}/${key}/runs`,
+        title: "Order Runs",
+    };
+}
+const RESOURCE = "orders";
+const KeyParamsSchema = z.object({
+    key: z.string(),
+});
+function formatOrder(order, user) {
+    return {
+        id: order.id,
+        key: order.key,
+        description: order.description,
+        status: order.status,
+        itemKey: order.item?.key ?? null,
+        ...formatAuditFields(order),
+        _links: [
+            ...orderLinks(RESOURCE, order.key, "Order"),
+            revisionCollectionLink(RESOURCE, order.key),
+            runsCollectionLink(RESOURCE, order.key),
+        ],
+        _actions: orderActions(RESOURCE, order.key, order.status, user),
+    };
+}
+function formatListOrder(order, user) {
+    const { _actions, ...rest } = formatOrder(order, user);
+    const { _links: _, ...withoutLinks } = rest;
+    return withoutLinks;
+}
+export default function orderRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List orders with pagination and filtering",
+            tags: ["Orders"],
+            querystring: OrderListQuerySchema,
+            response: {
+                200: OrderListResponseSchema,
+            },
+        },
+        handler: async (request) => {
+            const { page, pageSize, status, search } = request.query;
+            const where = {};
+            if (status)
+                where.status = status;
+            if (search) {
+                where.OR = [
+                    { key: { contains: search } },
+                    { description: { contains: search } },
+                ];
+            }
+            const [items, total] = await listOrders(where, page, pageSize);
+            return {
+                items: items.map((order) => formatListOrder(order, request.erpUser)),
+                total,
+                page,
+                pageSize,
+                _links: paginationLinks(RESOURCE, page, pageSize, total, {
+                    status,
+                    search,
+                }),
+                _linkTemplates: [
+                    { rel: "item", hrefTemplate: `${API_PREFIX}/orders/{key}` },
+                ],
+                _actions: [
+                    {
+                        rel: "create",
+                        href: `${API_PREFIX}/${RESOURCE}`,
+                        method: "POST",
+                        title: "Create Order",
+                        schema: `${API_PREFIX}/schemas/CreateOrder`,
+                        ...permGate(hasPermission(request.erpUser, "order_planner"), "order_planner"),
+                    },
+                ],
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Create a new order",
+            tags: ["Orders"],
+            body: CreateOrderSchema,
+            response: {
+                201: KeyCreateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { key, description, itemKey } = request.body;
+            const userId = request.erpUser.id;
+            let itemId = null;
+            if (itemKey) {
+                try {
+                    itemId = await resolveItemKey(itemKey);
+                }
+                catch {
+                    return notFound(reply, `Item '${itemKey}' not found`);
+                }
+            }
+            const order = await createOrder(key, description, itemId, userId);
+            const full = formatOrder(order, request.erpUser);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                key: full.key,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // GET by key
+    app.get("/:key", {
+        schema: {
+            description: "Get a single order by key",
+            tags: ["Orders"],
+            params: KeyParamsSchema,
+            response: {
+                200: OrderSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const order = await findExisting(key);
+            if (!order) {
+                return notFound(reply, `Order '${key}' not found`);
+            }
+            return formatOrder(order, request.erpUser);
+        },
+    });
+    // UPDATE
+    app.put("/:key", {
+        schema: {
+            description: "Update an order",
+            tags: ["Orders"],
+            params: KeyParamsSchema,
+            body: UpdateOrderSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const { itemKey, ...rest } = request.body;
+            const userId = request.erpUser.id;
+            const existing = await findExisting(key);
+            if (!existing) {
+                return notFound(reply, `Order '${key}' not found`);
+            }
+            const dbData = { ...rest };
+            if (itemKey !== undefined) {
+                if (itemKey === null) {
+                    dbData.itemId = null;
+                }
+                else {
+                    try {
+                        dbData.itemId = await resolveItemKey(itemKey);
+                    }
+                    catch {
+                        return notFound(reply, `Item '${itemKey}' not found`);
+                    }
+                }
+            }
+            const order = await updateOrder(key, dbData, userId);
+            const full = formatOrder(order, request.erpUser);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE
+    app.delete("/:key", {
+        schema: {
+            description: "Delete an order",
+            tags: ["Orders"],
+            params: KeyParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const existing = await findExisting(key);
+            if (!existing) {
+                return notFound(reply, `Order '${key}' not found`);
+            }
+            const hasRevisions = await checkHasRevisions(existing.id);
+            if (hasRevisions) {
+                return conflict(reply, "Cannot delete order with existing revisions. Archive it instead.");
+            }
+            await deleteOrder(key);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=orders.js.map

package/dist/routes/root.d.ts

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