@naisys/erp 3.0.0-beta.3

package/dist/services/operation-run-service.js

@@ -0,0 +1,347 @@
+import { OperationRunStatus as OperationRunStatusValues, } from "@naisys/erp-shared";
+import { fieldTypeString, getValueFormatHint, } from "@naisys/erp-shared";
+import { writeAuditEntry } from "../audit.js";
+import erpDb from "../erpDb.js";
+import { API_PREFIX } from "../hateoas.js";
+import { deserializeFieldValue, validateFieldValue, } from "./field-value-service.js";
+// --- Prisma include & result type ---
+export const includeOp = {
+    operation: {
+        select: {
+            seqNo: true,
+            title: true,
+            description: true,
+            workCenter: { select: { key: true } },
+        },
+    },
+    assignedTo: { select: { username: true } },
+    createdBy: { select: { username: true } },
+    updatedBy: { select: { username: true } },
+};
+// --- Lookups ---
+export async function listOpRuns(runId) {
+    return erpDb.operationRun.findMany({
+        where: { orderRunId: runId },
+        include: {
+            operation: {
+                select: {
+                    seqNo: true,
+                    title: true,
+                    description: true,
+                    workCenter: { select: { key: true } },
+                    predecessors: {
+                        include: { predecessor: { select: { seqNo: true, title: true } } },
+                        orderBy: { predecessor: { seqNo: "asc" } },
+                    },
+                },
+            },
+            _count: { select: { stepRuns: true } },
+            assignedTo: { select: { username: true } },
+            createdBy: { select: { username: true } },
+            updatedBy: { select: { username: true } },
+        },
+        orderBy: { operation: { seqNo: "asc" } },
+    });
+}
+export async function getOpRun(id) {
+    return erpDb.operationRun.findUnique({
+        where: { id },
+        include: includeOp,
+    });
+}
+const includeOpSeqNo = {
+    operation: { select: { seqNo: true } },
+};
+export async function findExisting(id, runId) {
+    const existing = await erpDb.operationRun.findUnique({
+        where: { id },
+        include: includeOpSeqNo,
+    });
+    if (!existing || existing.orderRunId !== runId)
+        return null;
+    return existing;
+}
+export async function getOpRunStepSummary(opRunId) {
+    return erpDb.stepRun.findMany({
+        where: { operationRunId: opRunId },
+        select: {
+            step: { select: { seqNo: true, title: true } },
+            completed: true,
+        },
+        orderBy: { step: { seqNo: "asc" } },
+    });
+}
+/**
+ * Resolve field reference values for an operation run.
+ * Looks up the plan-level field refs, finds the corresponding step runs
+ * in the same order run, and returns FieldValueEntry-shaped data
+ * compatible with the FieldValueRunList component.
+ */
+export async function getOpRunFieldRefSummary(operationId, orderRunId, orderKey, runNo) {
+    // Get field refs from the plan-level operation
+    const fieldRefs = await erpDb.operationFieldRef.findMany({
+        where: { operationId },
+        include: {
+            sourceStep: {
+                select: {
+                    id: true,
+                    seqNo: true,
+                    title: true,
+                    multiSet: true,
+                    operation: { select: { seqNo: true, title: true } },
+                    fieldSet: {
+                        select: {
+                            fields: {
+                                select: {
+                                    id: true,
+                                    seqNo: true,
+                                    label: true,
+                                    type: true,
+                                    isArray: true,
+                                    required: true,
+                                },
+                                orderBy: { seqNo: "asc" },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        orderBy: { seqNo: "asc" },
+    });
+    if (fieldRefs.length === 0)
+        return [];
+    // Collect all source step IDs to batch-fetch their step runs
+    const sourceStepIds = fieldRefs.map((r) => r.sourceStep.id);
+    // Find the step runs for these source steps in the same order run
+    // Include attachments for attachment-type fields
+    const stepRuns = await erpDb.stepRun.findMany({
+        where: {
+            operationRun: { orderRunId },
+            stepId: { in: sourceStepIds },
+        },
+        select: {
+            stepId: true,
+            fieldRecord: {
+                select: {
+                    fieldValues: {
+                        select: {
+                            fieldId: true,
+                            setIndex: true,
+                            value: true,
+                            fieldAttachments: {
+                                include: {
+                                    attachment: {
+                                        select: { publicId: true, filename: true, fileSize: true },
+                                    },
+                                },
+                            },
+                        },
+                        orderBy: { setIndex: "asc" },
+                    },
+                },
+            },
+        },
+    });
+    const stepRunMap = new Map(stepRuns.map((sr) => [sr.stepId, sr]));
+    return fieldRefs.map((ref) => {
+        const sr = stepRunMap.get(ref.sourceStep.id);
+        const storedFieldValues = sr?.fieldRecord?.fieldValues ?? [];
+        const fields = ref.sourceStep.fieldSet?.fields ?? [];
+        // Determine set count
+        const maxSetIndex = storedFieldValues.reduce((max, fv) => Math.max(max, fv.setIndex), -1);
+        const setCount = Math.max(1, maxSetIndex + 1);
+        // Build FieldValueEntry-shaped objects for each set × field
+        const fieldValues = [];
+        for (let si = 0; si < setCount; si++) {
+            for (const field of fields) {
+                const stored = storedFieldValues.find((fv) => fv.fieldId === field.id && fv.setIndex === si);
+                const value = deserializeFieldValue(stored?.value ?? "", field.isArray);
+                const setPath = ref.sourceStep.multiSet
+                    ? `/sets/${si}/fields/${field.seqNo}`
+                    : `/fields/${field.seqNo}`;
+                const stepsHref = `${API_PREFIX}/orders/${orderKey}/runs/${runNo}/ops/${ref.sourceStep.operation.seqNo}/steps/${ref.sourceStep.seqNo}`;
+                const attachments = field.type === "attachment" && stored
+                    ? stored.fieldAttachments.map((sfa) => ({
+                        id: sfa.attachment.publicId,
+                        filename: sfa.attachment.filename,
+                        fileSize: sfa.attachment.fileSize,
+                        downloadHref: `${stepsHref}${setPath}/attachments/${sfa.attachment.publicId}`,
+                    }))
+                    : undefined;
+                const fieldType = fieldTypeString(field.type, field.isArray);
+                fieldValues.push({
+                    fieldId: field.id,
+                    fieldSeqNo: field.seqNo,
+                    label: field.label,
+                    type: fieldType,
+                    valueFormat: getValueFormatHint(fieldType),
+                    required: field.required,
+                    setIndex: si,
+                    value,
+                    attachments,
+                    validation: validateFieldValue(field.type, field.isArray, field.required, value),
+                });
+            }
+        }
+        return {
+            seqNo: ref.seqNo,
+            title: ref.title,
+            sourceOpSeqNo: ref.sourceStep.operation.seqNo,
+            sourceOpTitle: ref.sourceStep.operation.title,
+            sourceStepSeqNo: ref.sourceStep.seqNo,
+            sourceStepTitle: ref.sourceStep.title,
+            multiSet: ref.sourceStep.multiSet,
+            fieldValues,
+        };
+    });
+}
+// --- Validation ---
+export function validateStatusFor(action, currentStatus, allowedStatuses) {
+    if (!allowedStatuses.includes(currentStatus)) {
+        return `Cannot ${action} operation run in ${currentStatus} status`;
+    }
+    return null;
+}
+/**
+ * Check that all predecessor dependencies for this operation are complete.
+ * Uses the OperationDependency graph rather than seqNo ordering.
+ */
+export async function checkPredecessorsComplete(runId, operationId) {
+    // Get predecessor operation IDs from dependency graph
+    const deps = await erpDb.operationDependency.findMany({
+        where: { successorId: operationId },
+        select: { predecessorId: true },
+    });
+    if (deps.length === 0)
+        return null;
+    const predecessorIds = deps.map((d) => d.predecessorId);
+    const incompletePrior = await erpDb.operationRun.findMany({
+        where: {
+            orderRunId: runId,
+            operationId: { in: predecessorIds },
+            status: {
+                notIn: [
+                    OperationRunStatusValues.completed,
+                    OperationRunStatusValues.skipped,
+                ],
+            },
+        },
+        include: { operation: { select: { seqNo: true, title: true } } },
+    });
+    if (incompletePrior.length === 0)
+        return null;
+    const labels = incompletePrior.map((op) => `Op ${op.operation.seqNo} "${op.operation.title}" (${op.status})`);
+    return `Cannot start: predecessor operations not complete — ${labels.join(", ")}`;
+}
+/**
+ * After completing/skipping an operation, unblock successor ops
+ * whose predecessors are now all complete.
+ */
+export async function unblockSuccessors(runId, operationId, userId) {
+    // Find successor operations via dependency graph
+    const successorDeps = await erpDb.operationDependency.findMany({
+        where: { predecessorId: operationId },
+        select: { successorId: true },
+    });
+    if (successorDeps.length === 0)
+        return;
+    for (const { successorId } of successorDeps) {
+        // Only unblock if the successor op run is currently blocked
+        const successorRun = await erpDb.operationRun.findFirst({
+            where: {
+                orderRunId: runId,
+                operationId: successorId,
+                status: OperationRunStatusValues.blocked,
+            },
+        });
+        if (!successorRun)
+            continue;
+        // Check if ALL predecessors of this successor are complete
+        const allPredDeps = await erpDb.operationDependency.findMany({
+            where: { successorId },
+            select: { predecessorId: true },
+        });
+        const predIds = allPredDeps.map((d) => d.predecessorId);
+        const incompleteCount = await erpDb.operationRun.count({
+            where: {
+                orderRunId: runId,
+                operationId: { in: predIds },
+                status: {
+                    notIn: [
+                        OperationRunStatusValues.completed,
+                        OperationRunStatusValues.skipped,
+                    ],
+                },
+            },
+        });
+        if (incompleteCount === 0) {
+            await erpDb.operationRun.update({
+                where: { id: successorRun.id },
+                data: {
+                    status: OperationRunStatusValues.pending,
+                    updatedById: userId,
+                },
+            });
+        }
+    }
+}
+/**
+ * After reopening an operation, re-block successor ops that are still pending
+ * (haven't been started yet) if this operation is one of their prerequisites.
+ */
+export async function reblockSuccessors(runId, operationId, userId) {
+    const successorDeps = await erpDb.operationDependency.findMany({
+        where: { predecessorId: operationId },
+        select: { successorId: true },
+    });
+    if (successorDeps.length === 0)
+        return;
+    for (const { successorId } of successorDeps) {
+        // Only re-block if successor is still pending (not started/in_progress/etc.)
+        await erpDb.operationRun.updateMany({
+            where: {
+                orderRunId: runId,
+                operationId: successorId,
+                status: OperationRunStatusValues.pending,
+            },
+            data: {
+                status: OperationRunStatusValues.blocked,
+                updatedById: userId,
+            },
+        });
+    }
+}
+export async function checkStepsComplete(opRunId) {
+    const incompleteSteps = await erpDb.stepRun.findMany({
+        where: { operationRunId: opRunId, completed: false },
+        include: { step: { select: { seqNo: true, title: true } } },
+    });
+    if (incompleteSteps.length === 0)
+        return null;
+    const labels = incompleteSteps.map((s) => `Step ${s.step.seqNo}${s.step.title ? ` "${s.step.title}"` : ""}`);
+    return `Cannot complete operation: incomplete steps — ${labels.join(", ")}`;
+}
+// --- Mutations ---
+export async function updateOpRun(id, data, userId) {
+    const updateData = { updatedById: userId };
+    if (data.assignedToId !== undefined)
+        updateData.assignedToId = data.assignedToId;
+    return erpDb.operationRun.update({
+        where: { id },
+        data: updateData,
+        include: includeOp,
+    });
+}
+export async function transitionStatus(id, action, fromStatus, toStatus, userId, extraData) {
+    return erpDb.$transaction(async (erpTx) => {
+        const updated = await erpTx.operationRun.update({
+            where: { id },
+            data: { status: toStatus, updatedById: userId, ...extraData },
+            include: includeOp,
+        });
+        await writeAuditEntry(erpTx, "OperationRun", id, action, "status", fromStatus, toStatus, userId);
+        return updated;
+    });
+}
+//# sourceMappingURL=operation-run-service.js.map

package/dist/services/operation-service.d.ts

@@ -0,0 +1,47 @@
+import type { OperationModel } from "../generated/prisma/models/Operation.js";
+import { type WithAuditUsers } from "../route-helpers.js";
+export type OperationWithUsers = OperationModel & WithAuditUsers & {
+    workCenter?: {
+        key: string;
+    } | null;
+};
+export type OperationWithSummary = OperationWithUsers & {
+    _count: {
+        steps: number;
+    };
+    predecessors: Array<{
+        predecessor: {
+            seqNo: number;
+            title: string;
+        };
+    }>;
+};
+export declare function listOperations(orderRevId: number): Promise<OperationWithSummary[]>;
+export type OperationWithStepSummary = OperationWithUsers & {
+    steps: Array<{
+        seqNo: number;
+        title: string;
+    }>;
+};
+export declare function getOperation(orderRevId: number, seqNo: number): Promise<OperationWithStepSummary | null>;
+export declare function findExisting(orderRevId: number, seqNo: number): Promise<{
+    title: string;
+    description: string;
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+    seqNo: number;
+    orderRevId: number;
+    workCenterId: number | null;
+    createdById: number;
+    updatedById: number;
+} | null>;
+export declare function createOperation(orderRevId: number, requestedSeqNo: number | undefined, title: string, description: string | undefined, workCenterId: number | null | undefined, predecessorSeqNos: number[] | undefined, userId: number): Promise<OperationWithSummary>;
+export declare function updateOperation(id: number, data: {
+    title?: string;
+    description?: string;
+    workCenterId?: number | null;
+    seqNo?: number;
+}, userId: number): Promise<OperationWithUsers>;
+export declare function deleteOperation(id: number): Promise<void>;
+//# sourceMappingURL=operation-service.d.ts.map

package/dist/services/operation-service.js

@@ -0,0 +1,132 @@
+import erpDb from "../erpDb.js";
+import { calcNextSeqNo, includeUsers, } from "../route-helpers.js";
+// --- Prisma include & result type ---
+const includeWorkCenter = {
+    workCenter: { select: { key: true } },
+};
+// --- Lookups ---
+export async function listOperations(orderRevId) {
+    return erpDb.operation.findMany({
+        where: { orderRevId },
+        include: {
+            ...includeUsers,
+            ...includeWorkCenter,
+            _count: { select: { steps: true } },
+            predecessors: {
+                include: { predecessor: { select: { seqNo: true, title: true } } },
+                orderBy: { predecessor: { seqNo: "asc" } },
+            },
+        },
+        orderBy: { seqNo: "asc" },
+    });
+}
+export async function getOperation(orderRevId, seqNo) {
+    return erpDb.operation.findFirst({
+        where: { orderRevId, seqNo },
+        include: {
+            ...includeUsers,
+            ...includeWorkCenter,
+            steps: {
+                select: { seqNo: true, title: true },
+                orderBy: { seqNo: "asc" },
+            },
+        },
+    });
+}
+export async function findExisting(orderRevId, seqNo) {
+    return erpDb.operation.findFirst({
+        where: { orderRevId, seqNo },
+    });
+}
+// --- Mutations ---
+export async function createOperation(orderRevId, requestedSeqNo, title, description, workCenterId, predecessorSeqNos, userId) {
+    return erpDb.$transaction(async (erpTx) => {
+        const maxSeq = await erpTx.operation.findFirst({
+            where: { orderRevId },
+            orderBy: { seqNo: "desc" },
+            select: { seqNo: true },
+        });
+        const defaultSeqNo = calcNextSeqNo(maxSeq?.seqNo ?? 0);
+        const nextSeqNo = requestedSeqNo ?? defaultSeqNo;
+        const created = await erpTx.operation.create({
+            data: {
+                orderRevId,
+                seqNo: nextSeqNo,
+                title,
+                description: description ?? "",
+                ...(workCenterId !== undefined ? { workCenterId } : {}),
+                createdById: userId,
+                updatedById: userId,
+            },
+        });
+        if (predecessorSeqNos !== undefined) {
+            // Use explicitly provided predecessors
+            for (const predSeqNo of predecessorSeqNos) {
+                const predOp = await erpTx.operation.findFirst({
+                    where: { orderRevId, seqNo: predSeqNo },
+                    select: { id: true },
+                });
+                if (predOp) {
+                    await erpTx.operationDependency.create({
+                        data: {
+                            successorId: created.id,
+                            predecessorId: predOp.id,
+                            createdById: userId,
+                        },
+                    });
+                }
+            }
+        }
+        else {
+            // Auto-create dependency on the previous operation (by seqNo)
+            const previousOp = await erpTx.operation.findFirst({
+                where: { orderRevId, seqNo: { lt: nextSeqNo } },
+                orderBy: { seqNo: "desc" },
+                select: { id: true },
+            });
+            if (previousOp) {
+                await erpTx.operationDependency.create({
+                    data: {
+                        successorId: created.id,
+                        predecessorId: previousOp.id,
+                        createdById: userId,
+                    },
+                });
+            }
+        }
+        // Re-fetch with summary data (predecessors + step count)
+        return erpTx.operation.findUniqueOrThrow({
+            where: { id: created.id },
+            include: {
+                ...includeUsers,
+                ...includeWorkCenter,
+                _count: { select: { steps: true } },
+                predecessors: {
+                    include: { predecessor: { select: { seqNo: true, title: true } } },
+                    orderBy: { predecessor: { seqNo: "asc" } },
+                },
+            },
+        });
+    });
+}
+export async function updateOperation(id, data, userId) {
+    return erpDb.operation.update({
+        where: { id },
+        data: {
+            ...(data.title !== undefined ? { title: data.title } : {}),
+            ...(data.description !== undefined
+                ? { description: data.description }
+                : {}),
+            ...(data.workCenterId !== undefined
+                ? { workCenterId: data.workCenterId }
+                : {}),
+            ...(data.seqNo !== undefined ? { seqNo: data.seqNo } : {}),
+            updatedById: userId,
+        },
+        include: { ...includeUsers, ...includeWorkCenter },
+    });
+}
+export async function deleteOperation(id) {
+    await erpDb.operation.delete({ where: { id } });
+}
+//# sourceMappingURL=operation-service.js.map

package/dist/services/order-revision-service.d.ts

@@ -0,0 +1,53 @@
+import { type RevisionStatus } from "@naisys/erp-shared";
+import type { OrderRevisionModel } from "../generated/prisma/models/OrderRevision.js";
+import { type WithAuditUsers } from "../route-helpers.js";
+export type OrderRevisionWithRelations = OrderRevisionModel & WithAuditUsers & {
+    order: {
+        item: {
+            key: string;
+        } | null;
+    };
+};
+export declare function getRevisionOpSummary(orderRevId: number): Promise<{
+    title: string;
+    seqNo: number;
+}[]>;
+export declare function listRevisions(orderId: number, where: Record<string, unknown>, page: number, pageSize: number): Promise<[OrderRevisionWithRelations[], number]>;
+export declare function getRevision(orderId: number, revNo: number): Promise<OrderRevisionWithRelations | null>;
+export declare function findExisting(orderId: number, revNo: number): Promise<({
+    order: {
+        item: {
+            key: string;
+        } | null;
+    };
+    createdBy: {
+        username: string;
+    };
+    updatedBy: {
+        username: string;
+    };
+} & {
+    description: string;
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+    status: import("../generated/prisma/enums.js").RevisionStatus;
+    changeSummary: string | null;
+    revNo: number;
+    createdById: number;
+    updatedById: number;
+    orderId: number;
+}) | null>;
+export declare function validateDraftStatus(status: string): string | null;
+export declare function checkHasOrderRuns(revisionId: number): Promise<string | null>;
+export declare function createRevision(orderId: number, data: {
+    description?: string;
+    changeSummary?: string | null;
+}, userId: number): Promise<OrderRevisionWithRelations>;
+export declare function updateRevision(id: number, data: {
+    description?: string;
+    changeSummary?: string | null;
+}, userId: number): Promise<OrderRevisionWithRelations>;
+export declare function deleteRevision(id: number): Promise<void>;
+export declare function transitionStatus(id: number, action: string, fromStatus: RevisionStatus, toStatus: RevisionStatus, userId: number): Promise<OrderRevisionWithRelations>;
+//# sourceMappingURL=order-revision-service.d.ts.map