@naisys/erp 3.0.0-beta.3

package/dist/services/labor-ticket-service.d.ts

@@ -0,0 +1,40 @@
+import type { LaborTicketModel } from "../generated/prisma/models/LaborTicket.js";
+export declare const includeLaborTicket: {
+    readonly user: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+    readonly createdBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+    readonly updatedBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+};
+export type LaborTicketWithUser = LaborTicketModel & {
+    user: {
+        username: string;
+    };
+    createdBy: {
+        username: string;
+    };
+    updatedBy: {
+        username: string;
+    };
+};
+export declare function isUserClockedIn(operationRunId: number, userId: number): Promise<boolean>;
+export declare function listLaborTickets(operationRunId: number): Promise<LaborTicketWithUser[]>;
+export declare function clockIn(operationRunId: number, userId: number, actorId: number): Promise<LaborTicketWithUser>;
+export declare function clockOut(operationRunId: number, opts: {
+    userId?: number;
+    ticketId?: number;
+}, actorId: number): Promise<LaborTicketWithUser[]>;
+export declare function clockOutAllForOpRun(operationRunId: number, actorId: number): Promise<void>;
+export declare function sumLaborTicketCosts(operationRunId: number): Promise<number>;
+export declare function deleteLaborTicket(ticketId: number, actorId: number): Promise<void>;
+//# sourceMappingURL=labor-ticket-service.d.ts.map

package/dist/services/labor-ticket-service.js

@@ -0,0 +1,148 @@
+import { getLatestRunInfoByUuid, sumCostsByUuid } from "@naisys/hub-database";
+import { writeAuditEntry } from "../audit.js";
+import erpDb from "../erpDb.js";
+// --- Prisma include & result type ---
+export const includeLaborTicket = {
+    user: { select: { username: true } },
+    createdBy: { select: { username: true } },
+    updatedBy: { select: { username: true } },
+};
+// --- Helpers ---
+/**
+ * Compute the cost for a labor ticket at clock-out time.
+ * Agents: sum of hub cost entries for the user within the clock-in/out window.
+ * Non-agents: 0.
+ */
+async function computeCost(userId, clockIn, clockOut) {
+    const user = await erpDb.user.findUnique({
+        where: { id: userId },
+        select: { isAgent: true, uuid: true },
+    });
+    if (!user?.isAgent)
+        return 0;
+    const cost = await sumCostsByUuid(user.uuid, clockIn, clockOut);
+    return Math.round(cost * 100) / 100;
+}
+/**
+ * Get the current hub run info (run_id + session start) for an agent user.
+ */
+async function getAgentRunInfo(userId) {
+    const user = await erpDb.user.findUnique({
+        where: { id: userId },
+        select: { isAgent: true, uuid: true },
+    });
+    if (!user?.isAgent)
+        return null;
+    return getLatestRunInfoByUuid(user.uuid);
+}
+// --- Lookups ---
+export async function isUserClockedIn(operationRunId, userId) {
+    const ticket = await erpDb.laborTicket.findFirst({
+        where: { operationRunId, userId, clockOut: null },
+    });
+    return !!ticket;
+}
+export async function listLaborTickets(operationRunId) {
+    return erpDb.laborTicket.findMany({
+        where: { operationRunId },
+        include: includeLaborTicket,
+        orderBy: { clockIn: "desc" },
+    });
+}
+// --- Mutations ---
+export async function clockIn(operationRunId, userId, actorId) {
+    const now = new Date();
+    const runInfo = await getAgentRunInfo(userId);
+    const runId = runInfo?.runId ?? null;
+    // If already clocked into this op run, just return the existing ticket
+    const existing = await erpDb.laborTicket.findFirst({
+        where: { operationRunId, userId, clockOut: null },
+        include: includeLaborTicket,
+    });
+    if (existing)
+        return existing;
+    return erpDb.$transaction(async (tx) => {
+        // Auto clock-out all open tickets for this user (globally)
+        const openTickets = await tx.laborTicket.findMany({
+            where: { userId, clockOut: null },
+        });
+        for (const ticket of openTickets) {
+            const cost = await computeCost(userId, ticket.clockIn, now);
+            await tx.laborTicket.update({
+                where: { id: ticket.id },
+                data: { clockOut: now, cost, updatedById: actorId },
+            });
+        }
+        // If no tickets were auto-closed and this is the first ticket for the
+        // current run/session, backdate clockIn to the session start so that
+        // startup costs (before the agent called clock-in) are captured.
+        let clockInTime = now;
+        if (runInfo && openTickets.length === 0) {
+            const existingForRun = await tx.laborTicket.findFirst({
+                where: { userId, runId },
+            });
+            if (!existingForRun) {
+                clockInTime = runInfo.sessionStart;
+            }
+        }
+        // Create new ticket
+        return tx.laborTicket.create({
+            data: {
+                operationRunId,
+                userId,
+                runId,
+                clockIn: clockInTime,
+                createdById: actorId,
+                updatedById: actorId,
+                updatedAt: now,
+            },
+            include: includeLaborTicket,
+        });
+    });
+}
+export async function clockOut(operationRunId, opts, actorId) {
+    const now = new Date();
+    return erpDb.$transaction(async (tx) => {
+        // Build where clause based on opts
+        const where = {
+            operationRunId,
+            clockOut: null,
+        };
+        if (opts.ticketId) {
+            where.id = opts.ticketId;
+        }
+        else if (opts.userId) {
+            where.userId = opts.userId;
+        }
+        // If neither specified, clocks out ALL open tickets for the op run
+        const openTickets = await tx.laborTicket.findMany({ where });
+        const updated = [];
+        for (const ticket of openTickets) {
+            const cost = await computeCost(ticket.userId, ticket.clockIn, now);
+            const result = await tx.laborTicket.update({
+                where: { id: ticket.id },
+                data: { clockOut: now, cost, updatedById: actorId },
+                include: includeLaborTicket,
+            });
+            updated.push(result);
+        }
+        return updated;
+    });
+}
+export async function clockOutAllForOpRun(operationRunId, actorId) {
+    await clockOut(operationRunId, {}, actorId);
+}
+export async function sumLaborTicketCosts(operationRunId) {
+    const result = await erpDb.laborTicket.aggregate({
+        where: { operationRunId },
+        _sum: { cost: true },
+    });
+    return Math.round((result._sum.cost ?? 0) * 100) / 100;
+}
+export async function deleteLaborTicket(ticketId, actorId) {
+    await erpDb.$transaction(async (tx) => {
+        await tx.laborTicket.delete({ where: { id: ticketId } });
+        await writeAuditEntry(tx, "LaborTicket", ticketId, "delete", "id", String(ticketId), null, actorId);
+    });
+}
+//# sourceMappingURL=labor-ticket-service.js.map

package/dist/services/log-file-service.d.ts

@@ -0,0 +1,4 @@
+import { tailLogFile } from "@naisys/common-node";
+export { tailLogFile };
+export declare function getErpLogPath(): string;
+//# sourceMappingURL=log-file-service.d.ts.map

package/dist/services/log-file-service.js

@@ -0,0 +1,11 @@
+import path from "node:path";
+import { tailLogFile } from "@naisys/common-node";
+export { tailLogFile };
+export function getErpLogPath() {
+    const naisysFolder = process.env.NAISYS_FOLDER;
+    if (!naisysFolder) {
+        throw new Error("NAISYS_FOLDER environment variable is not set.");
+    }
+    return path.join(naisysFolder, "logs", "erp.log");
+}
+//# sourceMappingURL=log-file-service.js.map

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

@@ -0,0 +1,33 @@
+export type DependencyWithDetails = Awaited<ReturnType<typeof listDependencies>>[number];
+export declare function listDependencies(operationId: number): Promise<({
+    createdBy: {
+        username: string;
+    };
+    predecessor: {
+        title: string;
+        seqNo: number;
+    };
+} & {
+    createdAt: Date;
+    id: number;
+    createdById: number;
+    successorId: number;
+    predecessorId: number;
+})[]>;
+export declare function createDependency(successorId: number, predecessorId: number, userId: number): Promise<{
+    createdBy: {
+        username: string;
+    };
+    predecessor: {
+        title: string;
+        seqNo: number;
+    };
+} & {
+    createdAt: Date;
+    id: number;
+    createdById: number;
+    successorId: number;
+    predecessorId: number;
+}>;
+export declare function deleteDependency(successorId: number, predecessorId: number): Promise<void>;
+//# sourceMappingURL=operation-dependency-service.d.ts.map

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

@@ -0,0 +1,30 @@
+import erpDb from "../erpDb.js";
+const depInclude = {
+    predecessor: { select: { seqNo: true, title: true } },
+    createdBy: { select: { username: true } },
+};
+export async function listDependencies(operationId) {
+    return erpDb.operationDependency.findMany({
+        where: { successorId: operationId },
+        include: depInclude,
+        orderBy: { predecessor: { seqNo: "asc" } },
+    });
+}
+export async function createDependency(successorId, predecessorId, userId) {
+    return erpDb.operationDependency.create({
+        data: {
+            successorId,
+            predecessorId,
+            createdById: userId,
+        },
+        include: depInclude,
+    });
+}
+export async function deleteDependency(successorId, predecessorId) {
+    await erpDb.operationDependency.delete({
+        where: {
+            successorId_predecessorId: { successorId, predecessorId },
+        },
+    });
+}
+//# sourceMappingURL=operation-dependency-service.js.map

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

@@ -0,0 +1,17 @@
+import type { OperationRunCommentType } from "@naisys/erp-shared";
+import type { OperationRunCommentModel } from "../generated/prisma/models/OperationRunComment.js";
+export declare const includeComment: {
+    readonly createdBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+};
+export type CommentWithUser = OperationRunCommentModel & {
+    createdBy: {
+        username: string;
+    };
+};
+export declare function listComments(operationRunId: number): Promise<CommentWithUser[]>;
+export declare function createComment(operationRunId: number, type: OperationRunCommentType, body: string, userId: number): Promise<CommentWithUser>;
+//# sourceMappingURL=operation-run-comment-service.d.ts.map

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

@@ -0,0 +1,26 @@
+import erpDb from "../erpDb.js";
+// --- Prisma include & result type ---
+export const includeComment = {
+    createdBy: { select: { username: true } },
+};
+// --- Lookups ---
+export async function listComments(operationRunId) {
+    return erpDb.operationRunComment.findMany({
+        where: { operationRunId },
+        include: includeComment,
+        orderBy: { createdAt: "asc" },
+    });
+}
+// --- Mutations ---
+export async function createComment(operationRunId, type, body, userId) {
+    return erpDb.operationRunComment.create({
+        data: {
+            operationRunId,
+            type,
+            body,
+            createdById: userId,
+        },
+        include: includeComment,
+    });
+}
+//# sourceMappingURL=operation-run-comment-service.js.map

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

@@ -0,0 +1,126 @@
+import { type OperationRunStatus } from "@naisys/erp-shared";
+import { type FieldRefValueSummary } from "@naisys/erp-shared";
+import type { OperationRunModel } from "../generated/prisma/models/OperationRun.js";
+export declare const includeOp: {
+    readonly operation: {
+        readonly select: {
+            readonly seqNo: true;
+            readonly title: true;
+            readonly description: true;
+            readonly workCenter: {
+                readonly select: {
+                    readonly key: true;
+                };
+            };
+        };
+    };
+    readonly assignedTo: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+    readonly createdBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+    readonly updatedBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+};
+export type OpRunWithOp = OperationRunModel & {
+    operation: {
+        seqNo: number;
+        title: string;
+        description: string;
+        workCenter: {
+            key: string;
+        } | null;
+    };
+    assignedTo: {
+        username: string;
+    } | null;
+    createdBy: {
+        username: string;
+    };
+    updatedBy: {
+        username: string;
+    };
+};
+export type OpRunWithSummary = OpRunWithOp & {
+    _count: {
+        stepRuns: number;
+    };
+    operation: {
+        seqNo: number;
+        title: string;
+        description: string;
+        workCenter: {
+            key: string;
+        } | null;
+        predecessors: Array<{
+            predecessor: {
+                seqNo: number;
+                title: string;
+            };
+        }>;
+    };
+};
+export declare function listOpRuns(runId: number): Promise<OpRunWithSummary[]>;
+export declare function getOpRun(id: number): Promise<OpRunWithOp | null>;
+export declare function findExisting(id: number, runId: number): Promise<({
+    operation: {
+        seqNo: number;
+    };
+} & {
+    operationId: number;
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+    orderRunId: number;
+    status: import("../generated/prisma/enums.js").OperationRunStatus;
+    assignedToId: number | null;
+    createdById: number;
+    updatedById: number;
+    cost: number | null;
+    statusNote: string | null;
+    completedAt: Date | null;
+}) | null>;
+export declare function getOpRunStepSummary(opRunId: number): Promise<{
+    step: {
+        title: string;
+        seqNo: number;
+    };
+    completed: boolean;
+}[]>;
+/**
+ * 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 declare function getOpRunFieldRefSummary(operationId: number, orderRunId: number, orderKey: string, runNo: number): Promise<FieldRefValueSummary[]>;
+export declare function validateStatusFor(action: string, currentStatus: string, allowedStatuses: string[]): string | null;
+/**
+ * Check that all predecessor dependencies for this operation are complete.
+ * Uses the OperationDependency graph rather than seqNo ordering.
+ */
+export declare function checkPredecessorsComplete(runId: number, operationId: number): Promise<string | null>;
+/**
+ * After completing/skipping an operation, unblock successor ops
+ * whose predecessors are now all complete.
+ */
+export declare function unblockSuccessors(runId: number, operationId: number, userId: number): Promise<void>;
+/**
+ * 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 declare function reblockSuccessors(runId: number, operationId: number, userId: number): Promise<void>;
+export declare function checkStepsComplete(opRunId: number): Promise<string | null>;
+export declare function updateOpRun(id: number, data: {
+    assignedToId?: number | null;
+}, userId: number): Promise<OpRunWithOp>;
+export declare function transitionStatus(id: number, action: string, fromStatus: OperationRunStatus, toStatus: OperationRunStatus, userId: number, extraData?: Record<string, unknown>): Promise<OpRunWithOp>;
+//# sourceMappingURL=operation-run-service.d.ts.map