@naisys/erp 3.0.0-beta.3

package/dist/routes/operation-dependencies.js

@@ -0,0 +1,170 @@
+import { CreateOperationDependencySchema, CreateResponseSchema, ErrorResponseSchema, OperationDependencyListResponseSchema, RevisionStatus, } 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 { mutationResult, resolveRevision } from "../route-helpers.js";
+import { createDependency, deleteDependency, listDependencies, } from "../services/operation-dependency-service.js";
+import { findExisting } from "../services/operation-service.js";
+const ParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+const DepParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+    predecessorSeqNo: z.coerce.number().int(),
+});
+function depBasePath(orderKey, revNo, seqNo) {
+    return `/orders/${orderKey}/revs/${revNo}/ops/${seqNo}/deps`;
+}
+function formatDependency(dep) {
+    return {
+        id: dep.id,
+        predecessorSeqNo: dep.predecessor.seqNo,
+        predecessorTitle: dep.predecessor.title,
+        createdAt: dep.createdAt.toISOString(),
+        createdBy: dep.createdBy.username,
+    };
+}
+function depActionTemplates(basePath, revStatus, user) {
+    if (!hasPermission(user, "order_planner") ||
+        revStatus !== RevisionStatus.draft)
+        return [];
+    return [
+        {
+            rel: "deleteDependency",
+            hrefTemplate: `${API_PREFIX}${basePath}/{predecessorSeqNo}`,
+            method: "DELETE",
+            title: "Remove Dependency",
+        },
+    ];
+}
+export default function operationDependencyRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST dependencies (predecessors) for an operation
+    app.get("/", {
+        schema: {
+            description: "List predecessor dependencies for an operation",
+            tags: ["Operation Dependencies"],
+            params: ParamsSchema,
+            response: {
+                200: OperationDependencyListResponseSchema,
+                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 findExisting(resolved.rev.id, seqNo);
+            if (!operation) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            const items = await listDependencies(operation.id);
+            const user = request.erpUser;
+            const base = depBasePath(orderKey, revNo, seqNo);
+            return {
+                items: items.map((dep) => formatDependency(dep)),
+                total: items.length,
+                _links: [selfLink(base)],
+                _actions: hasPermission(user, "order_planner") &&
+                    resolved.rev.status === RevisionStatus.draft
+                    ? [
+                        {
+                            rel: "create",
+                            href: `${API_PREFIX}${base}`,
+                            method: "POST",
+                            title: "Add Dependency",
+                            schema: `${API_PREFIX}/schemas/CreateOperationDependency`,
+                        },
+                    ]
+                    : [],
+                _actionTemplates: depActionTemplates(base, resolved.rev.status, user),
+            };
+        },
+    });
+    // CREATE a dependency
+    app.post("/", {
+        schema: {
+            description: "Add a predecessor dependency to an operation",
+            tags: ["Operation Dependencies"],
+            params: ParamsSchema,
+            body: CreateOperationDependencySchema,
+            response: {
+                201: CreateResponseSchema,
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo } = request.params;
+            const { predecessorSeqNo } = 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 modify dependencies on a ${resolved.rev.status} revision`);
+            }
+            const successor = await findExisting(resolved.rev.id, seqNo);
+            if (!successor) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            const predecessor = await findExisting(resolved.rev.id, predecessorSeqNo);
+            if (!predecessor) {
+                return notFound(reply, `Predecessor operation ${predecessorSeqNo} not found`);
+            }
+            if (successor.id === predecessor.id) {
+                return conflict(reply, "An operation cannot depend on itself");
+            }
+            const dep = await createDependency(successor.id, predecessor.id, userId);
+            const full = formatDependency(dep);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+            });
+        },
+    });
+    // DELETE a dependency
+    app.delete("/:predecessorSeqNo", {
+        schema: {
+            description: "Remove a predecessor dependency from an operation",
+            tags: ["Operation Dependencies"],
+            params: DepParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo, predecessorSeqNo } = 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 modify dependencies on a ${resolved.rev.status} revision`);
+            }
+            const successor = await findExisting(resolved.rev.id, seqNo);
+            if (!successor) {
+                return notFound(reply, `Operation ${seqNo} not found`);
+            }
+            const predecessor = await findExisting(resolved.rev.id, predecessorSeqNo);
+            if (!predecessor) {
+                return notFound(reply, `Predecessor operation ${predecessorSeqNo} not found`);
+            }
+            await deleteDependency(successor.id, predecessor.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=operation-dependencies.js.map

package/dist/routes/operation-field-refs.d.ts

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

package/dist/routes/operation-field-refs.js

@@ -0,0 +1,263 @@
+import { CreateFieldRefSchema, ErrorResponseSchema, FieldRefListResponseSchema, RevisionStatus, SeqNoCreateResponseSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { requirePermission } from "../auth-middleware.js";
+import erpDb from "../erpDb.js";
+import { conflict, notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { calcNextSeqNo, childItemLinks, mutationResult, resolveActions, resolveOperation, } from "../route-helpers.js";
+import { checkDuplicateSource, createFieldRef, deleteFieldRef, findExistingFieldRef, listFieldRefs, } from "../services/field-ref-service.js";
+const ParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+const RefParamsSchema = z.object({
+    orderKey: z.string(),
+    revNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+    refSeqNo: z.coerce.number().int(),
+});
+function basePath(orderKey, revNo, seqNo) {
+    return `/orders/${orderKey}/revs/${revNo}/ops/${seqNo}/field-refs`;
+}
+function formatFieldRef(orderKey, revNo, seqNo, revStatus, user, ref) {
+    const base = basePath(orderKey, revNo, seqNo);
+    return {
+        id: ref.id,
+        seqNo: ref.seqNo,
+        title: ref.title,
+        sourceOpSeqNo: ref.sourceStep.operation.seqNo,
+        sourceOpTitle: ref.sourceStep.operation.title,
+        sourceStepSeqNo: ref.sourceStep.seqNo,
+        sourceStepTitle: ref.sourceStep.title,
+        fields: (ref.sourceStep.fieldSet?.fields ?? []).map((f) => ({
+            seqNo: f.seqNo,
+            label: f.label,
+            type: f.type,
+        })),
+        createdAt: ref.createdAt.toISOString(),
+        createdBy: ref.createdBy.username,
+        _links: childItemLinks(base, ref.seqNo, "Field Refs", `/orders/${orderKey}/revs/${revNo}/ops/${seqNo}`, "Operation", "FieldRef"),
+        _actions: deleteAction(`${API_PREFIX}${base}/${ref.seqNo}`, revStatus, user),
+    };
+}
+function deleteAction(href, revStatus, user) {
+    return resolveActions([
+        {
+            rel: "delete",
+            method: "DELETE",
+            title: "Remove Reference",
+            permission: "order_planner",
+            statuses: [RevisionStatus.draft],
+            hideWithoutPermission: true,
+        },
+    ], href, { status: revStatus, user });
+}
+const draftCreateDef = {
+    rel: "create",
+    method: "POST",
+    title: "Add Field Reference",
+    schema: `${API_PREFIX}/schemas/CreateFieldRef`,
+    permission: "order_planner",
+    disabledWhen: (ctx) => ctx.status !== RevisionStatus.draft
+        ? "Can only add field references in draft revisions"
+        : null,
+};
+// Schema for the /available response
+const AvailableStepSchema = z.object({
+    opSeqNo: z.number(),
+    opTitle: z.string(),
+    stepSeqNo: z.number(),
+    stepTitle: z.string(),
+    stepId: z.number(),
+    fieldCount: z.number(),
+});
+const AvailableStepsResponseSchema = z.object({
+    items: z.array(AvailableStepSchema),
+});
+export default function operationFieldRefRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST available steps with fields (for the "add reference" dialog)
+    app.get("/available", {
+        schema: {
+            description: "List steps with fields in the same revision that can be referenced",
+            tags: ["Operation Field Refs"],
+            params: ParamsSchema,
+            response: {
+                200: AvailableStepsResponseSchema,
+                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");
+            }
+            // Find all steps in this revision that have fields
+            const steps = await erpDb.step.findMany({
+                where: {
+                    operation: { orderRevId: resolved.rev.id },
+                    fieldSetId: { not: null },
+                    fieldSet: { fields: { some: {} } },
+                },
+                select: {
+                    id: true,
+                    seqNo: true,
+                    title: true,
+                    operation: { select: { seqNo: true, title: true } },
+                    fieldSet: { select: { _count: { select: { fields: true } } } },
+                },
+                orderBy: [{ operation: { seqNo: "asc" } }, { seqNo: "asc" }],
+            });
+            // Exclude steps already referenced by this operation
+            const existingRefs = await erpDb.operationFieldRef.findMany({
+                where: { operationId: resolved.operation.id },
+                select: { sourceStepId: true },
+            });
+            const refSet = new Set(existingRefs.map((r) => r.sourceStepId));
+            return {
+                items: steps
+                    .filter((s) => !refSet.has(s.id))
+                    .map((s) => ({
+                    opSeqNo: s.operation.seqNo,
+                    opTitle: s.operation.title,
+                    stepSeqNo: s.seqNo,
+                    stepTitle: s.title,
+                    stepId: s.id,
+                    fieldCount: s.fieldSet?._count.fields ?? 0,
+                })),
+            };
+        },
+    });
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List field references for an operation",
+            tags: ["Operation Field Refs"],
+            params: ParamsSchema,
+            response: {
+                200: FieldRefListResponseSchema,
+                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 listFieldRefs(resolved.operation.id);
+            const maxSeq = items.length > 0 ? items[items.length - 1].seqNo : 0;
+            const base = basePath(orderKey, revNo, seqNo);
+            return {
+                items: items.map((ref) => {
+                    const { _links, ...rest } = formatFieldRef(orderKey, revNo, seqNo, resolved.rev.status, request.erpUser, ref);
+                    return rest;
+                }),
+                total: items.length,
+                nextSeqNo: calcNextSeqNo(maxSeq),
+                _links: [selfLink(base)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}${base}/{seqNo}`,
+                    },
+                ],
+                _actions: resolveActions([draftCreateDef], `${API_PREFIX}${base}`, {
+                    status: resolved.rev.status,
+                    user: request.erpUser,
+                }),
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Add a field reference to an operation (draft revision only)",
+            tags: ["Operation Field Refs"],
+            params: ParamsSchema,
+            body: CreateFieldRefSchema,
+            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, sourceOpSeqNo, sourceStepSeqNo, } = 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 field references to a ${resolved.rev.status} revision`);
+            }
+            // Resolve source step
+            const sourceOp = await erpDb.operation.findFirst({
+                where: { orderRevId: resolved.rev.id, seqNo: sourceOpSeqNo },
+            });
+            if (!sourceOp) {
+                return notFound(reply, `Source operation ${sourceOpSeqNo} not found`);
+            }
+            const sourceStep = await erpDb.step.findFirst({
+                where: { operationId: sourceOp.id, seqNo: sourceStepSeqNo },
+                select: { id: true, fieldSetId: true },
+            });
+            if (!sourceStep) {
+                return notFound(reply, `Source step ${sourceStepSeqNo} not found in operation ${sourceOpSeqNo}`);
+            }
+            if (!sourceStep.fieldSetId) {
+                return conflict(reply, "Source step has no fields");
+            }
+            // Check for duplicate
+            const dup = await checkDuplicateSource(resolved.operation.id, sourceStep.id);
+            if (dup) {
+                return conflict(reply, "This step is already referenced");
+            }
+            const ref = await createFieldRef(resolved.operation.id, requestedSeqNo, title, sourceStep.id, userId);
+            const full = formatFieldRef(orderKey, revNo, seqNo, resolved.rev.status, request.erpUser, ref);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                seqNo: full.seqNo,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE
+    app.delete("/:refSeqNo", {
+        schema: {
+            description: "Remove a field reference from an operation (draft revision only)",
+            tags: ["Operation Field Refs"],
+            params: RefParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+                409: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_planner"),
+        handler: async (request, reply) => {
+            const { orderKey, revNo, seqNo, refSeqNo } = 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 remove field references from a ${resolved.rev.status} revision`);
+            }
+            const existing = await findExistingFieldRef(resolved.operation.id, refSeqNo);
+            if (!existing) {
+                return notFound(reply, `Field reference ${refSeqNo} not found`);
+            }
+            await deleteFieldRef(existing.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=operation-field-refs.js.map

package/dist/routes/operation-run-comments.d.ts

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

package/dist/routes/operation-run-comments.js

@@ -0,0 +1,108 @@
+import { CreateOperationRunCommentSchema, CreateResponseSchema, ErrorResponseSchema, OperationRunCommentListResponseSchema, OperationRunCommentType, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { requirePermission } from "../auth-middleware.js";
+import { notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { mutationResult, resolveActions, resolveOpRun, } from "../route-helpers.js";
+import { createComment, listComments, } from "../services/operation-run-comment-service.js";
+function commentResource(orderKey, runNo, seqNo) {
+    return `orders/${orderKey}/runs/${runNo}/ops/${seqNo}/comments`;
+}
+function commentListActions(orderKey, runNo, seqNo, user) {
+    return resolveActions([
+        {
+            rel: "create",
+            method: "POST",
+            title: "Add Comment",
+            schema: `${API_PREFIX}/schemas/CreateOperationRunComment`,
+            permission: "order_executor",
+        },
+    ], `${API_PREFIX}/${commentResource(orderKey, runNo, seqNo)}`, { user });
+}
+function formatComment(orderKey, runNo, seqNo, comment) {
+    return {
+        id: comment.id,
+        operationRunId: comment.operationRunId,
+        type: comment.type,
+        body: comment.body,
+        createdAt: comment.createdAt.toISOString(),
+        createdBy: comment.createdBy.username,
+        _links: [
+            selfLink(`/${commentResource(orderKey, runNo, seqNo)}/${comment.id}`),
+        ],
+    };
+}
+const CommentParamsSchema = z.object({
+    orderKey: z.string(),
+    runNo: z.coerce.number().int(),
+    seqNo: z.coerce.number().int(),
+});
+export default function operationRunCommentRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List comments for an operation run",
+            tags: ["Operation Run Comments"],
+            params: CommentParamsSchema,
+            response: {
+                200: OperationRunCommentListResponseSchema,
+                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 listComments(resolved.opRun.id);
+            return {
+                items: items.map((c) => {
+                    const { _links, ...rest } = formatComment(orderKey, runNo, seqNo, c);
+                    return rest;
+                }),
+                total: items.length,
+                _links: [selfLink(`/${commentResource(orderKey, runNo, seqNo)}`)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/${commentResource(orderKey, runNo, seqNo)}/{id}`,
+                    },
+                ],
+                _actions: commentListActions(orderKey, runNo, seqNo, request.erpUser),
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Add a comment to an operation run",
+            tags: ["Operation Run Comments"],
+            params: CommentParamsSchema,
+            body: CreateOperationRunCommentSchema,
+            response: {
+                201: CreateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("order_executor"),
+        handler: async (request, reply) => {
+            const { orderKey, runNo, seqNo } = request.params;
+            const { type, body } = request.body;
+            const userId = request.erpUser.id;
+            const resolved = await resolveOpRun(orderKey, runNo, seqNo);
+            if (!resolved) {
+                return notFound(reply, "Operation run not found");
+            }
+            const comment = await createComment(resolved.opRun.id, type ?? OperationRunCommentType.note, body, userId);
+            const full = formatComment(orderKey, runNo, seqNo, comment);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                _links: full._links,
+            });
+        },
+    });
+}
+//# sourceMappingURL=operation-run-comments.js.map

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

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