@tailor-platform/erp-kit 0.4.1 → 0.5.0

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

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CountNotFoundError,
+  CountAlreadyCompletedError,
+  CountAlreadyCancelledError,
+} from "../lib/errors.generated";
+import { basePlannedCount, baseInProgressCount, baseCompletedCount } from "../testing/fixtures";
+import { run } from "./cancelInventoryCount";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("cancelInventoryCount", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:cancelInventoryCount"],
+  };
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { inventoryCountId: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountNotFoundError);
+    }
+  });
+
+  it("returns error when COMPLETED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCompletedCount);
+
+    const result = await run(db, { inventoryCountId: "count-3" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountAlreadyCompletedError);
+    }
+  });
+
+  it("returns error when already cancelled", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelledCount = { ...basePlannedCount, status: "CANCELLED" };
+    spies.select.mockReturnValueOnce(cancelledCount);
+
+    const result = await run(db, { inventoryCountId: "count-1" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountAlreadyCancelledError);
+    }
+  });
+
+  it("cancels PLANNED count", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelledCount = { ...basePlannedCount, status: "CANCELLED", isFrozen: false };
+
+    spies.select.mockReturnValueOnce(basePlannedCount);
+    spies.delete.mockReturnValue(undefined); // delete count lines
+    spies.update.mockReturnValue(cancelledCount);
+
+    const result = await run(db, { inventoryCountId: "count-1" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.inventoryCount.status).toBe("CANCELLED");
+    }
+  });
+
+  it("cancels IN_PROGRESS count", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelledCount = { ...baseInProgressCount, status: "CANCELLED", isFrozen: false };
+
+    spies.select.mockReturnValueOnce(baseInProgressCount);
+    spies.delete.mockReturnValue(undefined);
+    spies.update.mockReturnValue(cancelledCount);
+
+    const result = await run(db, { inventoryCountId: "count-2" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.inventoryCount.status).toBe("CANCELLED");
+    }
+  });
+
+  it("unfreezes stock movements when count had frozen them", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const frozenCount = { ...baseInProgressCount, isFrozen: true };
+    const cancelledCount = { ...frozenCount, status: "CANCELLED", isFrozen: false };
+
+    spies.select.mockReturnValueOnce(frozenCount);
+    spies.delete.mockReturnValue(undefined);
+    spies.update.mockReturnValue(cancelledCount);
+
+    const result = await run(db, { inventoryCountId: "count-2" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.inventoryCount.isFrozen).toBe(false);
+    }
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({ isFrozen: false, status: "CANCELLED" }),
+    );
+  });
+
+  it("discards count line data", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelledCount = { ...baseInProgressCount, status: "CANCELLED", isFrozen: false };
+
+    spies.select.mockReturnValueOnce(baseInProgressCount);
+    spies.delete.mockReturnValue(undefined);
+    spies.update.mockReturnValue(cancelledCount);
+
+    const result = await run(db, { inventoryCountId: "count-2" }, ctx);
+    expect(result.ok).toBe(true);
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,62 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CountNotFoundError,
+  CountAlreadyCompletedError,
+  CountAlreadyCancelledError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CancelInventoryCountInput {
+  inventoryCountId: string;
+}
+
+/**
+ * Function: cancelInventoryCount
+ *
+ * Cancels an inventory count in PLANNED or IN_PROGRESS status.
+ * Unfreezes stock if frozen and discards all count line data.
+ */
+export async function run(db: Transaction, input: CancelInventoryCountInput, _ctx: CommandContext) {
+  const { inventoryCountId } = 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 status
+  if (count.status === "COMPLETED") {
+    return err(new CountAlreadyCompletedError(inventoryCountId));
+  }
+
+  if (count.status === "CANCELLED") {
+    return err(new CountAlreadyCancelledError(inventoryCountId));
+  }
+
+  // 3. Delete all count lines
+  await db
+    .deleteFrom("InventoryCountLine")
+    .where("inventoryCountId", "=", inventoryCountId)
+    .execute();
+
+  // 4. Update status to CANCELLED and unfreeze
+  const updatedCount = await db
+    .updateTable("InventoryCount")
+    .set({
+      status: "CANCELLED",
+      isFrozen: false,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", inventoryCountId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ inventoryCount: updatedCount! });
+}

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

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

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

@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  StockMovementNotFoundError,
+  StockMovementAlreadyDoneError,
+  StockMovementAlreadyCancelledError,
+} from "../lib/errors.generated";
+import {
+  baseDraftMovement,
+  baseConfirmedMovement,
+  baseDoneMovement,
+  baseCancelledMovement,
+} from "../testing/fixtures";
+import { run } from "./cancelStockMovement";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("cancelStockMovement", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:cancelStockMovement"],
+  };
+
+  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(StockMovementNotFoundError);
+    }
+  });
+
+  it("returns error when DONE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseDoneMovement);
+
+    const result = await run(db, { id: baseDoneMovement.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StockMovementAlreadyDoneError);
+    }
+  });
+
+  it("returns error when already cancelled", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseCancelledMovement);
+
+    const result = await run(db, { id: baseCancelledMovement.id }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StockMovementAlreadyCancelledError);
+    }
+  });
+
+  it("cancels DRAFT movement", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelled = { ...baseDraftMovement, status: "CANCELLED", updatedAt: new Date() };
+    spies.select.mockReturnValueOnce(baseDraftMovement);
+    spies.update.mockReturnValue(cancelled);
+
+    const result = await run(db, { id: baseDraftMovement.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.movement.status).toBe("CANCELLED");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("cancels CONFIRMED movement", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelled = { ...baseConfirmedMovement, status: "CANCELLED", updatedAt: new Date() };
+    spies.select.mockReturnValueOnce(baseConfirmedMovement);
+    spies.update.mockReturnValue(cancelled);
+
+    const result = await run(db, { id: baseConfirmedMovement.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.movement.status).toBe("CANCELLED");
+    }
+  });
+
+  it("does not affect stock levels", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const cancelled = { ...baseDraftMovement, status: "CANCELLED", updatedAt: new Date() };
+    spies.select.mockReturnValueOnce(baseDraftMovement);
+    spies.update.mockReturnValue(cancelled);
+
+    const result = await run(db, { id: baseDraftMovement.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    // Only one update call (the movement status), no stock level updates
+    expect(spies.update).toHaveBeenCalledTimes(1);
+    expect(spies.insert).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,56 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  StockMovementNotFoundError,
+  StockMovementAlreadyDoneError,
+  StockMovementAlreadyCancelledError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CancelStockMovementInput {
+  id: string;
+}
+
+/**
+ * Function: cancelStockMovement
+ *
+ * Cancels a stock movement in DRAFT or CONFIRMED status.
+ * Movements already executed (DONE) cannot be cancelled.
+ */
+export async function run(db: Transaction, input: CancelStockMovementInput, _ctx: CommandContext) {
+  const { id } = input;
+
+  // 1. Check movement exists
+  const movement = await db
+    .selectFrom("StockMovement")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!movement) {
+    return err(new StockMovementNotFoundError(id));
+  }
+
+  // 2. Cannot cancel DONE
+  if (movement.status === "DONE") {
+    return err(new StockMovementAlreadyDoneError(id));
+  }
+
+  // 3. Cannot cancel already CANCELLED
+  if (movement.status === "CANCELLED") {
+    return err(new StockMovementAlreadyCancelledError(id));
+  }
+
+  // 4. Update status to CANCELLED
+  const cancelled = await db
+    .updateTable("StockMovement")
+    .set({
+      status: "CANCELLED",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ movement: cancelled! });
+}

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

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

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

@@ -0,0 +1,99 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CountNotFoundError,
+  CountNotInProgressError,
+  UnresolvedCountLinesError,
+} from "../lib/errors.generated";
+import {
+  baseInProgressCount,
+  basePlannedCount,
+  basePendingCountLine,
+  baseApprovedCountLine,
+} from "../testing/fixtures";
+import { run } from "./completeInventoryCount";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("completeInventoryCount", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:completeInventoryCount"],
+  };
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // count not found
+
+    const result = await run(db, { inventoryCountId: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountNotFoundError);
+    }
+  });
+
+  it("returns error when not in progress", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(basePlannedCount); // PLANNED status
+
+    const result = await run(db, { inventoryCountId: "count-1" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CountNotInProgressError);
+    }
+  });
+
+  it("returns error when unresolved lines exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseInProgressCount) // count lookup
+      .mockReturnValueOnce([basePendingCountLine, baseApprovedCountLine]); // lines: one PENDING
+
+    const result = await run(db, { inventoryCountId: "count-2" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnresolvedCountLinesError);
+    }
+  });
+
+  it("completes count", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const allResolvedLines = [
+      baseApprovedCountLine,
+      { ...basePendingCountLine, status: "REJECTED" },
+    ];
+    const completedCount = { ...baseInProgressCount, status: "COMPLETED", isFrozen: false };
+
+    spies.select
+      .mockReturnValueOnce(baseInProgressCount) // count lookup
+      .mockReturnValueOnce(allResolvedLines); // all lines resolved
+    spies.update.mockReturnValue(completedCount);
+
+    const result = await run(db, { inventoryCountId: "count-2" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.inventoryCount.status).toBe("COMPLETED");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("unfreezes stock after completion", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const frozenCount = { ...baseInProgressCount, isFrozen: true };
+    const completedCount = { ...frozenCount, status: "COMPLETED", isFrozen: false };
+
+    spies.select
+      .mockReturnValueOnce(frozenCount) // count lookup, isFrozen: true
+      .mockReturnValueOnce([baseApprovedCountLine]); // all lines resolved
+    spies.update.mockReturnValue(completedCount);
+
+    const result = await run(db, { inventoryCountId: "count-2" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.inventoryCount.isFrozen).toBe(false);
+    }
+    expect(spies.set).toHaveBeenCalledWith(
+      expect.objectContaining({ isFrozen: false, status: "COMPLETED" }),
+    );
+  });
+});

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

@@ -0,0 +1,70 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  CountNotFoundError,
+  CountNotInProgressError,
+  UnresolvedCountLinesError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CompleteInventoryCountInput {
+  inventoryCountId: string;
+}
+
+/**
+ * Function: completeInventoryCount
+ *
+ * Completes the inventory count, transitioning from IN_PROGRESS to COMPLETED.
+ * All count lines must be in a terminal status (APPROVED or REJECTED).
+ * Unfreezes stock if it was frozen during the count.
+ */
+export async function run(
+  db: Transaction,
+  input: CompleteInventoryCountInput,
+  _ctx: CommandContext,
+) {
+  const { inventoryCountId } = 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 status
+  if (count.status !== "IN_PROGRESS") {
+    return err(new CountNotInProgressError(inventoryCountId));
+  }
+
+  // 3. Check all lines are in terminal status
+  const lines = await db
+    .selectFrom("InventoryCountLine")
+    .selectAll()
+    .where("inventoryCountId", "=", inventoryCountId)
+    .execute();
+
+  const unresolvedLines = lines.filter((l) => l.status !== "APPROVED" && l.status !== "REJECTED");
+
+  if (unresolvedLines.length > 0) {
+    return err(new UnresolvedCountLinesError(inventoryCountId));
+  }
+
+  // 4. Update status to COMPLETED and unfreeze if frozen
+  const updatedCount = await db
+    .updateTable("InventoryCount")
+    .set({
+      status: "COMPLETED",
+      isFrozen: false,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", inventoryCountId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ inventoryCount: updatedCount! });
+}

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

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