@naisys/erp 3.0.0-beta.3

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

@@ -0,0 +1,138 @@
+import { type OrderRunPriority, type OrderRunStatus } from "@naisys/erp-shared";
+import type { OrderRunModel } from "../generated/prisma/models/OrderRun.js";
+export declare const includeRev: {
+    readonly orderRev: {
+        readonly select: {
+            readonly revNo: true;
+        };
+    };
+    readonly order: {
+        readonly select: {
+            readonly item: {
+                readonly select: {
+                    readonly key: true;
+                };
+            };
+        };
+    };
+    readonly itemInstances: {
+        readonly select: {
+            readonly id: true;
+            readonly key: true;
+        };
+        readonly take: 1;
+    };
+    readonly createdBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+    readonly updatedBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+};
+export type OrderRunWithRev = OrderRunModel & {
+    orderRev: {
+        revNo: number;
+    };
+    order: {
+        item: {
+            key: string;
+        } | null;
+    };
+    itemInstances: {
+        id: number;
+        key: string;
+    }[];
+    createdBy: {
+        username: string;
+    };
+    updatedBy: {
+        username: string;
+    };
+};
+export declare function listOrderRuns(where: Record<string, unknown>, page: number, pageSize: number): Promise<{
+    items: OrderRunWithRev[];
+    total: number;
+}>;
+export declare function getOrderRun(id: number): Promise<OrderRunWithRev | null>;
+export declare function findExisting(id: number, orderId: number): Promise<{
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+    status: import("../generated/prisma/enums.js").OrderRunStatus;
+    priority: import("../generated/prisma/enums.js").OrderRunPriority;
+    dueAt: string | null;
+    releaseNote: string | null;
+    orderRevId: number;
+    createdById: number;
+    updatedById: number;
+    orderId: number;
+    runNo: number;
+    cost: number | null;
+} | null>;
+export declare function getOrderRunOpSummary(orderRunId: number): Promise<{
+    operation: {
+        title: string;
+        seqNo: number;
+    };
+    status: import("../generated/prisma/enums.js").OperationRunStatus;
+}[]>;
+export declare function validateStatusFor(action: string, currentStatus: string, allowedStatuses: string[]): string | null;
+export declare function checkOpsComplete(orderRunId: number): Promise<string | null>;
+export declare function sumOpRunCosts(orderRunId: number): Promise<number>;
+export declare function createOrderRun(orderId: number, orderRevId: number, data: {
+    priority: OrderRunPriority;
+    dueAt?: string | null;
+    releaseNote?: string | null;
+}, userId: number): Promise<OrderRunWithRev>;
+export declare function updateOrderRun(id: number, data: {
+    priority?: OrderRunPriority;
+    releaseNote?: string | null;
+    dueAt?: string | null;
+}, userId: number): Promise<OrderRunWithRev>;
+export declare function deleteOrderRun(id: number): Promise<void>;
+export declare function transitionStatus(id: number, action: string, fromStatus: OrderRunStatus, toStatus: OrderRunStatus, userId: number, extraData?: Record<string, unknown>): Promise<OrderRunWithRev>;
+export declare function findOrderRevision(orderId: number, revNo: number): Promise<{
+    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 findLatestApprovedRevision(orderId: number): Promise<{
+    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 getReopenTarget(currentStatus: OrderRunStatus): OrderRunStatus;
+export declare function completeOrderRun(orderRunId: number, orderId: number, data: {
+    instanceKey?: string;
+    quantity?: number | null;
+    fieldValues?: {
+        fieldId: number;
+        value: string;
+        setIndex?: number;
+    }[];
+}, userId: number): Promise<{
+    run: OrderRunWithRev;
+    error?: undefined;
+} | {
+    error: string;
+    run?: undefined;
+}>;
+//# sourceMappingURL=order-run-service.d.ts.map