@naisys/erp 3.0.0-beta.3

package/dist/routes/items.js

@@ -0,0 +1,252 @@
+import { CreateItemSchema, ErrorResponseSchema, ItemListQuerySchema, ItemListResponseSchema, ItemSchema, KeyCreateResponseSchema, MutateResponseSchema, UpdateItemSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { notFound } from "../error-handler.js";
+import { API_PREFIX, collectionLink, paginationLinks, schemaLink, selfLink, } from "../hateoas.js";
+import { calcNextSeqNo, childItemLinks, formatAuditFields, mutationResult, } from "../route-helpers.js";
+import { createItem, deleteItem, findExisting, listItems, updateItem, } from "../services/item-service.js";
+const RESOURCE = "items";
+const KeyParamsSchema = z.object({
+    key: z.string(),
+});
+function itemLinks(key) {
+    return [
+        selfLink(`/${RESOURCE}/${key}`),
+        collectionLink(RESOURCE),
+        schemaLink("Item"),
+    ];
+}
+function itemActions(key, user) {
+    if (!hasPermission(user, "item_manager"))
+        return [];
+    const href = `${API_PREFIX}/${RESOURCE}/${key}`;
+    return [
+        {
+            rel: "update",
+            href,
+            method: "PUT",
+            title: "Update",
+            schema: `${API_PREFIX}/schemas/UpdateItem`,
+        },
+        {
+            rel: "delete",
+            href,
+            method: "DELETE",
+            title: "Delete",
+        },
+    ];
+}
+function formatItemFieldListResponse(itemKey, user, fields) {
+    const maxSeq = fields.length > 0 ? fields[fields.length - 1].seqNo : 0;
+    const base = `/items/${itemKey}/fields`;
+    return {
+        items: fields.map((field) => formatItemField(itemKey, user, field)),
+        total: fields.length,
+        nextSeqNo: calcNextSeqNo(maxSeq),
+        _links: [selfLink(base)],
+        _actions: hasPermission(user, "item_manager")
+            ? [
+                {
+                    rel: "create",
+                    href: `${API_PREFIX}${base}`,
+                    method: "POST",
+                    title: "Add Field",
+                    schema: `${API_PREFIX}/schemas/CreateField`,
+                },
+            ]
+            : [],
+    };
+}
+function formatItemField(itemKey, user, field) {
+    const base = `/items/${itemKey}/fields`;
+    return {
+        id: field.id,
+        fieldSetId: field.fieldSetId,
+        seqNo: field.seqNo,
+        label: field.label,
+        type: field.type,
+        isArray: field.isArray,
+        required: field.required,
+        ...formatAuditFields(field),
+        _links: childItemLinks(base, field.seqNo, "Fields", `/items/${itemKey}`, "Item", "Field"),
+        _actions: hasPermission(user, "item_manager")
+            ? [
+                {
+                    rel: "update",
+                    href: `${API_PREFIX}${base}/${field.seqNo}`,
+                    method: "PUT",
+                    title: "Update",
+                    schema: `${API_PREFIX}/schemas/UpdateField`,
+                },
+                {
+                    rel: "delete",
+                    href: `${API_PREFIX}${base}/${field.seqNo}`,
+                    method: "DELETE",
+                    title: "Delete",
+                },
+            ]
+            : [],
+    };
+}
+function formatItem(item, user) {
+    return {
+        id: item.id,
+        key: item.key,
+        description: item.description,
+        fields: formatItemFieldListResponse(item.key, user, item.fieldSet?.fields ?? []),
+        ...formatAuditFields(item),
+        _links: itemLinks(item.key),
+        _actions: itemActions(item.key, user),
+    };
+}
+function formatListItem(item, user) {
+    return {
+        id: item.id,
+        key: item.key,
+        description: item.description,
+        fields: formatItemFieldListResponse(item.key, user, item.fieldSet?.fields ?? []),
+        ...formatAuditFields(item),
+    };
+}
+export default function itemRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List items with pagination and search",
+            tags: ["Items"],
+            querystring: ItemListQuerySchema,
+            response: {
+                200: ItemListResponseSchema,
+            },
+        },
+        handler: async (request) => {
+            const { page, pageSize, search } = request.query;
+            const where = {};
+            if (search) {
+                where.OR = [
+                    { key: { contains: search } },
+                    { description: { contains: search } },
+                ];
+            }
+            const [items, total] = await listItems(where, page, pageSize);
+            return {
+                items: items.map((item) => formatListItem(item, request.erpUser)),
+                total,
+                page,
+                pageSize,
+                _links: paginationLinks(RESOURCE, page, pageSize, total, { search }),
+                _linkTemplates: [
+                    { rel: "item", hrefTemplate: `${API_PREFIX}/items/{key}` },
+                ],
+                _actions: hasPermission(request.erpUser, "item_manager")
+                    ? [
+                        {
+                            rel: "create",
+                            href: `${API_PREFIX}/${RESOURCE}`,
+                            method: "POST",
+                            title: "Create Item",
+                            schema: `${API_PREFIX}/schemas/CreateItem`,
+                        },
+                    ]
+                    : [],
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Create a new item",
+            tags: ["Items"],
+            body: CreateItemSchema,
+            response: {
+                201: KeyCreateResponseSchema,
+            },
+        },
+        preHandler: requirePermission("item_manager"),
+        handler: async (request, reply) => {
+            const { key, description } = request.body;
+            const userId = request.erpUser.id;
+            const item = await createItem(key, description, userId);
+            const full = formatItem(item, 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 item by key",
+            tags: ["Items"],
+            params: KeyParamsSchema,
+            response: {
+                200: ItemSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const item = await findExisting(key);
+            if (!item) {
+                return notFound(reply, `Item '${key}' not found`);
+            }
+            return formatItem(item, request.erpUser);
+        },
+    });
+    // UPDATE
+    app.put("/:key", {
+        schema: {
+            description: "Update an item",
+            tags: ["Items"],
+            params: KeyParamsSchema,
+            body: UpdateItemSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("item_manager"),
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const data = request.body;
+            const userId = request.erpUser.id;
+            const existing = await findExisting(key);
+            if (!existing) {
+                return notFound(reply, `Item '${key}' not found`);
+            }
+            const item = await updateItem(key, data, userId);
+            const full = formatItem(item, request.erpUser);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE
+    app.delete("/:key", {
+        schema: {
+            description: "Delete an item",
+            tags: ["Items"],
+            params: KeyParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("item_manager"),
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const existing = await findExisting(key);
+            if (!existing) {
+                return notFound(reply, `Item '${key}' not found`);
+            }
+            await deleteItem(key);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=items.js.map

package/dist/routes/labor-tickets.d.ts

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

package/dist/routes/labor-tickets.js

@@ -0,0 +1,268 @@
+import { ClockOutLaborTicketSchema, CreateResponseSchema, ErrorResponseSchema, LaborTicketListResponseSchema, MutateResponseSchema, OperationRunStatus, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { checkOpRunInProgress, formatAuditFields, formatDate, mutationResult, permGate, resolveOpRun, } from "../route-helpers.js";
+import { clockIn, clockOut, deleteLaborTicket, listLaborTickets, } from "../services/labor-ticket-service.js";
+function laborResource(orderKey, runNo, seqNo) {
+    return `orders/${orderKey}/runs/${runNo}/ops/${seqNo}/labor`;
+}
+function laborTicketListActions(orderKey, runNo, seqNo, opRunStatus, user, tickets) {
+    const actions = [];
+    const base = `${API_PREFIX}/${laborResource(orderKey, runNo, seqNo)}`;
+    const isInProgress = opRunStatus === OperationRunStatus.in_progress;
+    const isExecutor = hasPermission(user, "order_executor");
+    const executorGate = permGate(isExecutor, "order_executor");
+    const userHasOpenTicket = user != null && tickets.some((t) => t.userId === user.id && !t.clockOut);
+    const anyOpenTickets = tickets.some((t) => !t.clockOut);
+    // clock-in: show for non-executors (disabled for permission), or executors with status logic
+    if (!isExecutor) {
+        actions.push({
+            rel: "clock-in",
+            href: `${base}/clock-in`,
+            method: "POST",
+            title: "Clock In",
+            ...executorGate,
+        });
+    }
+    else if (!isInProgress) {
+        actions.push({
+            rel: "clock-in",
+            href: `${base}/clock-in`,
+            method: "POST",
+            title: "Clock In",
+            disabled: true,
+            disabledReason: "Operation must be in progress to clock in",
+        });
+    }
+    else if (!userHasOpenTicket) {
+        actions.push({
+            rel: "clock-in",
+            href: `${base}/clock-in`,
+            method: "POST",
+            title: "Clock In",
+        });
+    }
+    // clock-out for executor
+    if (isExecutor && isInProgress && userHasOpenTicket) {
+        actions.push({
+            rel: "clock-out",
+            href: `${base}/clock-out`,
+            method: "POST",
+            title: "Clock Out",
+            schema: `${API_PREFIX}/schemas/ClockOutLaborTicket`,
+            body: {},
+        });
+    }
+    // manager clock-out: for non-executor managers only
+    if (!isExecutor &&
+        hasPermission(user, "order_manager") &&
+        isInProgress &&
+        anyOpenTickets) {
+        actions.push({
+            rel: "clock-out",
+            href: `${base}/clock-out`,
+            method: "POST",
+            title: "Clock Out",
+            schema: `${API_PREFIX}/schemas/ClockOutLaborTicket`,
+            body: { userId: 0, ticketId: 0 },
+        });
+    }
+    return actions;
+}
+function laborTicketActionTemplates(orderKey, runNo, seqNo, user) {
+    if (!hasPermission(user, "order_manager"))
+        return [];
+    return [
+        {
+            rel: "deleteTicket",
+            hrefTemplate: `${API_PREFIX}/${laborResource(orderKey, runNo, seqNo)}/{ticketId}`,
+            method: "DELETE",
+            title: "Delete Ticket",
+        },
+    ];
+}
+function formatLaborTicket(orderKey, runNo, seqNo, ticket) {
+    return {
+        id: ticket.id,
+        operationRunId: ticket.operationRunId,
+        userId: ticket.userId,
+        username: ticket.user.username,
+        runId: ticket.runId,
+        clockIn: ticket.clockIn.toISOString(),
+        clockOut: formatDate(ticket.clockOut),
+        cost: ticket.cost,
+        ...formatAuditFields(ticket),
+        _links: [
+            selfLink(`/${laborResource(orderKey, runNo, seqNo)}/${ticket.id}`),
+        ],
+    };
+}
+const LaborParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+const LaborTicketParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+    ticketId: z.coerce.number().int(),
+});
+export default function laborTicketRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List labor tickets for an operation run",
+            tags: ["Labor Tickets"],
+            params: LaborParamsSchema,
+            response: {
+                200: LaborTicketListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation run not found");
+            }
+            const items = await listLaborTickets(resolved.opRun.id);
+            return {
+                items: items.map((ticket) => {
+                    const { _links, ...rest } = formatLaborTicket(orderKey, runNo, seqNo, ticket);
+                    return rest;
+                }),
+                total: items.length,
+                _links: [selfLink(`/${laborResource(orderKey, runNo, seqNo)}`)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/${laborResource(orderKey, runNo, seqNo)}/{id}`,
+                    },
+                ],
+                _actions: laborTicketListActions(orderKey, runNo, seqNo, resolved.opRun.status, request.erpUser, items),
+                _actionTemplates: laborTicketActionTemplates(orderKey, runNo, seqNo, request.erpUser),
+            };
+        },
+    });
+    // CLOCK IN
+    app.post("/clock-in", {
+        schema: {
+            description: "Clock in to an operation run (auto clocks out any open tickets for this user)",
+            tags: ["Labor Tickets"],
+            params: LaborParamsSchema,
+            response: {
+                200: CreateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, "Operation run not found");
+            const opErr = checkOpRunInProgress(resolved.opRun.status);
+            if (opErr) {
+                reply.status(409);
+                return { statusCode: 409, error: "Conflict", message: opErr };
+            }
+            const ticket = await clockIn(resolved.opRun.id, userId, userId);
+            const full = formatLaborTicket(orderKey, runNo, seqNo, ticket);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                _links: full._links,
+            });
+        },
+    });
+    // CLOCK OUT
+    app.post("/clock-out", {
+        schema: {
+            description: "Clock out of an operation run",
+            tags: ["Labor Tickets"],
+            params: LaborParamsSchema,
+            body: ClockOutLaborTicketSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const userId = request.erpUser.id;
+            const body = request.body;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved)
+                return notFound(reply, "Operation run not found");
+            const opErr = checkOpRunInProgress(resolved.opRun.status);
+            if (opErr) {
+                reply.status(409);
+                return { statusCode: 409, error: "Conflict", message: opErr };
+            }
+            // Non-managers can only clock out their own tickets
+            const isManager = hasPermission(request.erpUser, "order_manager");
+            const opts = {
+                userId: body.userId ?? (isManager ? undefined : userId),
+                ticketId: body.ticketId,
+            };
+            // Non-managers cannot specify another user's ID
+            if (!isManager && body.userId && body.userId !== userId) {
+                reply.status(409);
+                return {
+                    statusCode: 409,
+                    error: "Conflict",
+                    message: "Non-managers can only clock out their own tickets",
+                };
+            }
+            await clockOut(resolved.opRun.id, opts, userId);
+            // Return full list after clock-out
+            const items = await listLaborTickets(resolved.opRun.id);
+            const full = {
+                items: items.map((ticket) => {
+                    const { _links, ...rest } = formatLaborTicket(orderKey, runNo, seqNo, ticket);
+                    return rest;
+                }),
+                total: items.length,
+                _links: [selfLink(`/${laborResource(orderKey, runNo, seqNo)}`)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/${laborResource(orderKey, runNo, seqNo)}/{id}`,
+                    },
+                ],
+                _actions: laborTicketListActions(orderKey, runNo, seqNo, resolved.opRun.status, request.erpUser, items),
+                _actionTemplates: laborTicketActionTemplates(orderKey, runNo, seqNo, request.erpUser),
+            };
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE
+    app.delete("/:ticketId", {
+        schema: {
+            description: "Delete a labor ticket",
+            tags: ["Labor Tickets"],
+            params: LaborTicketParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_manager"),
+        handler: async (request, reply) => {
+            const { ticketId } = request.params;
+            const userId = request.erpUser.id;
+            await deleteLaborTicket(ticketId, userId);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=labor-tickets.js.map

package/dist/routes/operation-dependencies.d.ts

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