@naisys/erp 3.0.0-beta.10

package/dist/services/field-value-service.js

@@ -0,0 +1,256 @@
+import { formatFileSize } from "@naisys/common";
+import { FieldType, } from "@naisys/erp-shared";
+import erpDb from "../erpDb.js";
+// --- Lookups ---
+export async function findStepRunWithField(id, opRunId, fieldSeqNo) {
+    const stepRun = await erpDb.stepRun.findUnique({
+        where: { id },
+        include: {
+            step: {
+                select: {
+                    multiSet: true,
+                    fieldSet: {
+                        select: {
+                            fields: {
+                                where: { seqNo: fieldSeqNo },
+                                select: {
+                                    id: true,
+                                    fieldSetId: true,
+                                    seqNo: true,
+                                    label: true,
+                                    type: true,
+                                    isArray: true,
+                                    required: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    });
+    if (!stepRun || stepRun.operationRunId !== opRunId)
+        return null;
+    return stepRun;
+}
+// --- Serialization ---
+/**
+ * Serialize a field value for DB storage.
+ * - Scalar (string): stored as-is
+ * - Array (string[]): stored as JSON array string
+ */
+export function serializeFieldValue(value) {
+    if (Array.isArray(value)) {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+/**
+ * Deserialize a DB-stored value back to the API shape.
+ * - isArray fields: parse JSON array, falling back to comma-split for legacy data
+ * - Scalar fields: return as-is
+ */
+export function deserializeFieldValue(dbValue, isArray) {
+    if (!isArray)
+        return dbValue;
+    if (!dbValue)
+        return [];
+    // Try JSON array first (new format)
+    if (dbValue.startsWith("[")) {
+        try {
+            const parsed = JSON.parse(dbValue);
+            if (Array.isArray(parsed))
+                return parsed;
+        }
+        catch {
+            // fall through to legacy
+        }
+    }
+    // Legacy: comma-separated string — migrate on read
+    return dbValue.split(",").map((v) => v.trim());
+}
+// --- Validation ---
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const DATETIME_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2})?$/;
+function validateSingleValue(type, value) {
+    const v = value.trim();
+    if (!v)
+        return null;
+    switch (type) {
+        case FieldType.number:
+            if (isNaN(Number(v)))
+                return "Must be a number";
+            break;
+        case FieldType.date:
+            if (!DATE_RE.test(v) || isNaN(Date.parse(v)))
+                return "Must be a valid date (YYYY-MM-DD)";
+            break;
+        case FieldType.datetime:
+            if (!DATETIME_RE.test(v) || isNaN(Date.parse(v)))
+                return "Must be a valid date/time (YYYY-MM-DDTHH:mm)";
+            break;
+        case FieldType.yesNo:
+            if (v !== "Yes" && v !== "No")
+                return 'Must be "Yes" or "No"';
+            break;
+        case FieldType.checkbox:
+            if (v !== "checked")
+                return "Invalid checkbox value";
+            break;
+    }
+    return null;
+}
+/**
+ * Check that the value shape matches the field's isArray flag.
+ * Returns an error string if mismatched, or null if OK.
+ */
+export function checkFieldValueShape(label, type, isArray, value) {
+    if (isArray && !Array.isArray(value)) {
+        return `Field "${label}" is an array field (type: ${type}[]) — value must be a JSON array, e.g. ["value1", "value2"]`;
+    }
+    if (!isArray && Array.isArray(value)) {
+        return `Field "${label}" is not an array field — value must be a string, not an array`;
+    }
+    return null;
+}
+export function validateFieldValue(type, isArray, required, value) {
+    const shapeErr = checkFieldValueShape("field", type, isArray, value);
+    if (shapeErr)
+        return { valid: false, error: shapeErr };
+    if (isArray) {
+        const items = value;
+        if (required && items.every((v) => !v.trim())) {
+            return { valid: false, error: "Required" };
+        }
+        for (let i = 0; i < items.length; i++) {
+            const err = validateSingleValue(type, items[i]);
+            if (err) {
+                return { valid: false, error: `Item ${i + 1}: ${err}` };
+            }
+        }
+    }
+    else {
+        const v = value;
+        if (required && !v.trim()) {
+            return { valid: false, error: "Required" };
+        }
+        const err = validateSingleValue(type, v);
+        if (err) {
+            return { valid: false, error: err };
+        }
+    }
+    return { valid: true };
+}
+function fieldValueKey(fieldId, setIndex) {
+    return `${fieldId}_${setIndex}`;
+}
+export function validateCompletionFields(existing) {
+    const existingFieldValues = existing.fieldRecord?.fieldValues ?? [];
+    // Build a map of field definitions keyed by id for isArray lookup
+    const fieldDefs = new Map((existing.step.fieldSet?.fields ?? []).map((f) => [f.id, f]));
+    const storedMap = new Map(existingFieldValues.map((fv) => {
+        const def = fieldDefs.get(fv.fieldId);
+        return [
+            fieldValueKey(fv.fieldId, fv.setIndex),
+            deserializeFieldValue(fv.value, def?.isArray ?? false),
+        ];
+    }));
+    // Determine how many sets exist
+    const allSetIndexes = new Set();
+    for (const fv of existingFieldValues)
+        allSetIndexes.add(fv.setIndex);
+    if (allSetIndexes.size === 0)
+        allSetIndexes.add(0);
+    const errors = [];
+    for (const si of [...allSetIndexes].sort((a, b) => a - b)) {
+        for (const field of existing.step.fieldSet?.fields ?? []) {
+            const key = fieldValueKey(field.id, si);
+            const value = storedMap.get(key) ?? "";
+            const result = validateFieldValue(field.type, field.isArray, field.required, value);
+            if (!result.valid) {
+                const prefix = existing.step.multiSet ? `Set ${si + 1} / ` : "";
+                errors.push(`${prefix}${field.label}: ${result.error}`);
+            }
+        }
+    }
+    if (errors.length > 0) {
+        return `Cannot complete step:\n${errors.join("\n")}`;
+    }
+    return null;
+}
+// --- Attachment value helpers ---
+export function formatAttachmentLabel(filename, fileSize) {
+    return `${filename} (${formatFileSize(fileSize)})`;
+}
+/**
+ * Query current attachments for a field value and rebuild the stored value
+ * to reflect them. Returns the new API-shape value.
+ */
+export async function rebuildAttachmentFieldValue(fieldRecordId, fieldId, setIndex, isArray, userId) {
+    const fieldValue = await erpDb.fieldValue.findUnique({
+        where: {
+            fieldRecordId_fieldId_setIndex: { fieldRecordId, fieldId, setIndex },
+        },
+        include: {
+            fieldAttachments: {
+                include: {
+                    attachment: { select: { filename: true, fileSize: true } },
+                },
+            },
+        },
+    });
+    const labels = (fieldValue?.fieldAttachments ?? []).map((fa) => formatAttachmentLabel(fa.attachment.filename, fa.attachment.fileSize));
+    const value = labels.length === 0 ? (isArray ? [] : "") : isArray ? labels : labels[0];
+    await upsertFieldValue(fieldRecordId, fieldId, setIndex, value, userId);
+    return value;
+}
+/**
+ * Clear an attachment field: delete all FieldAttachment links and set value to empty.
+ */
+export async function clearAttachmentFieldValue(fieldRecordId, fieldId, setIndex, userId) {
+    const fieldValue = await erpDb.fieldValue.findUnique({
+        where: {
+            fieldRecordId_fieldId_setIndex: { fieldRecordId, fieldId, setIndex },
+        },
+        select: { id: true },
+    });
+    if (fieldValue) {
+        await erpDb.fieldAttachment.deleteMany({
+            where: { fieldValueId: fieldValue.id },
+        });
+    }
+    const empty = "";
+    await upsertFieldValue(fieldRecordId, fieldId, setIndex, empty, userId);
+}
+// --- Mutations ---
+export async function upsertFieldValue(fieldRecordId, fieldId, setIndex, value, userId) {
+    const dbValue = serializeFieldValue(value);
+    await erpDb.fieldValue.upsert({
+        where: {
+            fieldRecordId_fieldId_setIndex: { fieldRecordId, fieldId, setIndex },
+        },
+        create: {
+            fieldRecordId,
+            fieldId,
+            setIndex,
+            value: dbValue,
+            createdById: userId,
+            updatedById: userId,
+        },
+        update: {
+            value: dbValue,
+            updatedById: userId,
+        },
+    });
+}
+export async function deleteFieldValueSet(fieldRecordId, setIndex) {
+    await erpDb.$transaction(async (erpTx) => {
+        // Delete all field values for this set
+        await erpTx.fieldValue.deleteMany({
+            where: { fieldRecordId, setIndex },
+        });
+        // Re-index higher sets to fill the gap
+        await erpTx.$executeRawUnsafe(`UPDATE field_values SET set_index = set_index - 1 WHERE field_record_id = ? AND set_index > ?`, fieldRecordId, setIndex);
+    });
+}
+//# sourceMappingURL=field-value-service.js.map

package/dist/services/item-instance-service.js

@@ -0,0 +1,155 @@
+import erpDb from "../erpDb.js";
+import { includeUsers } from "../route-helpers.js";
+// --- Prisma include & result type ---
+export const includeItemInstanceRelations = {
+    ...includeUsers,
+    item: {
+        select: {
+            key: true,
+            fieldSet: {
+                select: {
+                    id: true,
+                    fields: {
+                        select: {
+                            id: true,
+                            seqNo: true,
+                            label: true,
+                            type: true,
+                            isArray: true,
+                            required: true,
+                        },
+                        orderBy: { seqNo: "asc" },
+                    },
+                },
+            },
+        },
+    },
+    orderRun: {
+        select: {
+            runNo: true,
+            order: { select: { key: true } },
+        },
+    },
+    fieldRecord: {
+        include: {
+            fieldValues: {
+                select: {
+                    id: true,
+                    fieldId: true,
+                    setIndex: true,
+                    value: true,
+                    fieldAttachments: {
+                        select: {
+                            attachment: {
+                                select: { publicId: true, filename: true, fileSize: true },
+                            },
+                        },
+                    },
+                },
+                orderBy: { setIndex: "asc" },
+            },
+        },
+    },
+};
+// --- Lookups ---
+export async function listItemInstances(where, page, pageSize) {
+    return Promise.all([
+        erpDb.itemInstance.findMany({
+            where,
+            include: includeItemInstanceRelations,
+            skip: (page - 1) * pageSize,
+            take: pageSize,
+            orderBy: { createdAt: "desc" },
+        }),
+        erpDb.itemInstance.count({ where }),
+    ]);
+}
+export async function findItemInstance(id) {
+    return erpDb.itemInstance.findUnique({
+        where: { id },
+        include: includeItemInstanceRelations,
+    });
+}
+export async function findItemInstanceByItemAndKey(itemId, key) {
+    return erpDb.itemInstance.findUnique({
+        where: { itemId_key: { itemId, key } },
+        include: includeItemInstanceRelations,
+    });
+}
+export async function findItemInstanceWithField(id, fieldSeqNo) {
+    return erpDb.itemInstance.findUnique({
+        where: { id },
+        include: {
+            item: {
+                select: {
+                    fieldSet: {
+                        select: {
+                            id: true,
+                            fields: {
+                                where: { seqNo: fieldSeqNo },
+                                select: {
+                                    id: true,
+                                    seqNo: true,
+                                    label: true,
+                                    type: true,
+                                    isArray: true,
+                                    required: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    });
+}
+// --- Mutations ---
+export async function createItemInstance(itemId, key, quantity, orderRunId, userId) {
+    return erpDb.itemInstance.create({
+        data: {
+            itemId,
+            key,
+            quantity: quantity ?? null,
+            orderRunId: orderRunId ?? null,
+            createdById: userId,
+            updatedById: userId,
+        },
+        include: includeItemInstanceRelations,
+    });
+}
+export async function updateItemInstance(id, data, userId) {
+    return erpDb.itemInstance.update({
+        where: { id },
+        data: { ...data, updatedById: userId },
+        include: includeItemInstanceRelations,
+    });
+}
+export async function deleteItemInstance(id) {
+    await erpDb.itemInstance.delete({ where: { id } });
+}
+/**
+ * Get or create a FieldRecord for an ItemInstance, linking it back.
+ * Returns the fieldRecordId, or null if the item has no fieldSet.
+ */
+export async function ensureItemInstanceFieldRecord(instanceId, userId) {
+    const inst = await erpDb.itemInstance.findUniqueOrThrow({
+        where: { id: instanceId },
+        select: {
+            fieldRecordId: true,
+            item: { select: { fieldSetId: true } },
+        },
+    });
+    if (inst.fieldRecordId)
+        return inst.fieldRecordId;
+    if (!inst.item.fieldSetId)
+        return null;
+    const fr = await erpDb.fieldRecord.create({
+        data: { fieldSetId: inst.item.fieldSetId, createdById: userId },
+    });
+    await erpDb.itemInstance.update({
+        where: { id: instanceId },
+        data: { fieldRecordId: fr.id },
+    });
+    return fr.id;
+}
+//# sourceMappingURL=item-instance-service.js.map

package/dist/services/item-service.js

@@ -0,0 +1,56 @@
+import erpDb from "../erpDb.js";
+import { includeUsers } from "../route-helpers.js";
+// --- Prisma include & result type ---
+export const includeUsersAndFieldSet = {
+    ...includeUsers,
+    fieldSet: {
+        include: {
+            fields: {
+                include: includeUsers,
+                orderBy: { seqNo: "asc" },
+            },
+        },
+    },
+};
+// --- Lookups ---
+export async function listItems(where, page, pageSize) {
+    return Promise.all([
+        erpDb.item.findMany({
+            where,
+            include: includeUsersAndFieldSet,
+            skip: (page - 1) * pageSize,
+            take: pageSize,
+            orderBy: { createdAt: "desc" },
+        }),
+        erpDb.item.count({ where }),
+    ]);
+}
+export async function findExisting(key) {
+    return erpDb.item.findUnique({
+        where: { key },
+        include: includeUsersAndFieldSet,
+    });
+}
+// --- Mutations ---
+export async function createItem(key, description, userId) {
+    return erpDb.item.create({
+        data: {
+            key,
+            description,
+            createdById: userId,
+            updatedById: userId,
+        },
+        include: includeUsersAndFieldSet,
+    });
+}
+export async function updateItem(key, data, userId) {
+    return erpDb.item.update({
+        where: { key },
+        data: { ...data, updatedById: userId },
+        include: includeUsersAndFieldSet,
+    });
+}
+export async function deleteItem(key) {
+    await erpDb.item.delete({ where: { key } });
+}
+//# sourceMappingURL=item-service.js.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.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.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.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