@naisys/erp 3.0.0-beta.3

package/dist/generated/prisma/models/WorkCenterUser.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=WorkCenterUser.js.map

package/dist/generated/prisma/models.d.ts

@@ -0,0 +1,28 @@
+export type * from './models/Order.js';
+export type * from './models/OrderRevision.js';
+export type * from './models/Operation.js';
+export type * from './models/OperationFieldRef.js';
+export type * from './models/OperationDependency.js';
+export type * from './models/WorkCenter.js';
+export type * from './models/WorkCenterUser.js';
+export type * from './models/FieldSet.js';
+export type * from './models/FieldRecord.js';
+export type * from './models/Field.js';
+export type * from './models/Step.js';
+export type * from './models/OrderRun.js';
+export type * from './models/OperationRun.js';
+export type * from './models/StepRun.js';
+export type * from './models/FieldValue.js';
+export type * from './models/Item.js';
+export type * from './models/ItemInstance.js';
+export type * from './models/User.js';
+export type * from './models/UserPermission.js';
+export type * from './models/Session.js';
+export type * from './models/SchemaVersion.js';
+export type * from './models/LaborTicket.js';
+export type * from './models/AuditLog.js';
+export type * from './models/Attachment.js';
+export type * from './models/FieldAttachment.js';
+export type * from './models/OperationRunComment.js';
+export type * from './commonInputTypes.js';
+//# sourceMappingURL=models.d.ts.map

package/dist/generated/prisma/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.js.map

package/dist/hateoas.d.ts

@@ -0,0 +1,7 @@
+import type { HateoasLink } from "@naisys/common";
+export declare const API_PREFIX = "/api/erp";
+export declare function selfLink(path: string, title?: string): HateoasLink;
+export declare function collectionLink(resource: string): HateoasLink;
+export declare function schemaLink(schemaName: string): HateoasLink;
+export declare function paginationLinks(basePath: string, page: number, pageSize: number, total: number, filters?: Record<string, string | undefined>): HateoasLink[];
+//# sourceMappingURL=hateoas.d.ts.map

package/dist/hateoas.js

@@ -0,0 +1,61 @@
+export const API_PREFIX = "/api/erp";
+export function selfLink(path, title) {
+    return { rel: "self", href: `${API_PREFIX}${path}`, title };
+}
+export function collectionLink(resource) {
+    return {
+        rel: "collection",
+        href: `${API_PREFIX}/${resource}`,
+        title: resource,
+    };
+}
+export function schemaLink(schemaName) {
+    return {
+        rel: "schema",
+        href: `${API_PREFIX}/schemas/${schemaName}`,
+    };
+}
+function buildQuery(page, pageSize, filters) {
+    const params = new URLSearchParams();
+    params.set("page", String(page));
+    params.set("pageSize", String(pageSize));
+    if (filters) {
+        for (const [key, value] of Object.entries(filters)) {
+            if (value !== undefined)
+                params.set(key, value);
+        }
+    }
+    return params.toString();
+}
+export function paginationLinks(basePath, page, pageSize, total, filters) {
+    const fullPath = `${API_PREFIX}/${basePath}`;
+    const totalPages = Math.ceil(total / pageSize);
+    const links = [
+        {
+            rel: "self",
+            href: `${fullPath}?${buildQuery(page, pageSize, filters)}`,
+        },
+        {
+            rel: "first",
+            href: `${fullPath}?${buildQuery(1, pageSize, filters)}`,
+        },
+        {
+            rel: "last",
+            href: `${fullPath}?${buildQuery(Math.max(1, totalPages), pageSize, filters)}`,
+        },
+    ];
+    if (page > 1) {
+        links.push({
+            rel: "prev",
+            href: `${fullPath}?${buildQuery(page - 1, pageSize, filters)}`,
+        });
+    }
+    if (page < totalPages) {
+        links.push({
+            rel: "next",
+            href: `${fullPath}?${buildQuery(page + 1, pageSize, filters)}`,
+        });
+    }
+    return links;
+}
+//# sourceMappingURL=hateoas.js.map

package/dist/route-helpers.d.ts

@@ -0,0 +1,318 @@
+import type { HateoasAction, HateoasLink } from "@naisys/common";
+import { type ActionDef as ActionDefBase, permGate } from "@naisys/common";
+import { type ErpPermission } from "@naisys/erp-shared";
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { ErpUser } from "./auth-middleware.js";
+/**
+ * Returns true when the caller wants the full entity in the mutation response.
+ * UI clients send `Prefer: return=representation`; agents get the slim default.
+ */
+export declare function wantsFullResponse(request: FastifyRequest): boolean;
+/**
+ * Override Fastify's schema-driven serializer so every field in the
+ * response object is emitted (not just the ones in the slim schema).
+ */
+export declare function useFullSerializer(reply: FastifyReply): void;
+/**
+ * Return `slim` by default, or `full` when the caller sends
+ * `Prefer: return=representation`.
+ *
+ * For full responses we override the serializer so that Fastify
+ * emits all fields instead of stripping them down to the (slim)
+ * response schema.
+ */
+export declare function mutationResult<TFull, TSlim>(request: FastifyRequest, reply: FastifyReply, full: TFull, slim: TSlim): TFull | TSlim;
+export declare const includeUsers: {
+    readonly createdBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+    readonly updatedBy: {
+        readonly select: {
+            readonly username: true;
+        };
+    };
+};
+export type WithAuditUsers = {
+    createdAt: Date;
+    createdBy: {
+        username: string;
+    };
+    updatedAt: Date;
+    updatedBy: {
+        username: string;
+    };
+};
+export declare function formatAuditFields(item: WithAuditUsers): {
+    createdAt: string;
+    createdBy: string;
+    updatedAt: string;
+    updatedBy: string;
+};
+export declare function formatDate(d: Date | null): string | null;
+export declare function calcNextSeqNo(currentMax: number): number;
+export declare function childItemLinks(basePath: string, itemKey: string | number, collectionTitle: string, parentPath: string, parentTitle: string, schemaName: string, parentRel?: string): HateoasLink[];
+export { permGate };
+export interface ActionDef<T> extends Omit<ActionDefBase<T>, "permission"> {
+    permission?: ErpPermission;
+}
+export declare function resolveActions<T extends {
+    user: ErpUser | undefined;
+}>(defs: ActionDef<T>[], baseHref: string, ctx: T): HateoasAction[];
+export declare function draftCrudActions(href: string, updateSchemaName: string, revStatus: string, user: ErpUser | undefined): HateoasAction[];
+export declare function checkOrderRunStarted(status: string): string | null;
+export declare function checkOpRunInProgress(status: string): string | null;
+/**
+ * If the operation has a work center, check that the user is assigned to it.
+ * Returns an error message or null if access is allowed.
+ */
+export declare function checkWorkCenterAccess(operationId: number, user: ErpUser): Promise<string | null>;
+export declare function resolveOrder(orderKey: string): Promise<{
+    description: string;
+    createdAt: Date;
+    id: number;
+    updatedAt: Date;
+    key: string;
+    status: import("./generated/prisma/enums.js").OrderStatus;
+    createdById: number;
+    updatedById: number;
+    itemId: number | null;
+} | null>;
+export declare function resolveRevision(orderKey: string, revNo: number): Promise<{
+    order: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        key: string;
+        status: import("./generated/prisma/enums.js").OrderStatus;
+        createdById: number;
+        updatedById: number;
+        itemId: number | null;
+    };
+    rev: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        status: import("./generated/prisma/enums.js").RevisionStatus;
+        changeSummary: string | null;
+        revNo: number;
+        createdById: number;
+        updatedById: number;
+        orderId: number;
+    };
+} | null>;
+export declare function resolveOperation(orderKey: string, revNo: number, opSeqNo: number): Promise<{
+    operation: {
+        title: string;
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        seqNo: number;
+        orderRevId: number;
+        workCenterId: number | null;
+        createdById: number;
+        updatedById: number;
+    };
+    order: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        key: string;
+        status: import("./generated/prisma/enums.js").OrderStatus;
+        createdById: number;
+        updatedById: number;
+        itemId: number | null;
+    };
+    rev: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        status: import("./generated/prisma/enums.js").RevisionStatus;
+        changeSummary: string | null;
+        revNo: number;
+        createdById: number;
+        updatedById: number;
+        orderId: number;
+    };
+} | null>;
+export declare function resolveStep(orderKey: string, revNo: number, opSeqNo: number, stepSeqNo: number): Promise<{
+    step: {
+        title: string;
+        operationId: number;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        seqNo: number;
+        instructions: string;
+        multiSet: boolean;
+        createdById: number;
+        updatedById: number;
+        fieldSetId: number | null;
+    };
+    operation: {
+        title: string;
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        seqNo: number;
+        orderRevId: number;
+        workCenterId: number | null;
+        createdById: number;
+        updatedById: number;
+    };
+    order: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        key: string;
+        status: import("./generated/prisma/enums.js").OrderStatus;
+        createdById: number;
+        updatedById: number;
+        itemId: number | null;
+    };
+    rev: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        status: import("./generated/prisma/enums.js").RevisionStatus;
+        changeSummary: string | null;
+        revNo: number;
+        createdById: number;
+        updatedById: number;
+        orderId: number;
+    };
+} | null>;
+export declare function resolveOrderRun(orderKey: string, runNo: number): Promise<{
+    order: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        key: string;
+        status: import("./generated/prisma/enums.js").OrderStatus;
+        createdById: number;
+        updatedById: number;
+        itemId: number | null;
+    };
+    run: {
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        status: import("./generated/prisma/enums.js").OrderRunStatus;
+        priority: import("./generated/prisma/enums.js").OrderRunPriority;
+        dueAt: string | null;
+        releaseNote: string | null;
+        orderRevId: number;
+        createdById: number;
+        updatedById: number;
+        orderId: number;
+        runNo: number;
+        cost: number | null;
+    };
+} | null>;
+export declare function resolveOpRun(orderKey: string, runNo: number, seqNo: number): Promise<{
+    opRun: {
+        operationId: number;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        orderRunId: number;
+        status: import("./generated/prisma/enums.js").OperationRunStatus;
+        assignedToId: number | null;
+        createdById: number;
+        updatedById: number;
+        cost: number | null;
+        statusNote: string | null;
+        completedAt: Date | null;
+    };
+    order: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        key: string;
+        status: import("./generated/prisma/enums.js").OrderStatus;
+        createdById: number;
+        updatedById: number;
+        itemId: number | null;
+    };
+    run: {
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        status: import("./generated/prisma/enums.js").OrderRunStatus;
+        priority: import("./generated/prisma/enums.js").OrderRunPriority;
+        dueAt: string | null;
+        releaseNote: string | null;
+        orderRevId: number;
+        createdById: number;
+        updatedById: number;
+        orderId: number;
+        runNo: number;
+        cost: number | null;
+    };
+} | null>;
+export declare function resolveStepRun(orderKey: string, runNo: number, seqNo: number, stepSeqNo: number): Promise<{
+    stepRun: {
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        createdById: number;
+        updatedById: number;
+        statusNote: string | null;
+        completed: boolean;
+        operationRunId: number;
+        stepId: number;
+        fieldRecordId: number | null;
+    };
+    opRun: {
+        operationId: number;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        orderRunId: number;
+        status: import("./generated/prisma/enums.js").OperationRunStatus;
+        assignedToId: number | null;
+        createdById: number;
+        updatedById: number;
+        cost: number | null;
+        statusNote: string | null;
+        completedAt: Date | null;
+    };
+    order: {
+        description: string;
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        key: string;
+        status: import("./generated/prisma/enums.js").OrderStatus;
+        createdById: number;
+        updatedById: number;
+        itemId: number | null;
+    };
+    run: {
+        createdAt: Date;
+        id: number;
+        updatedAt: Date;
+        status: import("./generated/prisma/enums.js").OrderRunStatus;
+        priority: import("./generated/prisma/enums.js").OrderRunPriority;
+        dueAt: string | null;
+        releaseNote: string | null;
+        orderRevId: number;
+        createdById: number;
+        updatedById: number;
+        orderId: number;
+        runNo: number;
+        cost: number | null;
+    };
+} | null>;
+//# sourceMappingURL=route-helpers.d.ts.map

package/dist/route-helpers.js

@@ -0,0 +1,220 @@
+import { permGate, resolveActions as resolveActionsBase, } from "@naisys/common";
+import { OperationRunStatus, OrderRunStatus, RevisionStatus, } from "@naisys/erp-shared";
+import { hasPermission } from "./auth-middleware.js";
+import erpDb from "./erpDb.js";
+import { API_PREFIX, schemaLink, selfLink } from "./hateoas.js";
+// --- Prefer: return=representation (RFC 7240) ---
+/**
+ * Returns true when the caller wants the full entity in the mutation response.
+ * UI clients send `Prefer: return=representation`; agents get the slim default.
+ */
+export function wantsFullResponse(request) {
+    const prefer = request.headers["prefer"];
+    return typeof prefer === "string" && prefer.includes("return=representation");
+}
+/**
+ * Override Fastify's schema-driven serializer so every field in the
+ * response object is emitted (not just the ones in the slim schema).
+ */
+export function useFullSerializer(reply) {
+    reply.header("content-type", "application/json; charset=utf-8");
+    reply.serializer(JSON.stringify);
+}
+/**
+ * Return `slim` by default, or `full` when the caller sends
+ * `Prefer: return=representation`.
+ *
+ * For full responses we override the serializer so that Fastify
+ * emits all fields instead of stripping them down to the (slim)
+ * response schema.
+ */
+export function mutationResult(request, reply, full, slim) {
+    if (wantsFullResponse(request)) {
+        useFullSerializer(reply);
+        return full;
+    }
+    return slim;
+}
+// --- Shared Prisma include for audit user fields ---
+export const includeUsers = {
+    createdBy: { select: { username: true } },
+    updatedBy: { select: { username: true } },
+};
+// --- Formatting helpers ---
+export function formatAuditFields(item) {
+    return {
+        createdAt: item.createdAt.toISOString(),
+        createdBy: item.createdBy.username,
+        updatedAt: item.updatedAt.toISOString(),
+        updatedBy: item.updatedBy.username,
+    };
+}
+export function formatDate(d) {
+    return d ? d.toISOString() : null;
+}
+export function calcNextSeqNo(currentMax) {
+    return Math.ceil((currentMax + 1) / 10) * 10;
+}
+// --- HATEOAS helpers ---
+export function childItemLinks(basePath, itemKey, collectionTitle, parentPath, parentTitle, schemaName, parentRel = "parent") {
+    return [
+        selfLink(`${basePath}/${itemKey}`),
+        {
+            rel: "collection",
+            href: `${API_PREFIX}${basePath}`,
+            title: collectionTitle,
+        },
+        {
+            rel: parentRel,
+            href: `${API_PREFIX}${parentPath}`,
+            title: parentTitle,
+        },
+        schemaLink(schemaName),
+    ];
+}
+// --- Declarative action resolver (wraps @naisys/common with ERP permission types) ---
+export { permGate };
+export function resolveActions(defs, baseHref, ctx) {
+    return resolveActionsBase(defs, baseHref, ctx, (perm) => hasPermission(ctx.user, perm));
+}
+export function draftCrudActions(href, updateSchemaName, revStatus, user) {
+    return resolveActions([
+        {
+            rel: "update",
+            method: "PUT",
+            title: "Update",
+            schema: `${API_PREFIX}/schemas/${updateSchemaName}`,
+            permission: "order_planner",
+            disabledWhen: (ctx) => ctx.status !== RevisionStatus.draft
+                ? "Can only edit in draft revisions"
+                : null,
+        },
+        {
+            rel: "delete",
+            method: "DELETE",
+            title: "Delete",
+            permission: "order_planner",
+            statuses: [RevisionStatus.draft],
+            hideWithoutPermission: true,
+        },
+    ], href, { status: revStatus, user });
+}
+// --- Status guards (return error message or null) ---
+export function checkOrderRunStarted(status) {
+    return status !== OrderRunStatus.started
+        ? `Order run is not started (status: ${status})`
+        : null;
+}
+export function checkOpRunInProgress(status) {
+    return status !== OperationRunStatus.in_progress
+        ? `Operation run is not in_progress (status: ${status})`
+        : null;
+}
+/**
+ * If the operation has a work center, check that the user is assigned to it.
+ * Returns an error message or null if access is allowed.
+ */
+export async function checkWorkCenterAccess(operationId, user) {
+    if (hasPermission(user, "erp_admin"))
+        return null;
+    const operation = await erpDb.operation.findUnique({
+        where: { id: operationId },
+        select: {
+            workCenter: {
+                select: {
+                    key: true,
+                    userAssignments: {
+                        where: { userId: user.id },
+                        select: { userId: true },
+                    },
+                },
+            },
+        },
+    });
+    if (!operation?.workCenter)
+        return null; // no work center = open to all
+    if (operation.workCenter.userAssignments.length > 0)
+        return null;
+    return `You are not assigned to work center '${operation.workCenter.key}'`;
+}
+// --- Resolution chains ---
+export async function resolveOrder(orderKey) {
+    return erpDb.order.findUnique({ where: { key: orderKey } });
+}
+export async function resolveRevision(orderKey, revNo) {
+    const order = await resolveOrder(orderKey);
+    if (!order)
+        return null;
+    const rev = await erpDb.orderRevision.findFirst({
+        where: { orderId: order.id, revNo },
+    });
+    if (!rev)
+        return null;
+    return { order, rev };
+}
+export async function resolveOperation(orderKey, revNo, opSeqNo) {
+    const result = await resolveRevision(orderKey, revNo);
+    if (!result)
+        return null;
+    const operation = await erpDb.operation.findFirst({
+        where: { orderRevId: result.rev.id, seqNo: opSeqNo },
+    });
+    if (!operation)
+        return null;
+    return { ...result, operation };
+}
+export async function resolveStep(orderKey, revNo, opSeqNo, stepSeqNo) {
+    const result = await resolveOperation(orderKey, revNo, opSeqNo);
+    if (!result)
+        return null;
+    const step = await erpDb.step.findFirst({
+        where: { operationId: result.operation.id, seqNo: stepSeqNo },
+    });
+    if (!step)
+        return null;
+    return { ...result, step };
+}
+export async function resolveOrderRun(orderKey, runNo) {
+    const order = await resolveOrder(orderKey);
+    if (!order)
+        return null;
+    const run = await erpDb.orderRun.findUnique({
+        where: { orderId_runNo: { orderId: order.id, runNo } },
+    });
+    if (!run)
+        return null;
+    return { order, run };
+}
+export async function resolveOpRun(orderKey, runNo, seqNo) {
+    const result = await resolveOrderRun(orderKey, runNo);
+    if (!result)
+        return null;
+    const operation = await erpDb.operation.findFirst({
+        where: { orderRevId: result.run.orderRevId, seqNo },
+    });
+    if (!operation)
+        return null;
+    const opRun = await erpDb.operationRun.findUnique({
+        where: {
+            orderRunId_operationId: {
+                orderRunId: result.run.id,
+                operationId: operation.id,
+            },
+        },
+    });
+    if (!opRun)
+        return null;
+    return { ...result, opRun };
+}
+export async function resolveStepRun(orderKey, runNo, seqNo, stepSeqNo) {
+    const result = await resolveOpRun(orderKey, runNo, seqNo);
+    if (!result)
+        return null;
+    const stepRun = await erpDb.stepRun.findFirst({
+        where: { operationRunId: result.opRun.id, step: { seqNo: stepSeqNo } },
+    });
+    if (!stepRun)
+        return null;
+    return { ...result, stepRun };
+}
+//# sourceMappingURL=route-helpers.js.map

package/dist/routes/admin.d.ts

@@ -0,0 +1,3 @@
+import type { FastifyInstance, FastifyPluginOptions } from "fastify";
+export default function adminRoutes(fastify: FastifyInstance, _options: FastifyPluginOptions): void;
+//# sourceMappingURL=admin.d.ts.map