@naisys/erp 3.0.0-beta.3

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.d.ts

@@ -0,0 +1,33 @@
+export interface UploadResult {
+    attachmentId: string;
+    filename: string;
+    fileSize: number;
+    fileHash: string;
+}
+/**
+ * Store a file buffer as a content-addressable attachment under
+ * attachments/erp/<first2>/<next2>/<fullhash>
+ * and create the DB records (Attachment + FieldAttachment).
+ */
+export declare function uploadAttachment(fileBuffer: Buffer, filename: string, uploadedById: number, fieldValueId: number): Promise<UploadResult>;
+/**
+ * List attachments for a field value.
+ */
+export declare function listAttachmentsForFieldValue(fieldValueId: number): Promise<{
+    id: string;
+    filename: string;
+    fileSize: number;
+}[]>;
+/**
+ * Get an attachment's file path for download.
+ */
+export declare function getAttachmentFilePath(publicId: string): Promise<{
+    filepath: string;
+    filename: string;
+} | null>;
+/**
+ * Delete a field attachment link. Does NOT delete the file on disk
+ * (other records may reference the same content-addressable file).
+ */
+export declare function deleteFieldAttachment(fieldValueId: number, publicId: string): Promise<void>;
+//# sourceMappingURL=attachment-service.d.ts.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.d.ts

@@ -0,0 +1,96 @@
+export type FieldRefWithDetails = Awaited<ReturnType<typeof listFieldRefs>>[number];
+export declare function listFieldRefs(operationId: number): Promise<({
+    createdBy: {
+        username: string;
+    };
+    sourceStep: {
+        title: string;
+        operation: {
+            title: string;
+            seqNo: number;
+        };
+        fieldSet: {
+            fields: {
+                seqNo: number;
+                type: import("../generated/prisma/enums.js").FieldType;
+                label: string;
+            }[];
+        } | null;
+        seqNo: number;
+    };
+} & {
+    title: string;
+    operationId: number;
+    createdAt: Date;
+    id: number;
+    seqNo: number;
+    createdById: number;
+    sourceStepId: number;
+})[]>;
+export declare function getFieldRef(operationId: number, seqNo: number): Promise<({
+    createdBy: {
+        username: string;
+    };
+    sourceStep: {
+        title: string;
+        operation: {
+            title: string;
+            seqNo: number;
+        };
+        fieldSet: {
+            fields: {
+                seqNo: number;
+                type: import("../generated/prisma/enums.js").FieldType;
+                label: string;
+            }[];
+        } | null;
+        seqNo: number;
+    };
+} & {
+    title: string;
+    operationId: number;
+    createdAt: Date;
+    id: number;
+    seqNo: number;
+    createdById: number;
+    sourceStepId: number;
+}) | null>;
+export declare function createFieldRef(operationId: number, seqNo: number | undefined, title: string, sourceStepId: number, userId: number): Promise<{
+    createdBy: {
+        username: string;
+    };
+    sourceStep: {
+        title: string;
+        operation: {
+            title: string;
+            seqNo: number;
+        };
+        fieldSet: {
+            fields: {
+                seqNo: number;
+                type: import("../generated/prisma/enums.js").FieldType;
+                label: string;
+            }[];
+        } | null;
+        seqNo: number;
+    };
+} & {
+    title: string;
+    operationId: number;
+    createdAt: Date;
+    id: number;
+    seqNo: number;
+    createdById: number;
+    sourceStepId: number;
+}>;
+export declare function deleteFieldRef(id: number): Promise<void>;
+export declare function findExistingFieldRef(operationId: number, seqNo: number): Promise<{
+    id: number;
+} | null>;
+/**
+ * Check if a source step already has a field ref for this operation.
+ */
+export declare function checkDuplicateSource(operationId: number, sourceStepId: number): Promise<{
+    id: number;
+} | null>;
+//# sourceMappingURL=field-ref-service.d.ts.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.d.ts

@@ -0,0 +1,49 @@
+import { FieldType } from "@naisys/erp-shared";
+import type { FieldModel } from "../generated/prisma/models/Field.js";
+import { type WithAuditUsers } from "../route-helpers.js";
+export type FieldWithUsers = FieldModel & WithAuditUsers;
+export declare function listFields(fieldSetId: number): Promise<FieldWithUsers[]>;
+export declare function getField(fieldSetId: number, fieldSeqNo: number): Promise<FieldWithUsers | null>;
+export declare function findExistingField(fieldSetId: number, fieldSeqNo: number): Promise<{
+    required: boolean;
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+    seqNo: number;
+    type: import("../generated/prisma/enums.js").FieldType;
+    label: string;
+    isArray: boolean;
+    createdById: number;
+    updatedById: number;
+    fieldSetId: number;
+} | null>;
+export declare function ensureFieldSet(fieldSetId: number | null, userId: number): Promise<number>;
+export declare function ensureFieldRecord(fieldRecordId: number | null, fieldSetId: number, userId: number): Promise<number>;
+/**
+ * Get or create a FieldRecord for a StepRun, linking it back.
+ * Returns the fieldRecordId, or null if the step has no fieldSet.
+ */
+export declare function ensureStepRunFieldRecord(stepRunId: number, userId: number): Promise<number | null>;
+export declare function createFields(fieldSetId: number, items: Array<{
+    seqNo?: number | null;
+    label: string;
+    type?: FieldType | null;
+    isArray?: boolean | null;
+    required?: boolean | null;
+}>, userId: number): Promise<FieldWithUsers[]>;
+export declare function createField(fieldSetId: number, data: {
+    seqNo?: number | null;
+    label: string;
+    type?: FieldType | null;
+    isArray?: boolean | null;
+    required?: boolean | null;
+}, userId: number): Promise<FieldWithUsers>;
+export declare function updateField(id: number, data: {
+    label?: string;
+    type?: FieldType;
+    isArray?: boolean;
+    required?: boolean;
+    seqNo?: number;
+}, userId: number): Promise<FieldWithUsers>;
+export declare function deleteField(id: number): Promise<void>;
+//# sourceMappingURL=field-service.d.ts.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

package/dist/services/field-value-service.d.ts

@@ -0,0 +1,61 @@
+import { type FieldValidation, type FieldValue } from "@naisys/erp-shared";
+import type { StepRunWithStepAndFields } from "./step-run-service.js";
+export declare function findStepRunWithField(id: number, opRunId: number, fieldSeqNo: number): Promise<({
+    step: {
+        fieldSet: {
+            fields: {
+                required: boolean;
+                id: number;
+                seqNo: number;
+                type: import("../generated/prisma/enums.js").FieldType;
+                label: string;
+                isArray: boolean;
+                fieldSetId: number;
+            }[];
+        } | null;
+        multiSet: boolean;
+    };
+} & {
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+    createdById: number;
+    updatedById: number;
+    statusNote: string | null;
+    completed: boolean;
+    operationRunId: number;
+    stepId: number;
+    fieldRecordId: number | null;
+}) | null>;
+/**
+ * Serialize a field value for DB storage.
+ * - Scalar (string): stored as-is
+ * - Array (string[]): stored as JSON array string
+ */
+export declare function serializeFieldValue(value: FieldValue): string;
+/**
+ * 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 declare function deserializeFieldValue(dbValue: string, isArray: boolean): FieldValue;
+/**
+ * Check that the value shape matches the field's isArray flag.
+ * Returns an error string if mismatched, or null if OK.
+ */
+export declare function checkFieldValueShape(label: string, type: string, isArray: boolean, value: FieldValue): string | null;
+export declare function validateFieldValue(type: string, isArray: boolean, required: boolean, value: FieldValue): FieldValidation;
+export declare function validateCompletionFields(existing: StepRunWithStepAndFields): string | null;
+export declare function formatAttachmentLabel(filename: string, fileSize: number): string;
+/**
+ * Query current attachments for a field value and rebuild the stored value
+ * to reflect them. Returns the new API-shape value.
+ */
+export declare function rebuildAttachmentFieldValue(fieldRecordId: number, fieldId: number, setIndex: number, isArray: boolean, userId: number): Promise<FieldValue>;
+/**
+ * Clear an attachment field: delete all FieldAttachment links and set value to empty.
+ */
+export declare function clearAttachmentFieldValue(fieldRecordId: number, fieldId: number, setIndex: number, userId: number): Promise<void>;
+export declare function upsertFieldValue(fieldRecordId: number, fieldId: number, setIndex: number, value: FieldValue, userId: number): Promise<void>;
+export declare function deleteFieldValueSet(fieldRecordId: number, setIndex: number): Promise<void>;
+//# sourceMappingURL=field-value-service.d.ts.map