@naisys/erp 3.0.0-beta.6

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

package/dist/services/step-run-service.js

@@ -0,0 +1,106 @@
+import erpDb from "../erpDb.js";
+// --- Prisma include & result type ---
+export const includeStepRunWithFields = {
+    step: {
+        select: {
+            seqNo: true,
+            title: true,
+            instructions: true,
+            multiSet: true,
+            fieldSet: {
+                select: {
+                    fields: {
+                        select: {
+                            id: true,
+                            seqNo: true,
+                            label: true,
+                            type: true,
+                            isArray: true,
+                            required: true,
+                        },
+                        orderBy: { seqNo: "asc" },
+                    },
+                },
+            },
+        },
+    },
+    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" },
+            },
+        },
+    },
+    createdBy: { select: { username: true } },
+    updatedBy: { select: { username: true } },
+};
+// --- Lightweight include (step metadata only, no field values) ---
+export const includeStepRun = {
+    step: {
+        select: {
+            seqNo: true,
+            title: true,
+            instructions: true,
+            multiSet: true,
+            fieldSet: {
+                select: {
+                    _count: { select: { fields: true } },
+                },
+            },
+        },
+    },
+    createdBy: { select: { username: true } },
+    updatedBy: { select: { username: true } },
+};
+// --- Lookups ---
+export async function listStepRuns(opRunId) {
+    return erpDb.stepRun.findMany({
+        where: { operationRunId: opRunId },
+        include: includeStepRun,
+        orderBy: { step: { seqNo: "asc" } },
+    });
+}
+export async function listStepRunsWithFields(opRunId) {
+    return erpDb.stepRun.findMany({
+        where: { operationRunId: opRunId },
+        include: includeStepRunWithFields,
+        orderBy: { step: { seqNo: "asc" } },
+    });
+}
+export async function getStepRunWithFields(id) {
+    return erpDb.stepRun.findUnique({
+        where: { id },
+        include: includeStepRunWithFields,
+    });
+}
+// --- Mutations ---
+export async function updateStepRun(id, completed, statusNote, userId) {
+    if (completed !== undefined) {
+        await erpDb.stepRun.update({
+            where: { id },
+            data: {
+                completed,
+                statusNote: statusNote ?? null,
+                updatedById: userId,
+            },
+        });
+    }
+    return erpDb.stepRun.findUniqueOrThrow({
+        where: { id },
+        include: includeStepRunWithFields,
+    });
+}
+//# sourceMappingURL=step-run-service.js.map

package/dist/services/step-service.js

@@ -0,0 +1,89 @@
+import erpDb from "../erpDb.js";
+import { calcNextSeqNo, includeUsers, } from "../route-helpers.js";
+// --- Prisma include & result type ---
+export const includeUsersAndFields = {
+    ...includeUsers,
+    fieldSet: {
+        include: {
+            fields: {
+                include: includeUsers,
+                orderBy: { seqNo: "asc" },
+            },
+        },
+    },
+};
+// --- Lookups ---
+export async function listSteps(operationId) {
+    return erpDb.step.findMany({
+        where: { operationId },
+        include: includeUsersAndFields,
+        orderBy: { seqNo: "asc" },
+    });
+}
+export async function getStep(operationId, seqNo) {
+    return erpDb.step.findFirst({
+        where: { operationId, seqNo },
+        include: includeUsersAndFields,
+    });
+}
+export async function findExisting(operationId, seqNo) {
+    return erpDb.step.findFirst({
+        where: { operationId, seqNo },
+        include: includeUsersAndFields,
+    });
+}
+// --- Mutations ---
+export async function createSteps(operationId, items, userId) {
+    return erpDb.$transaction(async (erpTx) => {
+        const maxSeq = await erpTx.step.findFirst({
+            where: { operationId },
+            orderBy: { seqNo: "desc" },
+            select: { seqNo: true },
+        });
+        let nextSeqNo = calcNextSeqNo(maxSeq?.seqNo ?? 0);
+        const created = [];
+        for (const item of items) {
+            const seqNo = item.seqNo ?? nextSeqNo;
+            const step = await erpTx.step.create({
+                data: {
+                    operationId,
+                    seqNo,
+                    title: item.title ?? "",
+                    instructions: item.instructions ?? "",
+                    multiSet: item.multiSet ?? false,
+                    createdById: userId,
+                    updatedById: userId,
+                },
+                include: includeUsersAndFields,
+            });
+            created.push(step);
+            if (!item.seqNo) {
+                nextSeqNo = calcNextSeqNo(seqNo);
+            }
+        }
+        return created;
+    });
+}
+export async function createStep(operationId, requestedSeqNo, title, instructions, multiSet, userId) {
+    const [step] = await createSteps(operationId, [{ seqNo: requestedSeqNo, title, instructions, multiSet }], userId);
+    return step;
+}
+export async function updateStep(id, data, userId) {
+    return erpDb.step.update({
+        where: { id },
+        data: {
+            ...(data.title !== undefined ? { title: data.title } : {}),
+            ...(data.instructions !== undefined
+                ? { instructions: data.instructions }
+                : {}),
+            ...(data.seqNo !== undefined ? { seqNo: data.seqNo } : {}),
+            ...(data.multiSet !== undefined ? { multiSet: data.multiSet } : {}),
+            updatedById: userId,
+        },
+        include: includeUsersAndFields,
+    });
+}
+export async function deleteStep(id) {
+    await erpDb.step.delete({ where: { id } });
+}
+//# sourceMappingURL=step-service.js.map

package/dist/services/user-service.js

@@ -0,0 +1,132 @@
+import { getAgentApiKeyByUuid, rotateAgentApiKeyByUuid, } from "@naisys/hub-database";
+import bcrypt from "bcryptjs";
+import { randomBytes, randomUUID } from "crypto";
+import erpDb from "../erpDb.js";
+import { isSupervisorAuth } from "../supervisorAuth.js";
+// --- Prisma include & result type ---
+export const includePermissions = {
+    permissions: true,
+};
+// --- Constants ---
+const SALT_ROUNDS = 10;
+// --- Lookups ---
+export async function listUsers(options) {
+    const { page, pageSize, search } = options;
+    const where = search ? { username: { contains: search } } : {};
+    const [items, total] = await Promise.all([
+        erpDb.user.findMany({
+            where,
+            include: includePermissions,
+            orderBy: { createdAt: "desc" },
+            skip: (page - 1) * pageSize,
+            take: pageSize,
+        }),
+        erpDb.user.count({ where }),
+    ]);
+    return { items, total, pageSize };
+}
+export async function getUserByUsername(username) {
+    return erpDb.user.findUnique({
+        where: { username },
+        include: includePermissions,
+    });
+}
+export async function getUserById(id) {
+    return erpDb.user.findUnique({
+        where: { id },
+        include: includePermissions,
+    });
+}
+export async function getUserApiKey(id) {
+    const user = await erpDb.user.findUnique({
+        where: { id },
+        select: { isAgent: true, uuid: true, apiKey: true },
+    });
+    if (!user)
+        return null;
+    if (user.isAgent && isSupervisorAuth()) {
+        return getAgentApiKeyByUuid(user.uuid);
+    }
+    else {
+        return user.apiKey ?? null;
+    }
+}
+// --- Mutations ---
+export async function getUserByUuid(uuid) {
+    return erpDb.user.findFirst({
+        where: { uuid },
+        include: includePermissions,
+    });
+}
+export async function createUserForAgent(username, uuid) {
+    return erpDb.user.create({
+        data: {
+            username,
+            uuid,
+            passwordHash: "",
+            isAgent: true,
+        },
+        include: includePermissions,
+    });
+}
+export async function createUserWithPassword(data) {
+    const passwordHash = await bcrypt.hash(data.password, SALT_ROUNDS);
+    const uuid = randomUUID();
+    return erpDb.user.create({
+        data: {
+            username: data.username,
+            uuid,
+            passwordHash,
+            isAgent: false,
+            apiKey: randomBytes(32).toString("hex"),
+        },
+        include: includePermissions,
+    });
+}
+export async function updateUser(id, data) {
+    const updateData = {};
+    if (data.username !== undefined) {
+        updateData.username = data.username;
+    }
+    if (data.password !== undefined) {
+        updateData.passwordHash = await bcrypt.hash(data.password, SALT_ROUNDS);
+    }
+    return erpDb.user.update({
+        where: { id },
+        data: updateData,
+        include: includePermissions,
+    });
+}
+export async function deleteUser(id) {
+    return erpDb.user.delete({ where: { id } });
+}
+export async function grantPermission(userId, permission, grantedBy) {
+    return erpDb.userPermission.create({
+        data: { userId, permission, grantedBy },
+    });
+}
+export async function revokePermission(userId, permission) {
+    return erpDb.userPermission.deleteMany({
+        where: { userId, permission },
+    });
+}
+export async function rotateUserApiKey(id) {
+    const newKey = randomBytes(32).toString("hex");
+    const user = await erpDb.user.findUnique({
+        where: { id },
+        select: { isAgent: true, uuid: true },
+    });
+    if (!user)
+        throw new Error("User not found");
+    if (user.isAgent && isSupervisorAuth()) {
+        await rotateAgentApiKeyByUuid(user.uuid, newKey);
+    }
+    else {
+        await erpDb.user.update({
+            where: { id },
+            data: { apiKey: newKey },
+        });
+    }
+    return newKey;
+}
+//# sourceMappingURL=user-service.js.map

package/dist/services/work-center-service.js

@@ -0,0 +1,106 @@
+import erpDb from "../erpDb.js";
+import { includeUsers } from "../route-helpers.js";
+// --- Prisma include & result type ---
+const includeDetail = {
+    ...includeUsers,
+    userAssignments: {
+        include: {
+            user: { select: { id: true, username: true } },
+            createdBy: { select: { username: true } },
+        },
+        orderBy: { user: { username: "asc" } },
+    },
+    _count: { select: { userAssignments: true } },
+};
+// --- Lookups ---
+export async function listWorkCenters(where, page, pageSize) {
+    return Promise.all([
+        erpDb.workCenter.findMany({
+            where,
+            include: includeDetail,
+            skip: (page - 1) * pageSize,
+            take: pageSize,
+            orderBy: { createdAt: "desc" },
+        }),
+        erpDb.workCenter.count({ where }),
+    ]);
+}
+export async function findExisting(key) {
+    return erpDb.workCenter.findUnique({
+        where: { key },
+        include: includeDetail,
+    });
+}
+// --- Mutations ---
+export async function createWorkCenter(key, description, userId) {
+    return erpDb.workCenter.create({
+        data: {
+            key,
+            description,
+            createdById: userId,
+            updatedById: userId,
+        },
+        include: includeDetail,
+    });
+}
+export async function updateWorkCenter(key, data, userId) {
+    return erpDb.workCenter.update({
+        where: { key },
+        data: { ...data, updatedById: userId },
+        include: includeDetail,
+    });
+}
+export async function deleteWorkCenter(key) {
+    await erpDb.workCenter.delete({ where: { key } });
+}
+// --- User assignments ---
+export async function assignUser(workCenterKey, username, createdById) {
+    const workCenter = await erpDb.workCenter.findUniqueOrThrow({
+        where: { key: workCenterKey },
+    });
+    const user = await erpDb.user.findUniqueOrThrow({
+        where: { username },
+    });
+    await erpDb.workCenterUser.create({
+        data: {
+            workCenterId: workCenter.id,
+            userId: user.id,
+            createdById,
+        },
+    });
+    return erpDb.workCenter.findUniqueOrThrow({
+        where: { key: workCenterKey },
+        include: includeDetail,
+    });
+}
+export async function removeUser(workCenterKey, username) {
+    const workCenter = await erpDb.workCenter.findUniqueOrThrow({
+        where: { key: workCenterKey },
+    });
+    const user = await erpDb.user.findUniqueOrThrow({
+        where: { username },
+    });
+    await erpDb.workCenterUser.delete({
+        where: {
+            workCenterId_userId: {
+                workCenterId: workCenter.id,
+                userId: user.id,
+            },
+        },
+    });
+}
+// --- Work center ID lookups for dispatch ---
+export async function getUserWorkCenterIds(userId) {
+    const assignments = await erpDb.workCenterUser.findMany({
+        where: { userId },
+        select: { workCenterId: true },
+    });
+    return assignments.map((a) => a.workCenterId);
+}
+export async function findWorkCenterByKey(key) {
+    return erpDb.workCenter.findUnique({
+        where: { key },
+        select: { id: true },
+    });
+}
+//# sourceMappingURL=work-center-service.js.map

package/dist/supervisorAuth.js

@@ -0,0 +1,16 @@
+/**
+ * Module-level flag indicating whether ERP should use the supervisor/hub
+ * databases for SSO authentication and agent API key lookups.
+ *
+ * Enabled by:
+ *  - SUPERVISOR_AUTH=true environment variable
+ *  - Supervisor calling `enableSupervisorAuth()` before registering the ERP plugin
+ */
+let _enabled = false;
+export function enableSupervisorAuth() {
+    _enabled = true;
+}
+export function isSupervisorAuth() {
+    return _enabled || process.env.SUPERVISOR_AUTH === "true";
+}
+//# sourceMappingURL=supervisorAuth.js.map