@tailor-platform/erp-kit 0.4.0 → 0.5.0

package/src/modules/inventory/command/recordCountLine.test.ts

@@ -0,0 +1,211 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CountNotFoundError,
+  CountNotInProgressError,
+  CountLineNotFoundError,
+  CountLineInvalidStatusError,
+} from "../lib/errors.generated";
+import {
+  baseInProgressCount,
+  basePlannedCount,
+  basePendingCountLine,
+  baseApprovedCountLine,
+} from "../testing/fixtures";
+import { run } from "./recordCountLine";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("recordCountLine", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:recordCountLine"],
+  };
+
+  it("returns error when count not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // count not found
+
+    const result = await run(
+      db,
+      {
+        inventoryCountId: "nonexistent",
+        countLineId: "count-line-1",
+        countedQuantity: 98,
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountNotFoundError);
+    }
+  });
+
+  it("returns error when count not in progress", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePlannedCount); // count is PLANNED
+
+    const result = await run(
+      db,
+      {
+        inventoryCountId: "count-1",
+        countLineId: "count-line-1",
+        countedQuantity: 98,
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountNotInProgressError);
+    }
+  });
+
+  it("returns error when line not pending", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseInProgressCount) // count lookup
+      .mockReturnValueOnce(baseApprovedCountLine); // line is APPROVED
+
+    const result = await run(
+      db,
+      {
+        inventoryCountId: "count-2",
+        countLineId: "count-line-2",
+        countedQuantity: 50,
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountLineInvalidStatusError);
+    }
+  });
+
+  it("returns error when count line not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseInProgressCount) // count lookup
+      .mockReturnValueOnce(undefined); // count line not found
+
+    const result = await run(
+      db,
+      {
+        inventoryCountId: "count-2",
+        countLineId: "nonexistent",
+        countedQuantity: 98,
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountLineNotFoundError);
+    }
+  });
+
+  it("records counted quantity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLine = {
+      ...basePendingCountLine,
+      countedQuantity: 95,
+      variance: -5,
+      status: "PENDING",
+    };
+
+    spies.select
+      .mockReturnValueOnce(baseInProgressCount) // count lookup
+      .mockReturnValueOnce(basePendingCountLine); // line lookup
+    spies.update.mockReturnValue(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        inventoryCountId: "count-2",
+        countLineId: "count-line-1",
+        countedQuantity: 95,
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.countLine.countedQuantity).toBe(95);
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("calculates variance correctly", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // systemQuantity is 100, countedQuantity is 105, variance should be 5
+    const updatedLine = {
+      ...basePendingCountLine,
+      countedQuantity: 105,
+      variance: 5,
+      status: "PENDING",
+    };
+
+    spies.select.mockReturnValueOnce(baseInProgressCount).mockReturnValueOnce(basePendingCountLine); // systemQuantity = 100
+    spies.update.mockReturnValue(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        inventoryCountId: "count-2",
+        countLineId: "count-line-1",
+        countedQuantity: 105,
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.countLine.variance).toBe(5);
+    }
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({ variance: 5, countedQuantity: 105 }),
+    );
+  });
+
+  it("allows recording for RECOUNT status lines", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const recountLine = { ...basePendingCountLine, status: "RECOUNT" };
+    const updatedLine = { ...recountLine, countedQuantity: 99, variance: -1, status: "PENDING" };
+
+    spies.select.mockReturnValueOnce(baseInProgressCount).mockReturnValueOnce(recountLine);
+    spies.update.mockReturnValue(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        inventoryCountId: "count-2",
+        countLineId: "count-line-1",
+        countedQuantity: 99,
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.countLine.status).toBe("PENDING");
+    }
+  });
+
+  it("allows recording for REJECTED status lines", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const rejectedLine = { ...basePendingCountLine, status: "REJECTED" };
+    const updatedLine = { ...rejectedLine, countedQuantity: 101, variance: 1, status: "PENDING" };
+
+    spies.select.mockReturnValueOnce(baseInProgressCount).mockReturnValueOnce(rejectedLine);
+    spies.update.mockReturnValue(updatedLine);
+
+    const result = await run(
+      db,
+      {
+        inventoryCountId: "count-2",
+        countLineId: "count-line-1",
+        countedQuantity: 101,
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.countLine.status).toBe("PENDING");
+    }
+  });
+});

package/src/modules/inventory/command/recordCountLine.ts

@@ -0,0 +1,81 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CountNotFoundError,
+  CountNotInProgressError,
+  CountLineNotFoundError,
+  CountLineInvalidStatusError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface RecordCountLineInput {
+  inventoryCountId: string;
+  countLineId: string;
+  countedQuantity: number;
+}
+
+/**
+ * Function: recordCountLine
+ *
+ * Records the physically counted quantity for a specific count line.
+ * Variance is automatically calculated as countedQuantity minus system snapshot quantity.
+ */
+export async function run(db: Transaction, input: RecordCountLineInput, _ctx: CommandContext) {
+  const { inventoryCountId, countLineId, countedQuantity } = input;
+
+  // 1. Fetch count
+  const count = await db
+    .selectFrom("InventoryCount")
+    .selectAll()
+    .where("id", "=", inventoryCountId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!count) {
+    return err(new CountNotFoundError(inventoryCountId));
+  }
+
+  // 2. Validate count is IN_PROGRESS
+  if (count.status !== "IN_PROGRESS") {
+    return err(new CountNotInProgressError(inventoryCountId));
+  }
+
+  // 3. Fetch count line
+  const countLine = await db
+    .selectFrom("InventoryCountLine")
+    .selectAll()
+    .where("id", "=", countLineId)
+    .where("inventoryCountId", "=", inventoryCountId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!countLine) {
+    return err(new CountLineNotFoundError(countLineId));
+  }
+
+  // 4. Validate line status
+  if (
+    countLine.status !== "PENDING" &&
+    countLine.status !== "RECOUNT" &&
+    countLine.status !== "REJECTED"
+  ) {
+    return err(new CountLineInvalidStatusError(countLineId));
+  }
+
+  // 5. Calculate variance
+  const variance = countedQuantity - countLine.systemQuantity;
+
+  // 6. Update count line
+  const updatedLine = await db
+    .updateTable("InventoryCountLine")
+    .set({
+      countedQuantity,
+      variance,
+      status: "PENDING",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", countLineId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ countLine: updatedLine! });
+}

package/src/modules/inventory/command/rejectCountLine.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./rejectCountLine";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const rejectCountLine = defineCommand(permissions.rejectCountLine, run);

package/src/modules/inventory/command/rejectCountLine.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CountLineNotFoundError, CountLineNotPendingError } from "../lib/errors.generated";
+import { basePendingCountLine, baseApprovedCountLine } from "../testing/fixtures";
+import { run } from "./rejectCountLine";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("rejectCountLine", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:rejectCountLine"],
+  };
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { countLineId: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountLineNotFoundError);
+    }
+  });
+
+  it("returns error when not pending", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseApprovedCountLine); // APPROVED
+
+    const result = await run(db, { countLineId: "count-line-2" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountLineNotPendingError);
+    }
+  });
+
+  it("rejects line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const rejectedLine = { ...basePendingCountLine, status: "REJECTED" };
+
+    spies.select.mockReturnValueOnce(basePendingCountLine);
+    spies.update.mockReturnValue(rejectedLine);
+
+    const result = await run(db, { countLineId: "count-line-1" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.countLine.status).toBe("REJECTED");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("sets line to RECOUNT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const recountLine = { ...basePendingCountLine, status: "RECOUNT" };
+
+    spies.select.mockReturnValueOnce(basePendingCountLine);
+    spies.update.mockReturnValue(recountLine);
+
+    const result = await run(db, { countLineId: "count-line-1", recount: true }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.countLine.status).toBe("RECOUNT");
+    }
+    expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ status: "RECOUNT" }));
+  });
+});

package/src/modules/inventory/command/rejectCountLine.ts

@@ -0,0 +1,50 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { CountLineNotFoundError, CountLineNotPendingError } from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface RejectCountLineInput {
+  countLineId: string;
+  recount?: boolean;
+}
+
+/**
+ * Function: rejectCountLine
+ *
+ * Rejects a count line, optionally requesting a recount.
+ * The line transitions to REJECTED (terminal) or RECOUNT (allows re-recording).
+ */
+export async function run(db: Transaction, input: RejectCountLineInput, _ctx: CommandContext) {
+  const { countLineId, recount = false } = input;
+
+  // 1. Fetch count line
+  const countLine = await db
+    .selectFrom("InventoryCountLine")
+    .selectAll()
+    .where("id", "=", countLineId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!countLine) {
+    return err(new CountLineNotFoundError(countLineId));
+  }
+
+  // 2. Validate status
+  if (countLine.status !== "PENDING") {
+    return err(new CountLineNotPendingError(countLineId));
+  }
+
+  // 3. Update status
+  const newStatus = recount ? "RECOUNT" : "REJECTED";
+
+  const updatedLine = await db
+    .updateTable("InventoryCountLine")
+    .set({
+      status: newStatus,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", countLineId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ countLine: updatedLine! });
+}

package/src/modules/inventory/command/rejectInventoryAdjustment.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./rejectInventoryAdjustment";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const rejectInventoryAdjustment = defineCommand(permissions.rejectInventoryAdjustment, run);

package/src/modules/inventory/command/rejectInventoryAdjustment.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AdjustmentNotFoundError,
+  AdjustmentNotPendingApprovalError,
+} from "../lib/errors.generated";
+import { basePendingApprovalAdjustment, baseDraftAdjustment } from "../testing/fixtures";
+import { run } from "./rejectInventoryAdjustment";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("rejectInventoryAdjustment", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:rejectInventoryAdjustment"],
+  };
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AdjustmentNotFoundError);
+    }
+  });
+
+  it("returns error when not pending", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDraftAdjustment);
+
+    const result = await run(db, { id: "adjustment-1" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AdjustmentNotPendingApprovalError);
+    }
+  });
+
+  it("rejects adjustment", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...basePendingApprovalAdjustment, status: "REJECTED" };
+    spies.select.mockReturnValueOnce(basePendingApprovalAdjustment);
+    spies.update.mockReturnValue(updated);
+
+    const result = await run(db, { id: "adjustment-2" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.status).toBe("REJECTED");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("rejected adjustment does not affect stock", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...basePendingApprovalAdjustment, status: "REJECTED" };
+    spies.select.mockReturnValueOnce(basePendingApprovalAdjustment);
+    spies.update.mockReturnValue(updated);
+
+    await run(db, { id: "adjustment-2" }, ctx);
+
+    // Only one update call (status change), no stock level or valuation updates
+    expect(spies.update).toHaveBeenCalledTimes(1);
+    expect(spies.insert).not.toHaveBeenCalled();
+  });
+});

package/src/modules/inventory/command/rejectInventoryAdjustment.ts

@@ -0,0 +1,50 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  AdjustmentNotFoundError,
+  AdjustmentNotPendingApprovalError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface RejectInventoryAdjustmentInput {
+  id: string;
+}
+
+/**
+ * Function: rejectInventoryAdjustment
+ *
+ * Rejects a pending inventory adjustment, transitioning it from PENDING_APPROVAL to REJECTED status.
+ */
+export async function run(
+  db: Transaction,
+  input: RejectInventoryAdjustmentInput,
+  _ctx: CommandContext,
+) {
+  const { id } = input;
+
+  // 1. Fetch adjustment
+  const adjustment = await db
+    .selectFrom("InventoryAdjustment")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!adjustment) {
+    return err(new AdjustmentNotFoundError(id));
+  }
+
+  // 2. Validate status is PENDING_APPROVAL
+  if (adjustment.status !== "PENDING_APPROVAL") {
+    return err(new AdjustmentNotPendingApprovalError(id));
+  }
+
+  // 3. Update status to REJECTED
+  const updated = await db
+    .updateTable("InventoryAdjustment")
+    .set({ status: "REJECTED", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ adjustment: updated! });
+}

package/src/modules/inventory/command/releaseReservation.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./releaseReservation";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const releaseReservation = defineCommand(permissions.releaseReservation, run);

package/src/modules/inventory/command/releaseReservation.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { StockLevelNotFoundError, InsufficientReservedStockError } from "../lib/errors.generated";
+import { baseStockLevel } from "../testing/fixtures";
+import { run } from "./releaseReservation";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("releaseReservation", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:releaseReservation"],
+  };
+
+  it("returns error when stock level not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // StockLevel lookup
+
+    const result = await run(
+      db,
+      { itemId: "item-1", storageLocationId: "location-1", quantity: 5 },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StockLevelNotFoundError);
+    }
+  });
+
+  it("returns error when release exceeds reserved", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // baseStockLevel: reserved=10
+    spies.select.mockReturnValueOnce(baseStockLevel); // StockLevel found
+
+    const result = await run(
+      db,
+      { itemId: "item-1", storageLocationId: "location-1", quantity: 15 },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InsufficientReservedStockError);
+    }
+  });
+
+  it("releases reservation successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // baseStockLevel: reserved=10
+    const updatedStockLevel = { ...baseStockLevel, reserved: 5, updatedAt: new Date() };
+
+    spies.select.mockReturnValueOnce(baseStockLevel); // StockLevel found
+    spies.update.mockReturnValue(updatedStockLevel);
+
+    const result = await run(
+      db,
+      { itemId: "item-1", storageLocationId: "location-1", quantity: 5 },
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.stockLevel.reserved).toBe(5);
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

package/src/modules/inventory/command/releaseReservation.ts

@@ -0,0 +1,50 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { StockLevelNotFoundError, InsufficientReservedStockError } from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ReleaseReservationInput {
+  itemId: string;
+  storageLocationId: string;
+  quantity: number;
+}
+
+/**
+ * Function: releaseReservation
+ *
+ * Releases a previously reserved quantity of stock, restoring it
+ * to available status. Used when a reservation is no longer needed.
+ */
+export async function run(db: Transaction, input: ReleaseReservationInput, _ctx: CommandContext) {
+  const { itemId, storageLocationId, quantity } = input;
+
+  // 1. Find stock level for item-location pair (forUpdate for write)
+  const stockLevel = await db
+    .selectFrom("StockLevel")
+    .selectAll()
+    .where("itemId", "=", itemId)
+    .where("storageLocationId", "=", storageLocationId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!stockLevel) {
+    return err(new StockLevelNotFoundError(`${itemId}:${storageLocationId}`));
+  }
+
+  // 2. Check reserved >= release amount
+  if (stockLevel.reserved < quantity) {
+    return err(new InsufficientReservedStockError(`${itemId}:${storageLocationId}`));
+  }
+
+  // 3. Decrement reserved quantity
+  const updatedStockLevel = await db
+    .updateTable("StockLevel")
+    .set({
+      reserved: stockLevel.reserved - quantity,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", stockLevel.id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ stockLevel: updatedStockLevel! });
+}

package/src/modules/inventory/command/reserveStock.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./reserveStock";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const reserveStock = defineCommand(permissions.reserveStock, run);