@naisys/erp 3.0.0-beta.6

package/dist/routes/inventory.js

@@ -0,0 +1,70 @@
+import { InventoryListQuerySchema, InventoryListResponseSchema, } from "@naisys/erp-shared";
+import erpDb from "../erpDb.js";
+import { API_PREFIX, paginationLinks } from "../hateoas.js";
+export default function inventoryRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    app.get("/", {
+        schema: {
+            description: "List all item instances across all items (inventory view)",
+            tags: ["Inventory"],
+            querystring: InventoryListQuerySchema,
+            response: {
+                200: InventoryListResponseSchema,
+            },
+        },
+        handler: async (request) => {
+            const { page, pageSize, search } = request.query;
+            const where = {};
+            if (search) {
+                where.OR = [
+                    { key: { contains: search } },
+                    { item: { key: { contains: search } } },
+                ];
+            }
+            const [instances, total] = await Promise.all([
+                erpDb.itemInstance.findMany({
+                    where,
+                    include: {
+                        item: { select: { key: true } },
+                        orderRun: {
+                            select: {
+                                runNo: true,
+                                order: { select: { key: true } },
+                            },
+                        },
+                    },
+                    skip: (page - 1) * pageSize,
+                    take: pageSize,
+                    orderBy: { createdAt: "desc" },
+                }),
+                erpDb.itemInstance.count({ where }),
+            ]);
+            return {
+                items: instances.map((inst) => ({
+                    id: inst.id,
+                    itemKey: inst.item.key,
+                    key: inst.key,
+                    quantity: inst.quantity,
+                    orderKey: inst.orderRun?.order.key ?? null,
+                    orderRunNo: inst.orderRun?.runNo ?? null,
+                    createdAt: inst.createdAt.toISOString(),
+                })),
+                total,
+                page,
+                pageSize,
+                _links: paginationLinks("inventory", page, pageSize, total, {
+                    search,
+                }),
+                _actionTemplates: [
+                    {
+                        rel: "viewInstance",
+                        hrefTemplate: `${API_PREFIX}/items/{itemKey}/instances/{id}`,
+                        method: "GET",
+                        title: "View Instance",
+                    },
+                ],
+            };
+        },
+    });
+}
+//# sourceMappingURL=inventory.js.map

package/dist/routes/item-fields.js

@@ -0,0 +1,220 @@
+import { CreateFieldSchema, ErrorResponseSchema, FieldListResponseSchema, FieldSchema, MutateResponseSchema, SeqNoCreateResponseSchema, UpdateFieldSchema, } from "@naisys/erp-shared";
+import { z } from "zod/v4";
+import { hasPermission, requirePermission } from "../auth-middleware.js";
+import erpDb from "../erpDb.js";
+import { notFound } from "../error-handler.js";
+import { API_PREFIX, selfLink } from "../hateoas.js";
+import { calcNextSeqNo, childItemLinks, formatAuditFields, mutationResult, } from "../route-helpers.js";
+import { createField, deleteField, ensureFieldSet, findExistingField, getField, listFields, updateField, } from "../services/field-service.js";
+import { findExisting as findExistingItem } from "../services/item-service.js";
+const ParamsSchema = z.object({ key: z.string() });
+const FieldParamsSchema = z.object({
+    key: z.string(),
+    fieldSeqNo: z.coerce.number().int(),
+});
+function fieldBasePath(key) {
+    return `/items/${key}/fields`;
+}
+function formatField(key, user, field) {
+    const base = fieldBasePath(key);
+    return {
+        id: field.id,
+        fieldSetId: field.fieldSetId,
+        seqNo: field.seqNo,
+        label: field.label,
+        type: field.type,
+        isArray: field.isArray,
+        required: field.required,
+        ...formatAuditFields(field),
+        _links: childItemLinks(base, field.seqNo, "Fields", `/items/${key}`, "Item", "Field"),
+        _actions: hasPermission(user, "item_manager")
+            ? [
+                {
+                    rel: "update",
+                    href: `${API_PREFIX}${base}/${field.seqNo}`,
+                    method: "PUT",
+                    title: "Update",
+                    schema: `${API_PREFIX}/schemas/UpdateField`,
+                },
+                {
+                    rel: "delete",
+                    href: `${API_PREFIX}${base}/${field.seqNo}`,
+                    method: "DELETE",
+                    title: "Delete",
+                },
+            ]
+            : [],
+    };
+}
+export default function itemFieldRoutes(fastify) {
+    const app = fastify.withTypeProvider();
+    // LIST
+    app.get("/", {
+        schema: {
+            description: "List fields for an item",
+            tags: ["Item Fields"],
+            params: ParamsSchema,
+            response: {
+                200: FieldListResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const item = await findExistingItem(key);
+            if (!item)
+                return notFound(reply, `Item '${key}' not found`);
+            const fields = item.fieldSetId ? await listFields(item.fieldSetId) : [];
+            const maxSeq = fields.length > 0 ? fields[fields.length - 1].seqNo : 0;
+            const base = fieldBasePath(key);
+            return {
+                items: fields.map((f) => {
+                    const { _links, ...rest } = formatField(key, request.erpUser, f);
+                    return rest;
+                }),
+                total: fields.length,
+                nextSeqNo: calcNextSeqNo(maxSeq),
+                _links: [selfLink(base)],
+                _linkTemplates: [
+                    {
+                        rel: "item",
+                        hrefTemplate: `${API_PREFIX}${base}/{seqNo}`,
+                    },
+                ],
+                _actions: hasPermission(request.erpUser, "item_manager")
+                    ? [
+                        {
+                            rel: "create",
+                            href: `${API_PREFIX}${base}`,
+                            method: "POST",
+                            title: "Add Field",
+                            schema: `${API_PREFIX}/schemas/CreateField`,
+                        },
+                    ]
+                    : [],
+            };
+        },
+    });
+    // CREATE
+    app.post("/", {
+        schema: {
+            description: "Create a field for an item",
+            tags: ["Item Fields"],
+            params: ParamsSchema,
+            body: CreateFieldSchema,
+            response: {
+                201: SeqNoCreateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("item_manager"),
+        handler: async (request, reply) => {
+            const { key } = request.params;
+            const { seqNo: requestedSeqNo, label, type, isArray, required, } = request.body;
+            const userId = request.erpUser.id;
+            const item = await findExistingItem(key);
+            if (!item)
+                return notFound(reply, `Item '${key}' not found`);
+            let fieldSetId = item.fieldSetId;
+            if (!fieldSetId) {
+                fieldSetId = await ensureFieldSet(null, userId);
+                await erpDb.item.update({
+                    where: { key },
+                    data: { fieldSetId },
+                });
+            }
+            const field = await createField(fieldSetId, { seqNo: requestedSeqNo, label, type, isArray, required }, userId);
+            const full = formatField(key, request.erpUser, field);
+            reply.status(201);
+            return mutationResult(request, reply, full, {
+                id: full.id,
+                seqNo: full.seqNo,
+                _links: full._links,
+                _actions: full._actions,
+            });
+        },
+    });
+    // GET
+    app.get("/:fieldSeqNo", {
+        schema: {
+            description: "Get an item field",
+            tags: ["Item Fields"],
+            params: FieldParamsSchema,
+            response: {
+                200: FieldSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        handler: async (request, reply) => {
+            const { key, fieldSeqNo } = request.params;
+            const item = await findExistingItem(key);
+            if (!item)
+                return notFound(reply, `Item '${key}' not found`);
+            if (!item.fieldSetId)
+                return notFound(reply, `Field ${fieldSeqNo} not found`);
+            const field = await getField(item.fieldSetId, fieldSeqNo);
+            if (!field)
+                return notFound(reply, `Field ${fieldSeqNo} not found`);
+            return formatField(key, request.erpUser, field);
+        },
+    });
+    // UPDATE
+    app.put("/:fieldSeqNo", {
+        schema: {
+            description: "Update an item field",
+            tags: ["Item Fields"],
+            params: FieldParamsSchema,
+            body: UpdateFieldSchema,
+            response: {
+                200: MutateResponseSchema,
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("item_manager"),
+        handler: async (request, reply) => {
+            const { key, fieldSeqNo } = request.params;
+            const { label, type, isArray, required, seqNo: newSeqNo } = request.body;
+            const userId = request.erpUser.id;
+            const item = await findExistingItem(key);
+            if (!item)
+                return notFound(reply, `Item '${key}' not found`);
+            if (!item.fieldSetId)
+                return notFound(reply, `Field ${fieldSeqNo} not found`);
+            const existing = await findExistingField(item.fieldSetId, fieldSeqNo);
+            if (!existing)
+                return notFound(reply, `Field ${fieldSeqNo} not found`);
+            const field = await updateField(existing.id, { label, type, isArray, required, seqNo: newSeqNo }, userId);
+            const full = formatField(key, request.erpUser, field);
+            return mutationResult(request, reply, full, {
+                _actions: full._actions,
+            });
+        },
+    });
+    // DELETE
+    app.delete("/:fieldSeqNo", {
+        schema: {
+            description: "Delete an item field",
+            tags: ["Item Fields"],
+            params: FieldParamsSchema,
+            response: {
+                204: z.void(),
+                404: ErrorResponseSchema,
+            },
+        },
+        preHandler: requirePermission("item_manager"),
+        handler: async (request, reply) => {
+            const { key, fieldSeqNo } = request.params;
+            const item = await findExistingItem(key);
+            if (!item)
+                return notFound(reply, `Item '${key}' not found`);
+            if (!item.fieldSetId)
+                return notFound(reply, `Field ${fieldSeqNo} not found`);
+            const existing = await findExistingField(item.fieldSetId, fieldSeqNo);
+            if (!existing)
+                return notFound(reply, `Field ${fieldSeqNo} not found`);
+            await deleteField(existing.id);
+            reply.status(204);
+        },
+    });
+}
+//# sourceMappingURL=item-fields.js.map