@naisys/erp 3.0.0-beta.10

package/dist/services/order-revision-service.js

@@ -0,0 +1,264 @@
+import { RevisionStatus as RevisionStatusValues, } from "@naisys/erp-shared";
+import { writeAuditEntry } from "../audit.js";
+import erpDb from "../erpDb.js";
+import { includeUsers } from "../route-helpers.js";
+// --- Prisma include & result type ---
+const includeRevisionRelations = {
+    ...includeUsers,
+    order: { select: { item: { select: { key: true } } } },
+};
+export async function getRevisionOpSummary(orderRevId) {
+    return erpDb.operation.findMany({
+        where: { orderRevId },
+        select: { seqNo: true, title: true },
+        orderBy: { seqNo: "asc" },
+    });
+}
+// --- Lookups ---
+export async function listRevisions(orderId, where, page, pageSize) {
+    const fullWhere = { orderId, ...where };
+    return Promise.all([
+        erpDb.orderRevision.findMany({
+            where: fullWhere,
+            include: includeRevisionRelations,
+            skip: (page - 1) * pageSize,
+            take: pageSize,
+            orderBy: { revNo: "desc" },
+        }),
+        erpDb.orderRevision.count({ where: fullWhere }),
+    ]);
+}
+export async function getRevision(orderId, revNo) {
+    return erpDb.orderRevision.findFirst({
+        where: { orderId, revNo },
+        include: includeRevisionRelations,
+    });
+}
+export async function findExisting(orderId, revNo) {
+    return erpDb.orderRevision.findFirst({
+        where: { orderId, revNo },
+        include: includeRevisionRelations,
+    });
+}
+// --- Validation ---
+export function validateDraftStatus(status) {
+    if (status !== RevisionStatusValues.draft) {
+        return `Cannot update revision in ${status} status`;
+    }
+    return null;
+}
+export async function checkHasOrderRuns(revisionId) {
+    const orderRunCount = await erpDb.orderRun.count({
+        where: { orderRevId: revisionId },
+    });
+    if (orderRunCount > 0) {
+        return "Cannot delete revision with existing order runs.";
+    }
+    return null;
+}
+// --- Mutations ---
+export async function createRevision(orderId, data, userId) {
+    return erpDb.$transaction(async (erpTx) => {
+        const prevRev = await erpTx.orderRevision.findFirst({
+            where: { orderId },
+            orderBy: { revNo: "desc" },
+            include: {
+                operations: {
+                    include: {
+                        steps: {
+                            include: {
+                                fieldSet: { include: { fields: true } },
+                            },
+                        },
+                        predecessors: true,
+                    },
+                },
+            },
+        });
+        const nextRevNo = (prevRev?.revNo ?? 0) + 1;
+        // Seed description: explicit value > previous rev's description > order's description
+        let resolvedDescription = data.description;
+        if (resolvedDescription === undefined) {
+            if (prevRev) {
+                resolvedDescription = prevRev.description;
+            }
+            else {
+                const order = await erpTx.order.findUniqueOrThrow({
+                    where: { id: orderId },
+                });
+                resolvedDescription = order.description;
+            }
+        }
+        const newRev = await erpTx.orderRevision.create({
+            data: {
+                orderId,
+                revNo: nextRevNo,
+                description: resolvedDescription,
+                changeSummary: data.changeSummary ?? null,
+                createdById: userId,
+                updatedById: userId,
+            },
+            include: includeRevisionRelations,
+        });
+        // Copy operations, steps, fields, dependencies, and field refs from the previous revision
+        if (prevRev) {
+            const oldToNewOpId = new Map();
+            const oldToNewStepId = new Map();
+            for (const op of prevRev.operations) {
+                const newOp = await erpTx.operation.create({
+                    data: {
+                        orderRevId: newRev.id,
+                        seqNo: op.seqNo,
+                        title: op.title,
+                        description: op.description,
+                        workCenterId: op.workCenterId,
+                        createdById: userId,
+                        updatedById: userId,
+                    },
+                });
+                oldToNewOpId.set(op.id, newOp.id);
+                for (const step of op.steps) {
+                    const fields = step.fieldSet?.fields ?? [];
+                    let newFieldSetId = null;
+                    if (fields.length > 0) {
+                        const newFieldSet = await erpTx.fieldSet.create({
+                            data: { createdById: userId },
+                        });
+                        newFieldSetId = newFieldSet.id;
+                        for (const field of fields) {
+                            await erpTx.field.create({
+                                data: {
+                                    fieldSetId: newFieldSet.id,
+                                    seqNo: field.seqNo,
+                                    label: field.label,
+                                    type: field.type,
+                                    isArray: field.isArray,
+                                    required: field.required,
+                                    createdById: userId,
+                                    updatedById: userId,
+                                },
+                            });
+                        }
+                    }
+                    const newStep = await erpTx.step.create({
+                        data: {
+                            operationId: newOp.id,
+                            seqNo: step.seqNo,
+                            title: step.title,
+                            instructions: step.instructions,
+                            multiSet: step.multiSet,
+                            fieldSetId: newFieldSetId,
+                            createdById: userId,
+                            updatedById: userId,
+                        },
+                    });
+                    oldToNewStepId.set(step.id, newStep.id);
+                }
+            }
+            // Copy operation dependencies using the old-to-new ID mapping
+            for (const op of prevRev.operations) {
+                for (const dep of op.predecessors) {
+                    const newSuccessorId = oldToNewOpId.get(dep.successorId);
+                    const newPredecessorId = oldToNewOpId.get(dep.predecessorId);
+                    if (newSuccessorId && newPredecessorId) {
+                        await erpTx.operationDependency.create({
+                            data: {
+                                successorId: newSuccessorId,
+                                predecessorId: newPredecessorId,
+                                createdById: userId,
+                            },
+                        });
+                    }
+                }
+            }
+            // Copy field refs using old-to-new operation and step ID mappings
+            const oldFieldRefs = await erpTx.operationFieldRef.findMany({
+                where: {
+                    operationId: {
+                        in: [...oldToNewOpId.keys()],
+                    },
+                },
+            });
+            for (const ref of oldFieldRefs) {
+                const newOpId = oldToNewOpId.get(ref.operationId);
+                const newStepId = oldToNewStepId.get(ref.sourceStepId);
+                if (newOpId && newStepId) {
+                    await erpTx.operationFieldRef.create({
+                        data: {
+                            operationId: newOpId,
+                            seqNo: ref.seqNo,
+                            title: ref.title,
+                            sourceStepId: newStepId,
+                            createdById: userId,
+                        },
+                    });
+                }
+            }
+        }
+        return newRev;
+    });
+}
+export async function updateRevision(id, data, userId) {
+    return erpDb.orderRevision.update({
+        where: { id },
+        data: {
+            ...(data.description !== undefined
+                ? { description: data.description }
+                : {}),
+            ...(data.changeSummary !== undefined
+                ? { changeSummary: data.changeSummary }
+                : {}),
+            updatedById: userId,
+        },
+        include: includeRevisionRelations,
+    });
+}
+export async function deleteRevision(id) {
+    await erpDb.$transaction(async (erpTx) => {
+        // Delete child records bottom-up: step fields → steps → operations → revision
+        const operations = await erpTx.operation.findMany({
+            where: { orderRevId: id },
+            select: { id: true },
+        });
+        const opIds = operations.map((op) => op.id);
+        if (opIds.length > 0) {
+            // Delete field refs first (sourceStepId FK is Restrict, so must go before steps)
+            await erpTx.operationFieldRef.deleteMany({
+                where: { operationId: { in: opIds } },
+            });
+            const steps = await erpTx.step.findMany({
+                where: { operationId: { in: opIds } },
+                select: { id: true, fieldSetId: true },
+            });
+            const fieldSetIds = steps
+                .map((s) => s.fieldSetId)
+                .filter((id) => id !== null);
+            // Steps reference field_sets via FK, so delete steps first
+            await erpTx.step.deleteMany({
+                where: { operationId: { in: opIds } },
+            });
+            // Fields cascade-delete from field_sets
+            if (fieldSetIds.length > 0) {
+                await erpTx.fieldSet.deleteMany({
+                    where: { id: { in: fieldSetIds } },
+                });
+            }
+            await erpTx.operation.deleteMany({
+                where: { orderRevId: id },
+            });
+        }
+        await erpTx.orderRevision.delete({ where: { id } });
+    });
+}
+export async function transitionStatus(id, action, fromStatus, toStatus, userId) {
+    return erpDb.$transaction(async (erpTx) => {
+        const updated = await erpTx.orderRevision.update({
+            where: { id },
+            data: { status: toStatus, updatedById: userId },
+            include: includeRevisionRelations,
+        });
+        await writeAuditEntry(erpTx, "OrderRevision", id, action, "status", fromStatus, toStatus, userId);
+        return updated;
+    });
+}
+//# sourceMappingURL=order-revision-service.js.map

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

@@ -0,0 +1,356 @@
+import { OperationRunStatus as OperationRunStatusValues, OrderRunStatus as OrderRunStatusValues, } from "@naisys/erp-shared";
+import { writeAuditEntry } from "../audit.js";
+import erpDb from "../erpDb.js";
+// --- Prisma include & result type ---
+export const includeRev = {
+    orderRev: { select: { revNo: true } },
+    order: { select: { item: { select: { key: true } } } },
+    itemInstances: { select: { id: true, key: true }, take: 1 },
+    createdBy: { select: { username: true } },
+    updatedBy: { select: { username: true } },
+};
+// --- Lookups ---
+export async function listOrderRuns(where, page, pageSize) {
+    const [items, total] = await Promise.all([
+        erpDb.orderRun.findMany({
+            where,
+            include: includeRev,
+            skip: (page - 1) * pageSize,
+            take: pageSize,
+            orderBy: { createdAt: "desc" },
+        }),
+        erpDb.orderRun.count({ where }),
+    ]);
+    return { items, total };
+}
+export async function getOrderRun(id) {
+    return erpDb.orderRun.findUnique({
+        where: { id },
+        include: includeRev,
+    });
+}
+export async function findExisting(id, orderId) {
+    const existing = await erpDb.orderRun.findUnique({ where: { id } });
+    if (!existing || existing.orderId !== orderId)
+        return null;
+    return existing;
+}
+export async function getOrderRunOpSummary(orderRunId) {
+    return erpDb.operationRun.findMany({
+        where: { orderRunId },
+        select: {
+            operation: { select: { seqNo: true, title: true } },
+            status: true,
+        },
+        orderBy: { operation: { seqNo: "asc" } },
+    });
+}
+// --- Validation ---
+export function validateStatusFor(action, currentStatus, allowedStatuses) {
+    if (!allowedStatuses.includes(currentStatus)) {
+        return `Cannot ${action} order run in ${currentStatus} status`;
+    }
+    return null;
+}
+export async function checkOpsComplete(orderRunId) {
+    const incompleteOps = await erpDb.operationRun.findMany({
+        where: {
+            orderRunId,
+            status: {
+                notIn: [
+                    OperationRunStatusValues.completed,
+                    OperationRunStatusValues.skipped,
+                ],
+            },
+        },
+        include: { operation: { select: { seqNo: true, title: true } } },
+    });
+    if (incompleteOps.length === 0)
+        return null;
+    const labels = incompleteOps.map((op) => `Op ${op.operation.seqNo} "${op.operation.title}" (${op.status})`);
+    return `Cannot close order run: incomplete operations — ${labels.join(", ")}`;
+}
+export async function sumOpRunCosts(orderRunId) {
+    const result = await erpDb.operationRun.aggregate({
+        where: { orderRunId },
+        _sum: { cost: true },
+    });
+    return Math.round((result._sum.cost ?? 0) * 100) / 100;
+}
+// --- Mutations ---
+export async function createOrderRun(orderId, orderRevId, data, userId) {
+    return erpDb.$transaction(async (erpTx) => {
+        const maxOrder = await erpTx.orderRun.findFirst({
+            where: { orderId },
+            orderBy: { runNo: "desc" },
+            select: { runNo: true },
+        });
+        const nextRunNo = (maxOrder?.runNo ?? 0) + 1;
+        const orderRun = await erpTx.orderRun.create({
+            data: {
+                runNo: nextRunNo,
+                orderId,
+                orderRevId,
+                priority: data.priority,
+                dueAt: data.dueAt ?? null,
+                releaseNote: data.releaseNote ?? null,
+                createdById: userId,
+                updatedById: userId,
+            },
+            include: includeRev,
+        });
+        // Fetch operations -> steps -> fields for this revision
+        const operations = await erpTx.operation.findMany({
+            where: { orderRevId },
+            include: {
+                steps: {
+                    include: { fieldSet: { include: { fields: true } } },
+                    orderBy: { seqNo: "asc" },
+                },
+                predecessors: { select: { predecessorId: true } },
+            },
+            orderBy: { seqNo: "asc" },
+        });
+        // Create OperationRun -> StepRun -> FieldRecord -> FieldValue rows
+        for (const op of operations) {
+            // Ops with predecessors start blocked; ops without start pending
+            const initialStatus = op.predecessors.length > 0
+                ? OperationRunStatusValues.blocked
+                : OperationRunStatusValues.pending;
+            const opRun = await erpTx.operationRun.create({
+                data: {
+                    orderRunId: orderRun.id,
+                    operationId: op.id,
+                    status: initialStatus,
+                    createdById: userId,
+                    updatedById: userId,
+                },
+            });
+            for (const step of op.steps) {
+                const stepRun = await erpTx.stepRun.create({
+                    data: {
+                        operationRunId: opRun.id,
+                        stepId: step.id,
+                        createdById: userId,
+                        updatedById: userId,
+                    },
+                });
+                const fields = step.fieldSet?.fields ?? [];
+                if (fields.length > 0 && step.fieldSetId) {
+                    const fieldRecord = await erpTx.fieldRecord.create({
+                        data: { fieldSetId: step.fieldSetId, createdById: userId },
+                    });
+                    await erpTx.stepRun.update({
+                        where: { id: stepRun.id },
+                        data: { fieldRecordId: fieldRecord.id },
+                    });
+                    for (const field of fields) {
+                        await erpTx.fieldValue.create({
+                            data: {
+                                fieldRecordId: fieldRecord.id,
+                                fieldId: field.id,
+                                value: "",
+                                createdById: userId,
+                                updatedById: userId,
+                            },
+                        });
+                    }
+                }
+            }
+        }
+        return orderRun;
+    });
+}
+export async function updateOrderRun(id, data, userId) {
+    const updateData = { updatedById: userId };
+    if (data.priority !== undefined)
+        updateData.priority = data.priority;
+    if (data.releaseNote !== undefined)
+        updateData.releaseNote = data.releaseNote;
+    if (data.dueAt !== undefined)
+        updateData.dueAt = data.dueAt;
+    return erpDb.orderRun.update({
+        where: { id },
+        data: updateData,
+        include: includeRev,
+    });
+}
+export async function deleteOrderRun(id) {
+    await erpDb.$transaction(async (tx) => {
+        const opRuns = await tx.operationRun.findMany({
+            where: { orderRunId: id },
+            select: { id: true },
+        });
+        const opRunIds = opRuns.map((r) => r.id);
+        if (opRunIds.length > 0) {
+            const stepRuns = await tx.stepRun.findMany({
+                where: { operationRunId: { in: opRunIds } },
+                select: { fieldRecordId: true },
+            });
+            const fieldRecordIds = stepRuns
+                .map((s) => s.fieldRecordId)
+                .filter((id) => id !== null);
+            if (fieldRecordIds.length > 0) {
+                await tx.fieldValue.deleteMany({
+                    where: { fieldRecordId: { in: fieldRecordIds } },
+                });
+            }
+            await tx.stepRun.deleteMany({
+                where: { operationRunId: { in: opRunIds } },
+            });
+            if (fieldRecordIds.length > 0) {
+                await tx.fieldRecord.deleteMany({
+                    where: { id: { in: fieldRecordIds } },
+                });
+            }
+            await tx.operationRun.deleteMany({ where: { orderRunId: id } });
+        }
+        await tx.orderRun.delete({ where: { id } });
+    });
+}
+export async function transitionStatus(id, action, fromStatus, toStatus, userId, extraData) {
+    return erpDb.$transaction(async (erpTx) => {
+        const updated = await erpTx.orderRun.update({
+            where: { id },
+            data: { status: toStatus, updatedById: userId, ...extraData },
+            include: includeRev,
+        });
+        await writeAuditEntry(erpTx, "OrderRun", id, action, "status", fromStatus, toStatus, userId);
+        return updated;
+    });
+}
+export async function findOrderRevision(orderId, revNo) {
+    return erpDb.orderRevision.findUnique({
+        where: { orderId_revNo: { orderId, revNo } },
+    });
+}
+export async function findLatestApprovedRevision(orderId) {
+    return erpDb.orderRevision.findFirst({
+        where: { orderId, status: "approved" },
+        orderBy: { revNo: "desc" },
+    });
+}
+export function getReopenTarget(currentStatus) {
+    return currentStatus === OrderRunStatusValues.closed
+        ? OrderRunStatusValues.started
+        : OrderRunStatusValues.released;
+}
+// --- Completion ---
+/**
+ * Auto-generate an instance key by finding the last instance for the item,
+ * parsing its key as a number, and incrementing. Returns the generated key
+ * or an error string if the last key is not numeric.
+ */
+async function autoGenerateInstanceKey(erpTx, itemId) {
+    const last = await erpTx.itemInstance.findFirst({
+        where: { itemId },
+        orderBy: { createdAt: "desc" },
+        select: { key: true },
+    });
+    if (!last)
+        return { key: "1" };
+    const num = Number(last.key);
+    if (isNaN(num)) {
+        return {
+            error: `Cannot auto-generate instance key: last key "${last.key}" is not numeric. Please provide a key manually.`,
+        };
+    }
+    return { key: String(Math.floor(num) + 1) };
+}
+export async function completeOrderRun(orderRunId, orderId, data, userId) {
+    return erpDb.$transaction(async (erpTx) => {
+        // Load the order with its item
+        const order = await erpTx.order.findUniqueOrThrow({
+            where: { id: orderId },
+            select: {
+                item: {
+                    select: {
+                        id: true,
+                        fieldSetId: true,
+                        fieldSet: {
+                            select: {
+                                fields: {
+                                    select: { id: true },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        if (!order.item) {
+            return { error: "Order has no item assigned — cannot complete" };
+        }
+        // Determine instance key
+        let instanceKey = data.instanceKey;
+        if (!instanceKey) {
+            const result = await autoGenerateInstanceKey(erpTx, order.item.id);
+            if ("error" in result)
+                return result;
+            instanceKey = result.key;
+        }
+        // Check for duplicate key
+        const existing = await erpTx.itemInstance.findUnique({
+            where: { itemId_key: { itemId: order.item.id, key: instanceKey } },
+        });
+        if (existing) {
+            return {
+                error: `Instance key "${instanceKey}" already exists for this item`,
+            };
+        }
+        // Create the item instance
+        const instance = await erpTx.itemInstance.create({
+            data: {
+                itemId: order.item.id,
+                orderRunId: orderRunId,
+                key: instanceKey,
+                quantity: data.quantity ?? null,
+                createdById: userId,
+                updatedById: userId,
+            },
+        });
+        // Create field record and field values if item has a field set
+        if (order.item.fieldSetId && (data.fieldValues?.length ?? 0) > 0) {
+            const fieldRecord = await erpTx.fieldRecord.create({
+                data: {
+                    fieldSetId: order.item.fieldSetId,
+                    createdById: userId,
+                },
+            });
+            await erpTx.itemInstance.update({
+                where: { id: instance.id },
+                data: { fieldRecordId: fieldRecord.id },
+            });
+            for (const fv of data.fieldValues ?? []) {
+                await erpTx.fieldValue.create({
+                    data: {
+                        fieldRecordId: fieldRecord.id,
+                        fieldId: fv.fieldId,
+                        setIndex: fv.setIndex ?? 0,
+                        value: fv.value,
+                        createdById: userId,
+                        updatedById: userId,
+                    },
+                });
+            }
+        }
+        // Sum operation run costs and transition run to closed
+        const costResult = await erpTx.operationRun.aggregate({
+            where: { orderRunId },
+            _sum: { cost: true },
+        });
+        const cost = Math.round((costResult._sum.cost ?? 0) * 100) / 100;
+        const updated = await erpTx.orderRun.update({
+            where: { id: orderRunId },
+            data: {
+                status: OrderRunStatusValues.closed,
+                cost,
+                updatedById: userId,
+            },
+            include: includeRev,
+        });
+        await writeAuditEntry(erpTx, "OrderRun", orderRunId, "complete", "status", OrderRunStatusValues.started, OrderRunStatusValues.closed, userId);
+        return { run: updated };
+    });
+}
+//# sourceMappingURL=order-run-service.js.map

package/dist/services/order-service.js

@@ -0,0 +1,68 @@
+import erpDb from "../erpDb.js";
+import { includeUsers } from "../route-helpers.js";
+// --- Prisma include & result type ---
+const includeOrderRelations = {
+    ...includeUsers,
+    item: { select: { key: true } },
+};
+// --- Lookups ---
+export async function listOrders(where, page, pageSize) {
+    return Promise.all([
+        erpDb.order.findMany({
+            where,
+            include: includeOrderRelations,
+            skip: (page - 1) * pageSize,
+            take: pageSize,
+            orderBy: { createdAt: "desc" },
+        }),
+        erpDb.order.count({ where }),
+    ]);
+}
+export async function findExisting(key) {
+    return erpDb.order.findUnique({
+        where: { key },
+        include: includeOrderRelations,
+    });
+}
+// --- Validation ---
+export async function checkHasRevisions(orderId) {
+    const revisionCount = await erpDb.orderRevision.count({
+        where: { orderId },
+    });
+    return revisionCount > 0;
+}
+// --- Mutations ---
+export async function resolveItemKey(itemKey) {
+    if (!itemKey)
+        return null;
+    const item = await erpDb.item.findUnique({
+        where: { key: itemKey },
+        select: { id: true },
+    });
+    if (!item)
+        throw new Error(`Item '${itemKey}' not found`);
+    return item.id;
+}
+export async function createOrder(key, description, itemId, userId) {
+    return erpDb.order.create({
+        data: {
+            key,
+            description,
+            itemId,
+            createdById: userId,
+            updatedById: userId,
+        },
+        include: includeOrderRelations,
+    });
+}
+export async function updateOrder(key, data, userId) {
+    return erpDb.order.update({
+        where: { key },
+        data: { ...data, updatedById: userId },
+        include: includeOrderRelations,
+    });
+}
+export async function deleteOrder(key) {
+    await erpDb.order.delete({ where: { key } });
+}
+//# sourceMappingURL=order-service.js.map