jason/mrp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

inventory control

Browse Source
This commit is contained in:
jason
2026-03-15 14:00:12 -05:00
parent 16582d3cea
commit 1fcb0c5480
14 changed files with 986 additions and 205 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
server/src/modules/inventory/router.ts
View File

@@ -7,6 +7,8 @@ import { fail, ok } from "../../lib/http.js";
import { requirePermissions } from "../../lib/rbac.js";
import {
createInventoryItem,
createInventoryReservation,
createInventoryTransfer,
createInventoryTransaction,
createWarehouse,
getInventoryItemById,
@@ -67,6 +69,22 @@ const inventoryTransactionSchema = z.object({
notes: z.string(),
});
const inventoryTransferSchema = z.object({
quantity: z.number().int().positive(),
fromWarehouseId: z.string().trim().min(1),
fromLocationId: z.string().trim().min(1),
toWarehouseId: z.string().trim().min(1),
toLocationId: z.string().trim().min(1),
notes: z.string(),
});
const inventoryReservationSchema = z.object({
quantity: z.number().int().positive(),
warehouseId: z.string().trim().min(1).nullable(),
locationId: z.string().trim().min(1).nullable(),
notes: z.string(),
});
const warehouseLocationSchema = z.object({
code: z.string().trim().min(1).max(64),
name: z.string().trim().min(1).max(160),
@@ -176,6 +194,44 @@ inventoryRouter.post("/items/:itemId/transactions", requirePermissions([permissi
return ok(response, result.item, 201);
});
inventoryRouter.post("/items/:itemId/transfers", requirePermissions([permissions.inventoryWrite]), async (request, response) => {
const itemId = getRouteParam(request.params.itemId);
if (!itemId) {
return fail(response, 400, "INVALID_INPUT", "Inventory item id is invalid.");
}
const parsed = inventoryTransferSchema.safeParse(request.body);
if (!parsed.success) {
return fail(response, 400, "INVALID_INPUT", "Inventory transfer payload is invalid.");
}
const result = await createInventoryTransfer(itemId, parsed.data, request.authUser?.id);
if (!result.ok) {
return fail(response, 400, "INVALID_INPUT", result.reason);
}
return ok(response, result.item, 201);
});
inventoryRouter.post("/items/:itemId/reservations", requirePermissions([permissions.inventoryWrite]), async (request, response) => {
const itemId = getRouteParam(request.params.itemId);
if (!itemId) {
return fail(response, 400, "INVALID_INPUT", "Inventory item id is invalid.");
}
const parsed = inventoryReservationSchema.safeParse(request.body);
if (!parsed.success) {
return fail(response, 400, "INVALID_INPUT", "Inventory reservation payload is invalid.");
}
const result = await createInventoryReservation(itemId, parsed.data);
if (!result.ok) {
return fail(response, 400, "INVALID_INPUT", result.reason);
}
return ok(response, result.item, 201);
});
inventoryRouter.get("/warehouses", requirePermissions([permissions.inventoryRead]), async (_request, response) => {
return ok(response, await listWarehouses());
});

387
server/src/modules/inventory/service.ts
View File

@@ -4,7 +4,12 @@ import type {
InventoryItemDetailDto,
InventoryItemInput,
InventoryItemOperationDto,
InventoryReservationDto,
InventoryReservationInput,
InventoryReservationStatus,
InventoryStockBalanceDto,
InventoryTransferDto,
InventoryTransferInput,
WarehouseDetailDto,
WarehouseInput,
WarehouseLocationOptionDto,
@@ -67,6 +72,8 @@ type InventoryDetailRecord = {
bomLines: BomLineRecord[];
operations: OperationRecord[];
inventoryTransactions: InventoryTransactionRecord[];
reservations: InventoryReservationRecord[];
transfers: InventoryTransferRecord[];
};
type InventoryTransactionRecord = {
@@ -109,6 +116,61 @@ type WarehouseDetailRecord = {
locations: WarehouseLocationRecord[];
};
type InventoryReservationRecord = {
id: string;
quantity: number;
status: string;
sourceType: string;
sourceId: string | null;
notes: string;
createdAt: Date;
warehouse: {
id: string;
code: string;
name: string;
} | null;
location: {
id: string;
code: string;
name: string;
} | null;
workOrder: {
id: string;
workOrderNumber: string;
} | null;
};
type InventoryTransferRecord = {
id: string;
quantity: number;
notes: string;
createdAt: Date;
fromWarehouse: {
id: string;
code: string;
name: string;
};
fromLocation: {
id: string;
code: string;
name: string;
};
toWarehouse: {
id: string;
code: string;
name: string;
};
toLocation: {
id: string;
code: string;
name: string;
};
createdBy: {
firstName: string;
lastName: string;
} | null;
};
function mapBomLine(record: BomLineRecord): InventoryBomLineDto {
return {
id: record.id,
@@ -172,7 +234,48 @@ function mapInventoryTransaction(record: InventoryTransactionRecord): InventoryT
};
}
function buildStockBalances(transactions: InventoryTransactionRecord[]): InventoryStockBalanceDto[] {
function mapReservation(record: InventoryReservationRecord): InventoryReservationDto {
return {
id: record.id,
quantity: record.quantity,
status: record.status as InventoryReservationStatus,
sourceType: record.sourceType,
sourceId: record.sourceId,
sourceLabel: record.workOrder ? record.workOrder.workOrderNumber : null,
notes: record.notes,
createdAt: record.createdAt.toISOString(),
warehouseId: record.warehouse?.id ?? null,
warehouseCode: record.warehouse?.code ?? null,
warehouseName: record.warehouse?.name ?? null,
locationId: record.location?.id ?? null,
locationCode: record.location?.code ?? null,
locationName: record.location?.name ?? null,
};
}
function mapTransfer(record: InventoryTransferRecord): InventoryTransferDto {
return {
id: record.id,
quantity: record.quantity,
notes: record.notes,
createdAt: record.createdAt.toISOString(),
createdByName: record.createdBy ? `${record.createdBy.firstName} ${record.createdBy.lastName}`.trim() : "System",
fromWarehouseId: record.fromWarehouse.id,
fromWarehouseCode: record.fromWarehouse.code,
fromWarehouseName: record.fromWarehouse.name,
fromLocationId: record.fromLocation.id,
fromLocationCode: record.fromLocation.code,
fromLocationName: record.fromLocation.name,
toWarehouseId: record.toWarehouse.id,
toWarehouseCode: record.toWarehouse.code,
toWarehouseName: record.toWarehouse.name,
toLocationId: record.toLocation.id,
toLocationCode: record.toLocation.code,
toLocationName: record.toLocation.name,
};
}
function buildStockBalances(transactions: InventoryTransactionRecord[], reservations: InventoryReservationRecord[]): InventoryStockBalanceDto[] {
const grouped = new Map<string, InventoryStockBalanceDto>();
for (const transaction of transactions) {
@@ -194,11 +297,40 @@ function buildStockBalances(transactions: InventoryTransactionRecord[]): Invento
locationCode: transaction.location.code,
locationName: transaction.location.name,
quantityOnHand: signedQuantity,
quantityReserved: 0,
quantityAvailable: signedQuantity,
});
}
for (const reservation of reservations) {
if (!reservation.warehouse || !reservation.location || reservation.status !== "ACTIVE") {
continue;
}
const key = `${reservation.warehouse.id}:${reservation.location.id}`;
const current = grouped.get(key);
if (current) {
current.quantityReserved += reservation.quantity;
current.quantityAvailable = current.quantityOnHand - current.quantityReserved;
continue;
}
grouped.set(key, {
warehouseId: reservation.warehouse.id,
warehouseCode: reservation.warehouse.code,
warehouseName: reservation.warehouse.name,
locationId: reservation.location.id,
locationCode: reservation.location.code,
locationName: reservation.location.name,
quantityOnHand: 0,
quantityReserved: reservation.quantity,
quantityAvailable: -reservation.quantity,
});
}
return [...grouped.values()]
.filter((balance) => balance.quantityOnHand !== 0)
.filter((balance) => balance.quantityOnHand !== 0 || balance.quantityReserved !== 0)
.sort((left, right) =>
`${left.warehouseCode}-${left.locationCode}`.localeCompare(`${right.warehouseCode}-${right.locationCode}`)
);
@@ -235,7 +367,13 @@ function mapDetail(record: InventoryDetailRecord): InventoryItemDetailDto {
.slice()
.sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime())
.map(mapInventoryTransaction);
const stockBalances = buildStockBalances(record.inventoryTransactions);
const activeReservations = record.reservations.filter((reservation) => reservation.status === "ACTIVE");
const stockBalances = buildStockBalances(record.inventoryTransactions, activeReservations);
const reservedQuantity = activeReservations.reduce((sum, reservation) => sum + reservation.quantity, 0);
const transferHistory = record.transfers
.slice()
.sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime())
.map(mapTransfer);
return {
...mapSummary({
@@ -258,8 +396,12 @@ function mapDetail(record: InventoryDetailRecord): InventoryItemDetailDto {
bomLines: record.bomLines.slice().sort((a, b) => a.position - b.position).map(mapBomLine),
operations: record.operations.slice().sort((a, b) => a.position - b.position).map(mapOperation),
onHandQuantity: stockBalances.reduce((sum, balance) => sum + balance.quantityOnHand, 0),
reservedQuantity,
availableQuantity: stockBalances.reduce((sum, balance) => sum + balance.quantityAvailable, 0),
stockBalances,
recentTransactions,
transfers: transferHistory,
reservations: record.reservations.slice().sort((left, right) => right.createdAt.getTime() - left.createdAt.getTime()).map(mapReservation),
};
}
@@ -353,6 +495,24 @@ function normalizeWarehouseLocations(locations: WarehouseLocationInput[]) {
.filter((location) => location.code.length > 0 && location.name.length > 0);
}
async function getItemLocationOnHand(itemId: string, warehouseId: string, locationId: string) {
const transactions = await prisma.inventoryTransaction.findMany({
where: {
itemId,
warehouseId,
locationId,
},
select: {
transactionType: true,
quantity: true,
},
});
return transactions.reduce((total, transaction) => {
return total + (transaction.transactionType === "RECEIPT" || transaction.transactionType === "ADJUSTMENT_IN" ? transaction.quantity : -transaction.quantity);
}, 0);
}
async function validateBomLines(parentItemId: string | null, bomLines: InventoryBomLineInput[]) {
const normalized = normalizeBomLines(bomLines);
@@ -434,6 +594,22 @@ async function validateOperations(type: InventoryItemType, operations: Inventory
return { ok: true as const, operations: normalized };
}
async function getActiveReservedQuantity(itemId: string, warehouseId: string, locationId: string) {
const reservations = await prisma.inventoryReservation.findMany({
where: {
itemId,
warehouseId,
locationId,
status: "ACTIVE",
},
select: {
quantity: true,
},
});
return reservations.reduce((sum, reservation) => sum + reservation.quantity, 0);
}
export async function listInventoryItems(filters: InventoryListFilters = {}) {
const items = await prisma.inventoryItem.findMany({
where: buildWhereClause(filters),
@@ -529,6 +705,70 @@ export async function getInventoryItemById(itemId: string) {
},
orderBy: [{ createdAt: "desc" }],
},
reservations: {
include: {
warehouse: {
select: {
id: true,
code: true,
name: true,
},
},
location: {
select: {
id: true,
code: true,
name: true,
},
},
workOrder: {
select: {
id: true,
workOrderNumber: true,
},
},
},
orderBy: [{ createdAt: "desc" }],
},
transfers: {
include: {
fromWarehouse: {
select: {
id: true,
code: true,
name: true,
},
},
fromLocation: {
select: {
id: true,
code: true,
name: true,
},
},
toWarehouse: {
select: {
id: true,
code: true,
name: true,
},
},
toLocation: {
select: {
id: true,
code: true,
name: true,
},
},
createdBy: {
select: {
firstName: true,
lastName: true,
},
},
},
orderBy: [{ createdAt: "desc" }],
},
},
});
@@ -579,14 +819,13 @@ export async function createInventoryTransaction(itemId: string, payload: Invent
return { ok: false as const, reason: "Warehouse location is invalid for the selected warehouse." };
}
const detail = await getInventoryItemById(itemId);
if (!detail) {
return { ok: false as const, reason: "Inventory item was not found." };
}
const signedQuantity = getSignedQuantity(payload.transactionType, payload.quantity);
if (signedQuantity < 0 && detail.onHandQuantity + signedQuantity < 0) {
return { ok: false as const, reason: "Transaction would drive on-hand quantity below zero." };
if (signedQuantity < 0) {
const onHand = await getItemLocationOnHand(itemId, payload.warehouseId, payload.locationId);
const reserved = await getActiveReservedQuantity(itemId, payload.warehouseId, payload.locationId);
if (onHand - reserved + signedQuantity < 0) {
return { ok: false as const, reason: "Transaction would drive available quantity below zero at the selected location." };
}
}
await prisma.inventoryTransaction.create({
@@ -606,6 +845,134 @@ export async function createInventoryTransaction(itemId: string, payload: Invent
return nextDetail ? { ok: true as const, item: nextDetail } : { ok: false as const, reason: "Unable to load updated inventory item." };
}
export async function createInventoryTransfer(itemId: string, payload: InventoryTransferInput, createdById?: string | null) {
const item = await prisma.inventoryItem.findUnique({
where: { id: itemId },
select: { id: true },
});
if (!item) {
return { ok: false as const, reason: "Inventory item was not found." };
}
const [fromLocation, toLocation] = await Promise.all([
prisma.warehouseLocation.findUnique({
where: { id: payload.fromLocationId },
select: { id: true, warehouseId: true },
}),
prisma.warehouseLocation.findUnique({
where: { id: payload.toLocationId },
select: { id: true, warehouseId: true },
}),
]);
if (!fromLocation || fromLocation.warehouseId !== payload.fromWarehouseId) {
return { ok: false as const, reason: "Source location is invalid for the selected source warehouse." };
}
if (!toLocation || toLocation.warehouseId !== payload.toWarehouseId) {
return { ok: false as const, reason: "Destination location is invalid for the selected destination warehouse." };
}
const onHand = await getItemLocationOnHand(itemId, payload.fromWarehouseId, payload.fromLocationId);
const reserved = await getActiveReservedQuantity(itemId, payload.fromWarehouseId, payload.fromLocationId);
if (onHand - reserved < payload.quantity) {
return { ok: false as const, reason: "Transfer quantity exceeds available stock at the source location." };
}
await prisma.$transaction(async (tx) => {
await tx.inventoryTransfer.create({
data: {
itemId,
fromWarehouseId: payload.fromWarehouseId,
fromLocationId: payload.fromLocationId,
toWarehouseId: payload.toWarehouseId,
toLocationId: payload.toLocationId,
quantity: payload.quantity,
notes: payload.notes,
createdById: createdById ?? null,
},
});
await tx.inventoryTransaction.create({
data: {
itemId,
warehouseId: payload.fromWarehouseId,
locationId: payload.fromLocationId,
transactionType: "ISSUE",
quantity: payload.quantity,
reference: "Inventory transfer out",
notes: payload.notes,
createdById: createdById ?? null,
},
});
await tx.inventoryTransaction.create({
data: {
itemId,
warehouseId: payload.toWarehouseId,
locationId: payload.toLocationId,
transactionType: "RECEIPT",
quantity: payload.quantity,
reference: "Inventory transfer in",
notes: payload.notes,
createdById: createdById ?? null,
},
});
});
const nextDetail = await getInventoryItemById(itemId);
return nextDetail ? { ok: true as const, item: nextDetail } : { ok: false as const, reason: "Unable to load updated inventory item." };
}
export async function createInventoryReservation(itemId: string, payload: InventoryReservationInput) {
const item = await prisma.inventoryItem.findUnique({
where: { id: itemId },
select: { id: true },
});
if (!item) {
return { ok: false as const, reason: "Inventory item was not found." };
}
if ((payload.warehouseId && !payload.locationId) || (!payload.warehouseId && payload.locationId)) {
return { ok: false as const, reason: "Reservation warehouse and location must be provided together." };
}
if (payload.warehouseId && payload.locationId) {
const location = await prisma.warehouseLocation.findUnique({
where: { id: payload.locationId },
select: { warehouseId: true },
});
if (!location || location.warehouseId !== payload.warehouseId) {
return { ok: false as const, reason: "Reservation location is invalid for the selected warehouse." };
}
const onHand = await getItemLocationOnHand(itemId, payload.warehouseId, payload.locationId);
const reserved = await getActiveReservedQuantity(itemId, payload.warehouseId, payload.locationId);
if (onHand - reserved < payload.quantity) {
return { ok: false as const, reason: "Reservation quantity exceeds available stock at the selected location." };
}
}
await prisma.inventoryReservation.create({
data: {
itemId,
warehouseId: payload.warehouseId,
locationId: payload.locationId,
sourceType: "MANUAL",
sourceId: null,
quantity: payload.quantity,
status: "ACTIVE",
notes: payload.notes,
},
});
const nextDetail = await getInventoryItemById(itemId);
return nextDetail ? { ok: true as const, item: nextDetail } : { ok: false as const, reason: "Unable to load updated inventory item." };
}
export async function createInventoryItem(payload: InventoryItemInput) {
const validatedBom = await validateBomLines(null, payload.bomLines);
if (!validatedBom.ok) {

52
server/src/modules/manufacturing/service.ts
View File

@@ -366,6 +366,10 @@ function addMinutes(value: Date, minutes: number) {
return new Date(value.getTime() + minutes * 60 * 1000);
}
function shouldReserveForStatus(status: string) {
return status === "RELEASED" || status === "IN_PROGRESS" || status === "ON_HOLD";
}
function buildWorkOrderOperationPlan(
itemOperations: WorkOrderRecord["item"]["operations"],
quantity: number,
@@ -463,6 +467,46 @@ async function regenerateWorkOrderOperations(workOrderId: string) {
});
}
async function syncWorkOrderReservations(workOrderId: string) {
const workOrder = await getWorkOrderById(workOrderId);
if (!workOrder) {
return;
}
await prisma.inventoryReservation.deleteMany({
where: {
workOrderId,
sourceType: "WORK_ORDER",
},
});
if (!shouldReserveForStatus(workOrder.status)) {
return;
}
const reservations = workOrder.materialRequirements
.filter((requirement) => requirement.remainingQuantity > 0)
.map((requirement) => ({
itemId: requirement.componentItemId,
warehouseId: workOrder.warehouseId,
locationId: workOrder.locationId,
workOrderId,
sourceType: "WORK_ORDER",
sourceId: workOrderId,
quantity: requirement.remainingQuantity,
status: "ACTIVE",
notes: `${workOrder.workOrderNumber} component demand`,
}));
if (reservations.length === 0) {
return;
}
await prisma.inventoryReservation.createMany({
data: reservations,
});
}
async function nextWorkOrderNumber() {
const next = (await workOrderModel.count()) + 1;
return `WO-${String(next).padStart(5, "0")}`;
@@ -696,6 +740,7 @@ export async function createWorkOrder(payload: WorkOrderInput) {
});
await regenerateWorkOrderOperations(created.id);
await syncWorkOrderReservations(created.id);
const workOrder = await getWorkOrderById(created.id);
return workOrder ? { ok: true as const, workOrder } : { ok: false as const, reason: "Unable to load saved work order." };
@@ -738,6 +783,7 @@ export async function updateWorkOrder(workOrderId: string, payload: WorkOrderInp
});
await regenerateWorkOrderOperations(workOrderId);
await syncWorkOrderReservations(workOrderId);
const workOrder = await getWorkOrderById(workOrderId);
return workOrder ? { ok: true as const, workOrder } : { ok: false as const, reason: "Unable to load saved work order." };
@@ -773,6 +819,8 @@ export async function updateWorkOrderStatus(workOrderId: string, status: WorkOrd
},
});
await syncWorkOrderReservations(workOrderId);
const workOrder = await getWorkOrderById(workOrderId);
return workOrder ? { ok: true as const, workOrder } : { ok: false as const, reason: "Unable to load saved work order." };
}
@@ -859,6 +907,8 @@ export async function issueWorkOrderMaterial(workOrderId: string, payload: WorkO
});
});
await syncWorkOrderReservations(workOrderId);
const nextWorkOrder = await getWorkOrderById(workOrderId);
return nextWorkOrder ? { ok: true as const, workOrder: nextWorkOrder } : { ok: false as const, reason: "Unable to load updated work order." };
}
@@ -917,6 +967,8 @@ export async function recordWorkOrderCompletion(workOrderId: string, payload: Wo
});
});
await syncWorkOrderReservations(workOrderId);
const nextWorkOrder = await getWorkOrderById(workOrderId);
return nextWorkOrder ? { ok: true as const, workOrder: nextWorkOrder } : { ok: false as const, reason: "Unable to load updated work order." };
}