@naisys/erp 3.0.0-beta.6

package/dist/routes/work-centers.js

@@ -0,0 +1,280 @@
+import { AssignWorkCenterUserSchema, CreateWorkCenterSchema, ErrorResponseSchema, KeyCreateResponseSchema, MutateResponseSchema, UpdateWorkCenterSchema, WorkCenterListQuerySchema, WorkCenterListResponseSchema, WorkCenterSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import { notFound } from "../error-handler.js";
+import { API_PREFIX, collectionLink, paginationLinks, schemaLink, selfLink, } from "../hateoas.js";
+import { formatAuditFields, mutationResult } from "../route-helpers.js";
+import { assignUser, createWorkCenter, deleteWorkCenter, findExisting, listWorkCenters, removeUser, updateWorkCenter, } from "../services/work-center-service.js";
+const RESOURCE = "work-centers";
+const KeyParamsSchema = z.object({
+    key: z.string(),
+});
+const UserParamsSchema = z.object({
+    key: z.string(),
+    username: z.string(),
+});
+function wcLinks(key) {
+    return [
+        selfLink(`/${RESOURCE}/${key}`),
+        collectionLink(RESOURCE),
+        schemaLink("WorkCenter"),
+    ];
+}
+function wcActions(key, user) {
+    if (!hasPermission(user, "erp_admin"))
+        return [];
+    const href = `${API_PREFIX}/${RESOURCE}/${key}`;
+    return [
+        {
+            rel: "update",
+            href,
+            method: "PUT",
+            title: "Update",
+            schema: `${API_PREFIX}/schemas/UpdateWorkCenter`,
+        },
+        {
+            rel: "delete",
+            href,
+            method: "DELETE",
+            title: "Delete",
+        },
+        {
+            rel: "assignUser",
+            href: `${href}/users`,
+            method: "POST",
+            title: "Assign User",
+            schema: `${API_PREFIX}/schemas/AssignWorkCenterUser`,
+        },
+    ];
+}
+function formatWorkCenter(wc, user) {
+    const isAdmin = hasPermission(user, "erp_admin");
+    return {
+        id: wc.id,
+        key: wc.key,
+        description: wc.description,
+        userAssignments: wc.userAssignments.map((a) => ({
+            userId: a.user.id,
+            username: a.user.username,
+            createdAt: a.createdAt.toISOString(),
+            createdBy: a.createdBy?.username ?? null,
+            _actions: isAdmin
+                ? [
+                    {
+                        rel: "remove",
+                        href: `${API_PREFIX}/${RESOURCE}/${wc.key}/users/${a.user.username}`,
+                        method: "DELETE",
+                        title: "Remove",
+                    },
+                ]
+                : [],
+        })),
+        ...formatAuditFields(wc),
+        _links: wcLinks(wc.key),
+        _actions: wcActions(wc.key, user),
+    };
+}
+function formatListItem(wc) {
+    return {
+        id: wc.id,
+        key: wc.key,
+        description: wc.description,
+        userCount: wc._count.userAssignments,
+        ...formatAuditFields(wc),
+    };
+}
+export default function workCenterRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List work centers with pagination and search",
+            tags: ["Work Centers"],
+            querystring: WorkCenterListQuerySchema,
+            response: {
+                200: WorkCenterListResponseSchema,
+            },
+        },
+        handler: async (request) => {
+            const { page, pageSize, search } = request.query;
+            const where = {};
+            if (search) {
+                where.OR = [
+                    { key: { contains: search } },
+                    { description: { contains: search } },
+                ];
+            }
+            const [items, total] = await listWorkCenters(where, page, pageSize);
+            return {
+                items: items.map((wc) => formatListItem(wc)),
+                total,
+                page,
+                pageSize,
+                _links: paginationLinks(RESOURCE, page, pageSize, total, { search }),
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}/work-centers/{key}`,
+                    },
+                ],
+                _actions: hasPermission(request.erpUser, "erp_admin")
+                    ? [
+                        {
+                            rel: "create",
+                            href: `${API_PREFIX}/${RESOURCE}`,
+                            method: "POST",
+                            title: "Create Work Center",
+                            schema: `${API_PREFIX}/schemas/CreateWorkCenter`,
+                        },
+                    ]
+                    : [],
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Create a new work center",
+            tags: ["Work Centers"],
+            body: CreateWorkCenterSchema,
+            response: {
+                201: KeyCreateResponseSchema,
+            },
+        },
+        preHandler: requirePermission("erp_admin"),
+        handler: async (request, reply) => {
+            const { key, description } = request.body;
+            const userId = request.erpUser.id;
+            const wc = await createWorkCenter(key, description, userId);
+            const full = formatWorkCenter(wc, request.erpUser);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                key: full.key,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // GET by key
+    app.get("/:key", {
+        schema: {
+            description: "Get a single work center by key",
+            tags: ["Work Centers"],
+            params: KeyParamsSchema,
+            response: {
+                200: WorkCenterSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const wc = await findExisting(key);
+            if (!wc) {
+                return notFound(reply, `Work center '${key}' not found`);
+            }
+            return formatWorkCenter(wc, request.erpUser);
+        },
+    });
+    // UPDATE
+    app.put("/:key", {
+        schema: {
+            description: "Update a work center",
+            tags: ["Work Centers"],
+            params: KeyParamsSchema,
+            body: UpdateWorkCenterSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("erp_admin"),
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const data = request.body;
+            const userId = request.erpUser.id;
+            const existing = await findExisting(key);
+            if (!existing) {
+                return notFound(reply, `Work center '${key}' not found`);
+            }
+            const wc = await updateWorkCenter(key, data, userId);
+            const full = formatWorkCenter(wc, request.erpUser);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE
+    app.delete("/:key", {
+        schema: {
+            description: "Delete a work center",
+            tags: ["Work Centers"],
+            params: KeyParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("erp_admin"),
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const existing = await findExisting(key);
+            if (!existing) {
+                return notFound(reply, `Work center '${key}' not found`);
+            }
+            await deleteWorkCenter(key);
+            reply.status(204);
+        },
+    });
+    // ASSIGN USER
+    app.post("/:key/users", {
+        schema: {
+            description: "Assign a user to a work center",
+            tags: ["Work Centers"],
+            params: KeyParamsSchema,
+            body: AssignWorkCenterUserSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("erp_admin"),
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const { username } = request.body;
+            const userId = request.erpUser.id;
+            const existing = await findExisting(key);
+            if (!existing) {
+                return notFound(reply, `Work center '${key}' not found`);
+            }
+            const wc = await assignUser(key, username, userId);
+            const full = formatWorkCenter(wc, request.erpUser);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // REMOVE USER
+    app.delete("/:key/users/:username", {
+        schema: {
+            description: "Remove a user from a work center",
+            tags: ["Work Centers"],
+            params: UserParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("erp_admin"),
+        handler: async (request, reply) => {
+            const { key, username } = request.params;
+            const existing = await findExisting(key);
+            if (!existing) {
+                return notFound(reply, `Work center '${key}' not found`);
+            }
+            await removeUser(key, username);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=work-centers.js.map

package/dist/schema-registry.js

@@ -0,0 +1,45 @@
+import { AssignWorkCenterUserSchema, BatchCreateFieldSchema, BatchCreateStepSchema, BatchUpdateFieldValuesSchema, ChangePasswordSchema, ClockOutLaborTicketSchema, CompleteOrderRunSchema, CreateAgentUserSchema, CreateFieldRefSchema, CreateFieldSchema, CreateItemInstanceSchema, CreateItemSchema, CreateOperationDependencySchema, CreateOperationRunCommentSchema, CreateOperationSchema, CreateOrderRevisionSchema, CreateOrderRunSchema, CreateOrderSchema, CreateStepSchema, CreateUserSchema, CreateWorkCenterSchema, GrantPermissionSchema, LoginRequestSchema, TransitionNoteSchema, UpdateFieldSchema, UpdateFieldValueSchema, UpdateItemInstanceSchema, UpdateItemSchema, UpdateOperationRunSchema, UpdateOperationSchema, UpdateOrderRevisionSchema, UpdateOrderRunSchema, UpdateOrderSchema, UpdateStepSchema, UpdateUserSchema, UpdateWorkCenterSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+export const schemaRegistry = {
+    CreateItem: CreateItemSchema,
+    UpdateItem: UpdateItemSchema,
+    CreateItemInstance: CreateItemInstanceSchema,
+    UpdateItemInstance: UpdateItemInstanceSchema,
+    CreateOrder: CreateOrderSchema,
+    UpdateOrder: UpdateOrderSchema,
+    CreateOrderRevision: CreateOrderRevisionSchema,
+    UpdateOrderRevision: UpdateOrderRevisionSchema,
+    CreateOrderRun: CreateOrderRunSchema,
+    UpdateOrderRun: UpdateOrderRunSchema,
+    CompleteOrderRun: CompleteOrderRunSchema,
+    CreateOperation: CreateOperationSchema,
+    CreateFieldRef: CreateFieldRefSchema,
+    CreateOperationDependency: CreateOperationDependencySchema,
+    UpdateOperation: UpdateOperationSchema,
+    TransitionNote: TransitionNoteSchema,
+    UpdateOperationRun: UpdateOperationRunSchema,
+    CreateOperationRunComment: CreateOperationRunCommentSchema,
+    CreateStep: CreateStepSchema,
+    BatchCreateStep: BatchCreateStepSchema,
+    UpdateStep: UpdateStepSchema,
+    CreateField: CreateFieldSchema,
+    BatchCreateField: BatchCreateFieldSchema,
+    UpdateField: UpdateFieldSchema,
+    UpdateFieldValue: UpdateFieldValueSchema,
+    BatchUpdateFieldValues: BatchUpdateFieldValuesSchema,
+    LoginRequest: LoginRequestSchema,
+    CreateUser: CreateUserSchema,
+    CreateAgentUser: CreateAgentUserSchema,
+    UpdateUser: UpdateUserSchema,
+    GrantPermission: GrantPermissionSchema,
+    ChangePassword: ChangePasswordSchema,
+    ClockOutLaborTicket: ClockOutLaborTicketSchema,
+    CreateWorkCenter: CreateWorkCenterSchema,
+    UpdateWorkCenter: UpdateWorkCenterSchema,
+    AssignWorkCenterUser: AssignWorkCenterUserSchema,
+};
+// Register schemas with Zod global registry for OpenAPI components/schemas population
+for (const [name, schema] of Object.entries(schemaRegistry)) {
+    z.globalRegistry.add(schema, { id: name });
+}
+//# sourceMappingURL=schema-registry.js.map

package/dist/services/attachment-service.js

@@ -0,0 +1,118 @@
+import { MAX_ATTACHMENT_SIZE } from "@naisys/common";
+import { createHash, randomBytes } from "crypto";
+import { createWriteStream, existsSync, mkdirSync, renameSync, unlinkSync, } from "fs";
+import { join } from "path";
+import erpDb from "../erpDb.js";
+function attachmentsDir() {
+    return join(process.env.NAISYS_FOLDER || "", "attachments");
+}
+/**
+ * Store a file buffer as a content-addressable attachment under
+ * attachments/erp/<first2>/<next2>/<fullhash>
+ * and create the DB records (Attachment + FieldAttachment).
+ */
+export async function uploadAttachment(fileBuffer, filename, uploadedById, fieldValueId) {
+    if (fileBuffer.length === 0) {
+        throw new Error("Empty file");
+    }
+    if (fileBuffer.length > MAX_ATTACHMENT_SIZE) {
+        throw new Error(`File too large. Max size: ${MAX_ATTACHMENT_SIZE} bytes`);
+    }
+    const fileHash = createHash("sha256").update(fileBuffer).digest("hex");
+    // Write to temp, then move to content-addressable path
+    const tmpDir = join(attachmentsDir(), "tmp");
+    mkdirSync(tmpDir, { recursive: true });
+    const tmpPath = join(tmpDir, `${Date.now()}_${uploadedById}_${Math.random().toString(36).slice(2)}`);
+    const ws = createWriteStream(tmpPath);
+    await new Promise((resolve, reject) => {
+        ws.on("finish", resolve);
+        ws.on("error", reject);
+        ws.end(fileBuffer);
+    });
+    const storageDir = join(attachmentsDir(), "erp", fileHash.slice(0, 2), fileHash.slice(2, 4));
+    mkdirSync(storageDir, { recursive: true });
+    const storagePath = join(storageDir, fileHash);
+    if (existsSync(storagePath)) {
+        try {
+            unlinkSync(tmpPath);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    else {
+        renameSync(tmpPath, storagePath);
+    }
+    // Create Attachment + FieldAttachment in a transaction
+    const attachment = await erpDb.$transaction(async (tx) => {
+        const att = await tx.attachment.create({
+            data: {
+                publicId: randomBytes(8).toString("base64url").slice(0, 10),
+                filepath: storagePath,
+                filename,
+                fileSize: fileBuffer.length,
+                fileHash,
+                uploadedById,
+            },
+        });
+        await tx.fieldAttachment.create({
+            data: {
+                fieldValueId,
+                attachmentId: att.id,
+            },
+        });
+        return att;
+    });
+    return {
+        attachmentId: attachment.publicId,
+        filename: attachment.filename,
+        fileSize: attachment.fileSize,
+        fileHash: attachment.fileHash,
+    };
+}
+/**
+ * List attachments for a field value.
+ */
+export async function listAttachmentsForFieldValue(fieldValueId) {
+    const links = await erpDb.fieldAttachment.findMany({
+        where: { fieldValueId },
+        include: {
+            attachment: {
+                select: { publicId: true, filename: true, fileSize: true },
+            },
+        },
+    });
+    return links.map((l) => ({
+        id: l.attachment.publicId,
+        filename: l.attachment.filename,
+        fileSize: l.attachment.fileSize,
+    }));
+}
+/**
+ * Get an attachment's file path for download.
+ */
+export async function getAttachmentFilePath(publicId) {
+    const att = await erpDb.attachment.findUnique({
+        where: { publicId },
+        select: { filepath: true, filename: true },
+    });
+    return att;
+}
+/**
+ * Delete a field attachment link. Does NOT delete the file on disk
+ * (other records may reference the same content-addressable file).
+ */
+export async function deleteFieldAttachment(fieldValueId, publicId) {
+    const att = await erpDb.attachment.findUnique({
+        where: { publicId },
+        select: { id: true },
+    });
+    if (!att)
+        throw new Error("Attachment not found");
+    await erpDb.fieldAttachment.delete({
+        where: {
+            fieldValueId_attachmentId: { fieldValueId, attachmentId: att.id },
+        },
+    });
+}
+//# sourceMappingURL=attachment-service.js.map

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

@@ -0,0 +1,74 @@
+import erpDb from "../erpDb.js";
+const includeFieldRef = {
+    sourceStep: {
+        select: {
+            seqNo: true,
+            title: true,
+            operation: { select: { seqNo: true, title: true } },
+            fieldSet: {
+                select: {
+                    fields: {
+                        select: { seqNo: true, label: true, type: true },
+                        orderBy: { seqNo: "asc" },
+                    },
+                },
+            },
+        },
+    },
+    createdBy: { select: { username: true } },
+};
+export async function listFieldRefs(operationId) {
+    return erpDb.operationFieldRef.findMany({
+        where: { operationId },
+        include: includeFieldRef,
+        orderBy: { seqNo: "asc" },
+    });
+}
+export async function getFieldRef(operationId, seqNo) {
+    return erpDb.operationFieldRef.findFirst({
+        where: { operationId, seqNo },
+        include: includeFieldRef,
+    });
+}
+export async function createFieldRef(operationId, seqNo, title, sourceStepId, userId) {
+    // Auto-assign seqNo if not provided
+    let assignedSeqNo = seqNo;
+    if (!assignedSeqNo) {
+        const maxRow = await erpDb.operationFieldRef.findFirst({
+            where: { operationId },
+            orderBy: { seqNo: "desc" },
+            select: { seqNo: true },
+        });
+        const maxSeq = maxRow?.seqNo ?? 0;
+        assignedSeqNo = Math.ceil((maxSeq + 1) / 10) * 10;
+    }
+    return erpDb.operationFieldRef.create({
+        data: {
+            operationId,
+            seqNo: assignedSeqNo,
+            title,
+            sourceStepId,
+            createdById: userId,
+        },
+        include: includeFieldRef,
+    });
+}
+export async function deleteFieldRef(id) {
+    await erpDb.operationFieldRef.delete({ where: { id } });
+}
+export async function findExistingFieldRef(operationId, seqNo) {
+    return erpDb.operationFieldRef.findFirst({
+        where: { operationId, seqNo },
+        select: { id: true },
+    });
+}
+/**
+ * Check if a source step already has a field ref for this operation.
+ */
+export async function checkDuplicateSource(operationId, sourceStepId) {
+    return erpDb.operationFieldRef.findFirst({
+        where: { operationId, sourceStepId },
+        select: { id: true },
+    });
+}
+//# sourceMappingURL=field-ref-service.js.map

package/dist/services/field-service.js

@@ -0,0 +1,114 @@
+import { FieldType } from "@naisys/erp-shared";
+import erpDb from "../erpDb.js";
+import { calcNextSeqNo, includeUsers, } from "../route-helpers.js";
+// --- Lookups ---
+export async function listFields(fieldSetId) {
+    return erpDb.field.findMany({
+        where: { fieldSetId },
+        include: includeUsers,
+        orderBy: { seqNo: "asc" },
+    });
+}
+export async function getField(fieldSetId, fieldSeqNo) {
+    return erpDb.field.findFirst({
+        where: { fieldSetId, seqNo: fieldSeqNo },
+        include: includeUsers,
+    });
+}
+export async function findExistingField(fieldSetId, fieldSeqNo) {
+    return erpDb.field.findFirst({
+        where: { fieldSetId, seqNo: fieldSeqNo },
+    });
+}
+// --- FieldSet / FieldRecord helpers ---
+export async function ensureFieldSet(fieldSetId, userId) {
+    if (fieldSetId)
+        return fieldSetId;
+    const fs = await erpDb.fieldSet.create({
+        data: { createdById: userId },
+    });
+    return fs.id;
+}
+export async function ensureFieldRecord(fieldRecordId, fieldSetId, userId) {
+    if (fieldRecordId)
+        return fieldRecordId;
+    const fr = await erpDb.fieldRecord.create({
+        data: { fieldSetId, createdById: userId },
+    });
+    return fr.id;
+}
+/**
+ * Get or create a FieldRecord for a StepRun, linking it back.
+ * Returns the fieldRecordId, or null if the step has no fieldSet.
+ */
+export async function ensureStepRunFieldRecord(stepRunId, userId) {
+    const sr = await erpDb.stepRun.findUniqueOrThrow({
+        where: { id: stepRunId },
+        select: { fieldRecordId: true, step: { select: { fieldSetId: true } } },
+    });
+    if (sr.fieldRecordId)
+        return sr.fieldRecordId;
+    if (!sr.step.fieldSetId)
+        return null;
+    const fieldRecordId = await ensureFieldRecord(null, sr.step.fieldSetId, userId);
+    await erpDb.stepRun.update({
+        where: { id: stepRunId },
+        data: { fieldRecordId },
+    });
+    return fieldRecordId;
+}
+// --- Mutations ---
+export async function createFields(fieldSetId, items, userId) {
+    return erpDb.$transaction(async (erpTx) => {
+        const maxSeq = await erpTx.field.findFirst({
+            where: { fieldSetId },
+            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 field = await erpTx.field.create({
+                data: {
+                    fieldSetId,
+                    seqNo,
+                    label: item.label,
+                    type: item.type ?? FieldType.string,
+                    isArray: item.isArray ?? false,
+                    required: item.required ?? false,
+                    createdById: userId,
+                    updatedById: userId,
+                },
+                include: includeUsers,
+            });
+            created.push(field);
+            if (!item.seqNo) {
+                nextSeqNo = calcNextSeqNo(seqNo);
+            }
+        }
+        return created;
+    });
+}
+export async function createField(fieldSetId, data, userId) {
+    const [field] = await createFields(fieldSetId, [data], userId);
+    return field;
+}
+export async function updateField(id, data, userId) {
+    return erpDb.field.update({
+        where: { id },
+        data: {
+            ...(data.label !== undefined ? { label: data.label } : {}),
+            ...(data.type !== undefined ? { type: data.type } : {}),
+            ...(data.isArray !== undefined ? { isArray: data.isArray } : {}),
+            ...(data.required !== undefined ? { required: data.required } : {}),
+            ...(data.seqNo !== undefined ? { seqNo: data.seqNo } : {}),
+            updatedById: userId,
+        },
+        include: includeUsers,
+    });
+}
+export async function deleteField(id) {
+    await erpDb.field.delete({ where: { id } });
+}
+//# sourceMappingURL=field-service.js.map