@naisys/erp 3.0.0-beta.50 → 3.0.0-beta.52

package/dist/generated/prisma/internal/prismaNamespace.js

@@ -225,6 +225,7 @@ export const OperationRunScalarFieldEnum = {
     status: 'status',
     assignedToId: 'assignedToId',
     cost: 'cost',
+    tokens: 'tokens',
     statusNote: 'statusNote',
     completedAt: 'completedAt',
     createdAt: 'createdAt',
@@ -315,6 +316,7 @@ export const LaborTicketScalarFieldEnum = {
     clockIn: 'clockIn',
     clockOut: 'clockOut',
     cost: 'cost',
+    tokens: 'tokens',
     createdAt: 'createdAt',
     createdById: 'createdById',
     updatedAt: 'updatedAt',

package/dist/routes/operations/operation-run-transitions.js

@@ -4,7 +4,7 @@ import { requirePermission } from "../../middleware/auth-middleware.js";
 import { checkOrderRunStarted, checkWorkCenterAccess, mutationResult, resolveOpRun, } from "../../route-helpers.js";
 import { checkPredecessorsComplete, checkStepsComplete, reblockSuccessors, transitionStatus, unblockSuccessors, validateStatusFor, } from "../../services/operations/operation-run-service.js";
 import { transitionStatus as transitionOrderRunStatus } from "../../services/orders/order-run-service.js";
-import { clockIn, clockOutAllForOpRun, isUserClockedIn, sumLaborTicketCosts, } from "../../services/production/labor-ticket-service.js";
+import { clockIn, clockOutAllForOpRun, isUserClockedIn, sumLaborTicketMetrics, } from "../../services/production/labor-ticket-service.js";
 import { formatOpRunTransition, SeqNoParamsSchema } from "./operation-runs.js";
 export default function operationRunTransitionRoutes(fastify) {
     const app = fastify.withTypeProvider();
@@ -99,10 +99,11 @@ export default function operationRunTransitionRoutes(fastify) {
             if (stepsErr)
                 return unprocessable(reply, stepsErr);
             await clockOutAllForOpRun(resolved.opRun.id, userId);
-            const cost = await sumLaborTicketCosts(resolved.opRun.id);
+            const { cost, tokens } = await sumLaborTicketMetrics(resolved.opRun.id);
             const opRun = await transitionStatus(resolved.opRun.id, "complete", OperationRunStatus.in_progress, OperationRunStatus.completed, userId, {
                 completedAt: new Date(),
                 cost,
+                tokens,
                 statusNote: note ?? null,
             });
             await unblockSuccessors(resolved.run.id, resolved.opRun.operationId, userId);
@@ -153,8 +154,12 @@ export default function operationRunTransitionRoutes(fastify) {
             if (resolved.opRun.status === OperationRunStatus.in_progress) {
                 await clockOutAllForOpRun(resolved.opRun.id, userId);
             }
-            const cost = await sumLaborTicketCosts(resolved.opRun.id);
-            const opRun = await transitionStatus(resolved.opRun.id, "skip", resolved.opRun.status, OperationRunStatus.skipped, userId, { ...(cost > 0 ? { cost } : undefined), statusNote: note ?? null });
+            const { cost, tokens } = await sumLaborTicketMetrics(resolved.opRun.id);
+            const opRun = await transitionStatus(resolved.opRun.id, "skip", resolved.opRun.status, OperationRunStatus.skipped, userId, {
+                ...(cost > 0 ? { cost } : undefined),
+                ...(tokens > 0 ? { tokens } : undefined),
+                statusNote: note ?? null,
+            });
             await unblockSuccessors(resolved.run.id, resolved.opRun.operationId, userId);
             const full = await formatOpRunTransition(orderKey, runNo, request.erpUser, opRun);
             return mutationResult(request, reply, full, {
@@ -196,8 +201,12 @@ export default function operationRunTransitionRoutes(fastify) {
             if (statusErr)
                 return conflict(reply, statusErr);
             await clockOutAllForOpRun(resolved.opRun.id, userId);
-            const cost = await sumLaborTicketCosts(resolved.opRun.id);
-            const opRun = await transitionStatus(resolved.opRun.id, "fail", OperationRunStatus.in_progress, OperationRunStatus.failed, userId, { ...(cost > 0 ? { cost } : undefined), statusNote: note ?? null });
+            const { cost, tokens } = await sumLaborTicketMetrics(resolved.opRun.id);
+            const opRun = await transitionStatus(resolved.opRun.id, "fail", OperationRunStatus.in_progress, OperationRunStatus.failed, userId, {
+                ...(cost > 0 ? { cost } : undefined),
+                ...(tokens > 0 ? { tokens } : undefined),
+                statusNote: note ?? null,
+            });
             const full = await formatOpRunTransition(orderKey, runNo, request.erpUser, opRun);
             return mutationResult(request, reply, full, {
                 status: opRun.status,

package/dist/routes/operations/operation-runs.js

@@ -5,16 +5,25 @@ import { API_PREFIX, selfLink } from "../../hateoas.js";
 import { hasPermission, requirePermission, } from "../../middleware/auth-middleware.js";
 import { checkOrderRunStarted, checkWorkCenterAccess, childItemLinks, formatAuditFields, formatDate, resolveActions, resolveOpRun, resolveOrderRun, useFullSerializer, wantsFullResponse, } from "../../route-helpers.js";
 import { checkStepsComplete, getOpRun, getOpRunFieldRefSummary, getOpRunStepSummary, listOpRuns, updateOpRun, validateStatusFor, } from "../../services/operations/operation-run-service.js";
+import { isUserClockedIn } from "../../services/production/labor-ticket-service.js";
 function opRunResource(orderKey, runNo) {
     return `orders/${orderKey}/runs/${runNo}/ops`;
 }
 async function opRunItemActions(orderKey, runNo, seqNo, opRunId, operationId, status, user) {
     const href = `${API_PREFIX}/${opRunResource(orderKey, runNo)}/${seqNo}`;
     const isExecutor = hasPermission(user, "order_executor");
-    const stepsErr = isExecutor && status === OperationRunStatus.in_progress
-        ? await checkStepsComplete(opRunId)
-        : null;
+    const isInProgress = status === OperationRunStatus.in_progress;
+    const stepsErr = isExecutor && isInProgress ? await checkStepsComplete(opRunId) : null;
     const wcErr = user ? await checkWorkCenterAccess(operationId, user) : null;
+    // Completing an op requires the caller to be clocked in (enforced by the
+    // /complete transition). Surface clock-in and the requirement here so an
+    // agent inspecting the op run finds it without following the `labor` link.
+    const userClockedIn = isExecutor && isInProgress && user
+        ? await isUserClockedIn(opRunId, user.id)
+        : false;
+    const notClockedInErr = isExecutor && isInProgress && !userClockedIn
+        ? "You must be clocked in to complete an operation"
+        : null;
     return resolveActions([
         {
             rel: "assign",
@@ -50,6 +59,18 @@ async function opRunItemActions(orderKey, runNo, seqNo, opRunId, operationId, st
                     ? "Operation is blocked by incomplete predecessors"
                     : null),
         },
+        {
+            rel: "clock-in",
+            path: "/labor/clock-in",
+            method: "POST",
+            title: "Clock In",
+            permission: "order_executor",
+            statuses: [OperationRunStatus.in_progress],
+            disabledWhen: () => wcErr ??
+                (userClockedIn
+                    ? "You are already clocked in to this operation"
+                    : null),
+        },
         {
             rel: "update",
             method: "PUT",
@@ -68,7 +89,7 @@ async function opRunItemActions(orderKey, runNo, seqNo, opRunId, operationId, st
             body: { note: "" },
             permission: "order_executor",
             statuses: [OperationRunStatus.in_progress],
-            disabledWhen: () => wcErr ?? stepsErr,
+            disabledWhen: () => wcErr ?? notClockedInErr ?? stepsErr,
         },
         {
             rel: "skip",
@@ -136,6 +157,7 @@ export async function formatOpRun(orderKey, runNo, user, opRun) {
         status: opRun.status,
         assignedTo: opRun.assignedTo?.username ?? null,
         cost: opRun.cost,
+        tokens: opRun.tokens,
         note: opRun.statusNote ?? null,
         completedAt: formatDate(opRun.completedAt),
         stepSummary: stepSummaryRows.map((sr) => ({
@@ -182,6 +204,7 @@ export async function formatOpRunTransition(orderKey, runNo, user, opRun) {
         status: opRun.status,
         assignedTo: opRun.assignedTo?.username ?? null,
         cost: opRun.cost,
+        tokens: opRun.tokens,
         note: opRun.statusNote ?? null,
         completedAt: formatDate(opRun.completedAt),
         ...formatAuditFields(opRun),
@@ -203,6 +226,7 @@ function formatListOpRun(opRun) {
         status: opRun.status,
         assignedTo: opRun.assignedTo?.username ?? null,
         cost: opRun.cost,
+        tokens: opRun.tokens,
         note: opRun.statusNote ?? null,
         completedAt: formatDate(opRun.completedAt),
         ...formatAuditFields(opRun),

package/dist/routes/production/labor-tickets.js

@@ -92,6 +92,7 @@ function formatLaborTicket(orderKey, runNo, seqNo, ticket) {
         clockIn: ticket.clockIn.toISOString(),
         clockOut: formatDate(ticket.clockOut),
         cost: ticket.cost,
+        tokens: ticket.tokens,
         ...formatAuditFields(ticket),
         _links: [
             selfLink(`/${laborResource(orderKey, runNo, seqNo)}/${ticket.id}`),

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

@@ -1,3 +1,4 @@
+import { keyBy } from "@naisys/common";
 import { OperationRunStatus as OperationRunStatusValues, } from "@naisys/erp-shared";
 import { fieldTypeString, getValueFormatHint, } from "@naisys/erp-shared";
 import erpDb from "../../database/erpDb.js";
@@ -153,7 +154,7 @@ export async function getOpRunFieldRefSummary(operationId, orderRunId, orderKey,
             },
         },
     });
-    const stepRunMap = new Map(stepRuns.map((sr) => [sr.stepId, sr]));
+    const stepRunMap = keyBy(stepRuns, (sr) => sr.stepId);
     return fieldRefs.map((ref) => {
         const sr = stepRunMap.get(ref.sourceStep.id);
         const storedFieldValues = sr?.fieldRecord?.fieldValues ?? [];

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

@@ -1,3 +1,4 @@
+import { mapDefined } from "@naisys/common";
 import { RevisionStatus as RevisionStatusValues, } from "@naisys/erp-shared";
 import erpDb from "../../database/erpDb.js";
 import { includeUsers } from "../../route-helpers.js";
@@ -230,9 +231,7 @@ export async function deleteRevision(id) {
                 where: { operationId: { in: opIds } },
                 select: { id: true, fieldSetId: true },
             });
-            const fieldSetIds = steps
-                .map((s) => s.fieldSetId)
-                .filter((id) => id !== null);
+            const fieldSetIds = mapDefined(steps, (s) => s.fieldSetId);
             // Steps reference field_sets via FK, so delete steps first
             await erpTx.step.deleteMany({
                 where: { operationId: { in: opIds } },

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

@@ -1,3 +1,4 @@
+import { keyBy, mapDefined } from "@naisys/common";
 import { OperationRunStatus as OperationRunStatusValues, OrderRunStatus as OrderRunStatusValues, } from "@naisys/erp-shared";
 import erpDb from "../../database/erpDb.js";
 import { writeAuditEntry } from "../audit.js";
@@ -188,9 +189,7 @@ export async function deleteOrderRun(id) {
                 where: { operationRunId: { in: opRunIds } },
                 select: { fieldRecordId: true },
             });
-            const fieldRecordIds = stepRuns
-                .map((s) => s.fieldRecordId)
-                .filter((id) => id !== null);
+            const fieldRecordIds = mapDefined(stepRuns, (s) => s.fieldRecordId);
             if (fieldRecordIds.length > 0) {
                 await tx.fieldValue.deleteMany({
                     where: { fieldRecordId: { in: fieldRecordIds } },
@@ -294,8 +293,8 @@ export async function completeOrderRun(orderRunId, orderId, data, userId) {
             };
         }
         const itemFields = order.item.fieldSet?.fields ?? [];
-        const fieldsBySeqNo = new Map(itemFields.map((f) => [f.seqNo, f]));
-        const fieldsById = new Map(itemFields.map((f) => [f.id, f]));
+        const fieldsBySeqNo = keyBy(itemFields, (f) => f.seqNo);
+        const fieldsById = keyBy(itemFields, (f) => f.id);
         // Validate caller-supplied fieldSeqNos exist on the item.
         const callerValues = data.fieldValues ?? [];
         for (const fv of callerValues) {

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

@@ -1,3 +1,4 @@
+import { keyBy, unique } from "@naisys/common";
 import erpDb from "../../database/erpDb.js";
 // --- Prisma deep include for full revision tree ---
 const includeFullTree = {
@@ -41,9 +42,9 @@ function compareProps(pairs) {
     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 fromMap = keyBy(fromFields, (f) => f.seqNo);
+    const toMap = keyBy(toFields, (f) => f.seqNo);
+    const allSeqNos = unique([...fromMap.keys(), ...toMap.keys()]);
     const result = [];
     for (const seqNo of [...allSeqNos].sort((a, b) => a - b)) {
         const from = fromMap.get(seqNo);
@@ -72,9 +73,9 @@ function diffFields(fromFields, toFields) {
     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 fromMap = keyBy(fromSteps, (s) => s.seqNo);
+    const toMap = keyBy(toSteps, (s) => s.seqNo);
+    const allSeqNos = unique([...fromMap.keys(), ...toMap.keys()]);
     const result = [];
     for (const seqNo of [...allSeqNos].sort((a, b) => a - b)) {
         const from = fromMap.get(seqNo);
@@ -138,9 +139,9 @@ function diffDeps(fromDeps, toDeps) {
     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 fromMap = keyBy(fromOps, (op) => op.seqNo);
+    const toMap = keyBy(toOps, (op) => op.seqNo);
+    const allSeqNos = unique([...fromMap.keys(), ...toMap.keys()]);
     const result = [];
     for (const seqNo of [...allSeqNos].sort((a, b) => a - b)) {
         const from = fromMap.get(seqNo);

package/dist/services/production/labor-ticket-backfill.js

@@ -0,0 +1,67 @@
+import { sumAgentMetricsByUuid } from "@naisys/hub-database";
+import { OperationRunStatus } from "@naisys/erp-shared";
+import erpDb from "../../database/erpDb.js";
+/**
+ * Populate `tokens` on labor tickets and operation runs finalized before the
+ * column existed. Idempotent — only touches rows where `tokens IS NULL`, and
+ * only for agent users (others can't have tokens, so their rows stay NULL
+ * and the next startup ignores them too). Requires the hub DB client.
+ */
+export async function backfillOpRunTokens() {
+    const tickets = await erpDb.laborTicket.findMany({
+        where: {
+            tokens: null,
+            clockOut: { not: null },
+            operationRun: {
+                status: {
+                    in: [
+                        OperationRunStatus.completed,
+                        OperationRunStatus.skipped,
+                        OperationRunStatus.failed,
+                    ],
+                },
+            },
+            user: { isAgent: true },
+        },
+        select: {
+            id: true,
+            operationRunId: true,
+            clockIn: true,
+            clockOut: true,
+            user: { select: { uuid: true } },
+        },
+    });
+    if (tickets.length === 0)
+        return;
+    const dirtyOpRunIds = new Set();
+    for (const ticket of tickets) {
+        const { tokens } = await sumAgentMetricsByUuid(ticket.user.uuid, ticket.clockIn, ticket.clockOut);
+        await erpDb.laborTicket.update({
+            where: { id: ticket.id },
+            data: { tokens: Math.round(tokens) },
+        });
+        dirtyOpRunIds.add(ticket.operationRunId);
+    }
+    // Re-aggregate touched op_runs. Skip rows that already have a snapshot so
+    // we never clobber a value set by the normal transition path.
+    for (const opRunId of dirtyOpRunIds) {
+        const opRun = await erpDb.operationRun.findUnique({
+            where: { id: opRunId },
+            select: { tokens: true },
+        });
+        if (!opRun || opRun.tokens !== null)
+            continue;
+        const agg = await erpDb.laborTicket.aggregate({
+            where: { operationRunId: opRunId },
+            _sum: { tokens: true },
+        });
+        const total = agg._sum.tokens ?? 0;
+        if (total > 0) {
+            await erpDb.operationRun.update({
+                where: { id: opRunId },
+                data: { tokens: total },
+            });
+        }
+    }
+}
+//# sourceMappingURL=labor-ticket-backfill.js.map

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

@@ -1,4 +1,4 @@
-import { getLatestRunInfoByUuid, sumCostsByUuid } from "@naisys/hub-database";
+import { getLatestRunInfoByUuid, sumAgentMetricsByUuid, } from "@naisys/hub-database";
 import erpDb from "../../database/erpDb.js";
 import { writeAuditEntry } from "../audit.js";
 // --- Prisma include & result type ---
@@ -9,19 +9,22 @@ export const includeLaborTicket = {
 };
 // --- Helpers ---
 /**
- * Compute the cost for a labor ticket at clock-out time.
+ * Compute cost + tokens 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.
+ * Non-agents: zeros.
  */
-async function computeCost(userId, clockIn, clockOut) {
+async function computeAgentMetrics(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;
+        return { cost: 0, tokens: 0 };
+    const { cost, tokens } = await sumAgentMetricsByUuid(user.uuid, clockIn, clockOut);
+    return {
+        cost: Math.round(cost * 100) / 100,
+        tokens: Math.round(tokens),
+    };
 }
 /**
  * Get the current hub run info (run_id + session start) for an agent user.
@@ -67,10 +70,10 @@ export async function clockIn(operationRunId, userId, actorId) {
             where: { userId, clockOut: null },
         });
         for (const ticket of openTickets) {
-            const cost = await computeCost(userId, ticket.clockIn, now);
+            const { cost, tokens } = await computeAgentMetrics(userId, ticket.clockIn, now);
             await tx.laborTicket.update({
                 where: { id: ticket.id },
-                data: { clockOut: now, cost, updatedById: actorId },
+                data: { clockOut: now, cost, tokens, updatedById: actorId },
             });
         }
         // If no tickets were auto-closed and this is the first ticket for the
@@ -118,10 +121,10 @@ export async function clockOut(operationRunId, opts, actorId) {
         const openTickets = await tx.laborTicket.findMany({ where });
         const updated = [];
         for (const ticket of openTickets) {
-            const cost = await computeCost(ticket.userId, ticket.clockIn, now);
+            const { cost, tokens } = await computeAgentMetrics(ticket.userId, ticket.clockIn, now);
             const result = await tx.laborTicket.update({
                 where: { id: ticket.id },
-                data: { clockOut: now, cost, updatedById: actorId },
+                data: { clockOut: now, cost, tokens, updatedById: actorId },
                 include: includeLaborTicket,
             });
             updated.push(result);
@@ -132,12 +135,15 @@ export async function clockOut(operationRunId, opts, actorId) {
 export async function clockOutAllForOpRun(operationRunId, actorId) {
     await clockOut(operationRunId, {}, actorId);
 }
-export async function sumLaborTicketCosts(operationRunId) {
+export async function sumLaborTicketMetrics(operationRunId) {
     const result = await erpDb.laborTicket.aggregate({
         where: { operationRunId },
-        _sum: { cost: true },
+        _sum: { cost: true, tokens: true },
     });
-    return Math.round((result._sum.cost ?? 0) * 100) / 100;
+    return {
+        cost: Math.round((result._sum.cost ?? 0) * 100) / 100,
+        tokens: result._sum.tokens ?? 0,
+    };
 }
 export async function deleteLaborTicket(ticketId, actorId) {
     await erpDb.$transaction(async (tx) => {