@naisys/erp 3.0.0-beta.3

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.d.ts

@@ -0,0 +1,15 @@
+import type { OrderModel } from "../generated/prisma/models/Order.js";
+import { type WithAuditUsers } from "../route-helpers.js";
+export type OrderWithRelations = OrderModel & WithAuditUsers & {
+    item: {
+        key: string;
+    } | null;
+};
+export declare function listOrders(where: Record<string, unknown>, page: number, pageSize: number): Promise<[OrderWithRelations[], number]>;
+export declare function findExisting(key: string): Promise<OrderWithRelations | null>;
+export declare function checkHasRevisions(orderId: number): Promise<boolean>;
+export declare function resolveItemKey(itemKey: string | undefined | null): Promise<number | null>;
+export declare function createOrder(key: string, description: string | undefined, itemId: number | null, userId: number): Promise<OrderWithRelations>;
+export declare function updateOrder(key: string, data: Record<string, unknown>, userId: number): Promise<OrderWithRelations>;
+export declare function deleteOrder(key: string): Promise<void>;
+//# sourceMappingURL=order-service.d.ts.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

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

@@ -0,0 +1,3 @@
+import type { RevisionDiffResponse } from "@naisys/erp-shared";
+export declare function diffRevisions(orderId: number, fromRevNo: number, toRevNo: number): Promise<RevisionDiffResponse | null>;
+//# sourceMappingURL=revision-diff-service.d.ts.map

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

@@ -0,0 +1,194 @@
+import erpDb from "../erpDb.js";
+// --- Prisma deep include for full revision tree ---
+const includeFullTree = {
+    operations: {
+        orderBy: { seqNo: "asc" },
+        include: {
+            steps: {
+                orderBy: { seqNo: "asc" },
+                include: {
+                    fieldSet: {
+                        include: { fields: { orderBy: { seqNo: "asc" } } },
+                    },
+                },
+            },
+            predecessors: {
+                include: {
+                    predecessor: { select: { seqNo: true, title: true } },
+                },
+            },
+        },
+    },
+};
+async function getRevisionTree(orderId, revNo) {
+    return erpDb.orderRevision.findFirst({
+        where: { orderId, revNo },
+        include: includeFullTree,
+    });
+}
+// --- Comparison helpers ---
+function compareProps(pairs) {
+    const changes = [];
+    for (const [field, from, to] of pairs) {
+        if (from !== to) {
+            changes.push({
+                field,
+                from: from,
+                to: to,
+            });
+        }
+    }
+    return changes;
+}
+function diffFields(fromFields, toFields) {
+    const fromMap = new Map(fromFields.map((f) => [f.seqNo, f]));
+    const toMap = new Map(toFields.map((f) => [f.seqNo, f]));
+    const allSeqNos = new Set([...fromMap.keys(), ...toMap.keys()]);
+    const result = [];
+    for (const seqNo of [...allSeqNos].sort((a, b) => a - b)) {
+        const from = fromMap.get(seqNo);
+        const to = toMap.get(seqNo);
+        if (!from && to) {
+            result.push({ seqNo, label: to.label, status: "added" });
+        }
+        else if (from && !to) {
+            result.push({ seqNo, label: from.label, status: "removed" });
+        }
+        else if (from && to) {
+            const changes = compareProps([
+                ["label", from.label, to.label],
+                ["type", from.type, to.type],
+                ["isArray", from.isArray, to.isArray],
+                ["required", from.required, to.required],
+            ]);
+            result.push({
+                seqNo,
+                label: to.label,
+                status: changes.length > 0 ? "modified" : "unchanged",
+                ...(changes.length > 0 ? { changes } : {}),
+            });
+        }
+    }
+    return result;
+}
+function diffSteps(fromSteps, toSteps) {
+    const fromMap = new Map(fromSteps.map((s) => [s.seqNo, s]));
+    const toMap = new Map(toSteps.map((s) => [s.seqNo, s]));
+    const allSeqNos = new Set([...fromMap.keys(), ...toMap.keys()]);
+    const result = [];
+    for (const seqNo of [...allSeqNos].sort((a, b) => a - b)) {
+        const from = fromMap.get(seqNo);
+        const to = toMap.get(seqNo);
+        if (!from && to) {
+            result.push({ seqNo, title: to.title, status: "added" });
+        }
+        else if (from && !to) {
+            result.push({ seqNo, title: from.title, status: "removed" });
+        }
+        else if (from && to) {
+            const changes = compareProps([
+                ["title", from.title, to.title],
+                ["instructions", from.instructions, to.instructions],
+                ["multiSet", from.multiSet, to.multiSet],
+            ]);
+            const fields = diffFields(from.fieldSet?.fields ?? [], to.fieldSet?.fields ?? []);
+            const hasFieldChanges = fields.some((f) => f.status !== "unchanged");
+            const isModified = changes.length > 0 || hasFieldChanges;
+            result.push({
+                seqNo,
+                title: to.title,
+                status: isModified ? "modified" : "unchanged",
+                ...(changes.length > 0 ? { changes } : {}),
+                ...(hasFieldChanges ? { fields } : {}),
+            });
+        }
+    }
+    return result;
+}
+function diffDeps(fromDeps, toDeps) {
+    const fromSet = new Map(fromDeps.map((d) => [d.predecessor.seqNo, d.predecessor.title]));
+    const toSet = new Map(toDeps.map((d) => [d.predecessor.seqNo, d.predecessor.title]));
+    const allSeqNos = new Set([...fromSet.keys(), ...toSet.keys()]);
+    const result = [];
+    for (const seqNo of [...allSeqNos].sort((a, b) => a - b)) {
+        const fromTitle = fromSet.get(seqNo);
+        const toTitle = toSet.get(seqNo);
+        if (fromTitle === undefined && toTitle !== undefined) {
+            result.push({
+                predecessorSeqNo: seqNo,
+                predecessorTitle: toTitle,
+                status: "added",
+            });
+        }
+        else if (fromTitle !== undefined && toTitle === undefined) {
+            result.push({
+                predecessorSeqNo: seqNo,
+                predecessorTitle: fromTitle,
+                status: "removed",
+            });
+        }
+        else if (fromTitle !== undefined) {
+            result.push({
+                predecessorSeqNo: seqNo,
+                predecessorTitle: toTitle ?? fromTitle,
+                status: "unchanged",
+            });
+        }
+    }
+    return result;
+}
+function diffOperations(fromOps, toOps) {
+    const fromMap = new Map(fromOps.map((op) => [op.seqNo, op]));
+    const toMap = new Map(toOps.map((op) => [op.seqNo, op]));
+    const allSeqNos = new Set([...fromMap.keys(), ...toMap.keys()]);
+    const result = [];
+    for (const seqNo of [...allSeqNos].sort((a, b) => a - b)) {
+        const from = fromMap.get(seqNo);
+        const to = toMap.get(seqNo);
+        if (!from && to) {
+            result.push({ seqNo, title: to.title, status: "added" });
+        }
+        else if (from && !to) {
+            result.push({ seqNo, title: from.title, status: "removed" });
+        }
+        else if (from && to) {
+            const changes = compareProps([
+                ["title", from.title, to.title],
+                ["description", from.description, to.description],
+            ]);
+            const steps = diffSteps(from.steps, to.steps);
+            const deps = diffDeps(from.predecessors, to.predecessors);
+            const hasStepChanges = steps.some((s) => s.status !== "unchanged");
+            const hasDepChanges = deps.some((d) => d.status !== "unchanged");
+            const isModified = changes.length > 0 || hasStepChanges || hasDepChanges;
+            result.push({
+                seqNo,
+                title: to.title,
+                status: isModified ? "modified" : "unchanged",
+                ...(changes.length > 0 ? { changes } : {}),
+                ...(hasStepChanges ? { steps } : {}),
+                ...(hasDepChanges ? { dependencies: deps } : {}),
+            });
+        }
+    }
+    return result;
+}
+// --- Public API ---
+export async function diffRevisions(orderId, fromRevNo, toRevNo) {
+    const [fromRev, toRev] = await Promise.all([
+        getRevisionTree(orderId, fromRevNo),
+        getRevisionTree(orderId, toRevNo),
+    ]);
+    if (!fromRev || !toRev)
+        return null;
+    const revisionChanges = compareProps([
+        ["description", fromRev.description, toRev.description],
+    ]);
+    return {
+        fromRevNo,
+        toRevNo,
+        revisionChanges,
+        operations: diffOperations(fromRev.operations, toRev.operations),
+    };
+}
+//# sourceMappingURL=revision-diff-service.js.map