@naisys/erp 3.0.0-beta.3

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

@@ -0,0 +1,152 @@
+import type { ItemInstanceModel } from "../generated/prisma/models/ItemInstance.js";
+import { type WithAuditUsers } from "../route-helpers.js";
+export declare const includeItemInstanceRelations: {
+    readonly item: {
+        readonly select: {
+            readonly key: true;
+            readonly fieldSet: {
+                readonly select: {
+                    readonly id: true;
+                    readonly fields: {
+                        readonly select: {
+                            readonly id: true;
+                            readonly seqNo: true;
+                            readonly label: true;
+                            readonly type: true;
+                            readonly isArray: true;
+                            readonly required: true;
+                        };
+                        readonly orderBy: {
+                            readonly seqNo: "asc";
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly orderRun: {
+        readonly select: {
+            readonly runNo: true;
+            readonly order: {
+                readonly select: {
+                    readonly key: true;
+                };
+            };
+        };
+    };
+    readonly fieldRecord: {
+        readonly include: {
+            readonly fieldValues: {
+                readonly select: {
+                    readonly id: true;
+                    readonly fieldId: true;
+                    readonly setIndex: true;
+                    readonly value: true;
+                    readonly fieldAttachments: {
+                        readonly select: {
+                            readonly attachment: {
+                                readonly select: {
+                                    readonly publicId: true;
+                                    readonly filename: true;
+                                    readonly fileSize: true;
+                                };
+                            };
+                        };
+                    };
+                };
+                readonly orderBy: {
+                    readonly setIndex: "asc";
+                };
+            };
+        };
+    };
+    readonly createdBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+    readonly updatedBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+};
+type FieldDef = {
+    id: number;
+    seqNo: number;
+    label: string;
+    type: string;
+    isArray: boolean;
+    required: boolean;
+};
+export type ItemInstanceWithRelations = ItemInstanceModel & WithAuditUsers & {
+    item: {
+        key: string;
+        fieldSet: {
+            id: number;
+            fields: FieldDef[];
+        } | null;
+    };
+    orderRun: {
+        runNo: number;
+        order: {
+            key: string;
+        };
+    } | null;
+    fieldRecordId: number | null;
+    fieldRecord: {
+        id: number;
+        fieldValues: {
+            id: number;
+            fieldId: number;
+            setIndex: number;
+            value: string;
+            fieldAttachments: {
+                attachment: {
+                    publicId: string;
+                    filename: string;
+                    fileSize: number;
+                };
+            }[];
+        }[];
+    } | null;
+};
+export declare function listItemInstances(where: Record<string, unknown>, page: number, pageSize: number): Promise<[ItemInstanceWithRelations[], number]>;
+export declare function findItemInstance(id: number): Promise<ItemInstanceWithRelations | null>;
+export declare function findItemInstanceByItemAndKey(itemId: number, key: string): Promise<ItemInstanceWithRelations | null>;
+export declare function findItemInstanceWithField(id: number, fieldSeqNo: number): Promise<({
+    item: {
+        fieldSet: {
+            id: number;
+            fields: {
+                required: boolean;
+                id: number;
+                seqNo: number;
+                type: import("../generated/prisma/enums.js").FieldType;
+                label: string;
+                isArray: boolean;
+            }[];
+        } | null;
+    };
+} & {
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+    key: string;
+    quantity: number | null;
+    orderRunId: number | null;
+    createdById: number;
+    updatedById: number;
+    itemId: number;
+    fieldRecordId: number | null;
+}) | null>;
+export declare function createItemInstance(itemId: number, key: string, quantity: number | null | undefined, orderRunId: number | null | undefined, userId: number): Promise<ItemInstanceWithRelations>;
+export declare function updateItemInstance(id: number, data: Record<string, unknown>, userId: number): Promise<ItemInstanceWithRelations>;
+export declare function deleteItemInstance(id: number): Promise<void>;
+/**
+ * Get or create a FieldRecord for an ItemInstance, linking it back.
+ * Returns the fieldRecordId, or null if the item has no fieldSet.
+ */
+export declare function ensureItemInstanceFieldRecord(instanceId: number, userId: number): Promise<number | null>;
+export {};
+//# sourceMappingURL=item-instance-service.d.ts.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.d.ts

@@ -0,0 +1,47 @@
+import type { ItemModel } from "../generated/prisma/models/Item.js";
+import { type WithAuditUsers } from "../route-helpers.js";
+import type { FieldWithUsers } from "./field-service.js";
+export declare const includeUsersAndFieldSet: {
+    readonly fieldSet: {
+        readonly include: {
+            readonly fields: {
+                readonly include: {
+                    readonly createdBy: {
+                        readonly select: {
+                            readonly username: true;
+                        };
+                    };
+                    readonly updatedBy: {
+                        readonly select: {
+                            readonly username: true;
+                        };
+                    };
+                };
+                readonly orderBy: {
+                    readonly seqNo: "asc";
+                };
+            };
+        };
+    };
+    readonly createdBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+    readonly updatedBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+};
+export type ItemWithUsers = ItemModel & WithAuditUsers & {
+    fieldSet: {
+        fields: FieldWithUsers[];
+    } | null;
+};
+export declare function listItems(where: Record<string, unknown>, page: number, pageSize: number): Promise<[ItemWithUsers[], number]>;
+export declare function findExisting(key: string): Promise<ItemWithUsers | null>;
+export declare function createItem(key: string, description: string | undefined, userId: number): Promise<ItemWithUsers>;
+export declare function updateItem(key: string, data: Record<string, unknown>, userId: number): Promise<ItemWithUsers>;
+export declare function deleteItem(key: string): Promise<void>;
+//# sourceMappingURL=item-service.d.ts.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