@tailor-platform/erp-kit 0.4.1 → 0.5.0

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

@@ -0,0 +1,131 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  StockMovementNotFoundError,
+  StockMovementNotDraftError,
+  EmptyMoveLinesError,
+  ItemNotFoundError,
+  ItemNotActiveError,
+  InvalidQuantityError,
+  SameSourceDestinationError,
+  StorageLocationNotFoundError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ConfirmStockMovementInput {
+  id: string;
+}
+
+export interface ItemManagementQueries {
+  getItem: (
+    db: unknown,
+    input: { id: string },
+    ctx: CommandContext,
+  ) => Promise<{ ok: true; value: { item: { id: string; status: string } | null } }>;
+}
+
+/**
+ * Function: confirmStockMovement
+ *
+ * Transitions a stock movement from DRAFT to CONFIRMED status.
+ * All move lines are revalidated before confirmation to ensure data integrity.
+ */
+export async function run(
+  db: Transaction,
+  input: ConfirmStockMovementInput,
+  ctx: CommandContext,
+  itemManagementQueries: ItemManagementQueries,
+) {
+  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. Must be DRAFT
+  if (movement.status !== "DRAFT") {
+    return err(new StockMovementNotDraftError(id));
+  }
+
+  // 3. Load and revalidate move lines
+  const lines = await db
+    .selectFrom("StockMoveLine")
+    .selectAll()
+    .where("stockMovementId", "=", id)
+    .execute();
+
+  if (lines.length === 0) {
+    return err(new EmptyMoveLinesError(id));
+  }
+
+  for (const line of lines) {
+    // Check item exists and is ACTIVE
+    const itemResult = await itemManagementQueries.getItem(db, { id: line.itemId }, ctx);
+    const item = itemResult.value.item;
+
+    if (!item) {
+      return err(new ItemNotFoundError(line.itemId));
+    }
+
+    if (item.status !== "ACTIVE") {
+      return err(new ItemNotActiveError(line.itemId));
+    }
+
+    // Quantity > 0
+    if (line.quantity <= 0) {
+      return err(new InvalidQuantityError(line.itemId));
+    }
+
+    // Source != destination
+    if (
+      line.sourceLocationId &&
+      line.destinationLocationId &&
+      line.sourceLocationId === line.destinationLocationId
+    ) {
+      return err(new SameSourceDestinationError(line.sourceLocationId));
+    }
+
+    // Validate locations exist
+    if (line.sourceLocationId) {
+      const sourceLoc = await db
+        .selectFrom("StorageLocation")
+        .selectAll()
+        .where("id", "=", line.sourceLocationId)
+        .executeTakeFirst();
+      if (!sourceLoc) {
+        return err(new StorageLocationNotFoundError(line.sourceLocationId));
+      }
+    }
+
+    if (line.destinationLocationId) {
+      const destLoc = await db
+        .selectFrom("StorageLocation")
+        .selectAll()
+        .where("id", "=", line.destinationLocationId)
+        .executeTakeFirst();
+      if (!destLoc) {
+        return err(new StorageLocationNotFoundError(line.destinationLocationId));
+      }
+    }
+  }
+
+  // 4. Update status to CONFIRMED
+  const confirmed = await db
+    .updateTable("StockMovement")
+    .set({
+      status: "CONFIRMED",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ movement: confirmed! });
+}

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

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

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

@@ -0,0 +1,298 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ItemNotFoundError,
+  StorageLocationNotFoundError,
+  ReasonCodeRequiredError,
+  ScrapQuantityMustBeNegativeError,
+  LotNotFoundError,
+  SerialNumberNotFoundError,
+} from "../lib/errors.generated";
+import { baseZone, baseDraftAdjustment } from "../testing/fixtures";
+import { run, type ItemManagementQueries } from "./createInventoryAdjustment";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("createInventoryAdjustment", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:createInventoryAdjustment"],
+  };
+
+  const mockGetItemFound: ItemManagementQueries = {
+    getItem: vi.fn().mockResolvedValue({ ok: true, value: { item: { id: "item-1" } } }),
+  };
+
+  const mockGetItemNotFound: ItemManagementQueries = {
+    getItem: vi.fn().mockResolvedValue({ ok: true, value: { item: null } }),
+  };
+
+  it("returns error when item not found", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(
+      db,
+      {
+        itemId: "nonexistent",
+        storageLocationId: "location-1",
+        quantityDelta: 5,
+        reasonCode: "correction",
+      },
+      ctx,
+      mockGetItemNotFound,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ItemNotFoundError);
+    }
+  });
+
+  it("returns error when location not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // location lookup fails
+
+    const result = await run(
+      db,
+      {
+        itemId: "item-1",
+        storageLocationId: "nonexistent",
+        quantityDelta: 5,
+        reasonCode: "correction",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StorageLocationNotFoundError);
+    }
+  });
+
+  it("returns error when reason code missing", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseZone); // location found
+
+    const result = await run(
+      db,
+      {
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: 5,
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ReasonCodeRequiredError);
+    }
+  });
+
+  it("returns error when SCRAP type with positive quantityDelta", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseZone); // location found
+
+    const result = await run(
+      db,
+      {
+        adjustmentType: "SCRAP",
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: 5,
+        reasonCode: "expired",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ScrapQuantityMustBeNegativeError);
+    }
+  });
+
+  it("creates CORRECTION adjustment with positive quantityDelta", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const created = { ...baseDraftAdjustment, adjustmentType: "CORRECTION", quantityDelta: 10 };
+    spies.select.mockReturnValueOnce(baseZone); // location found
+    spies.insert.mockReturnValue(created);
+
+    const result = await run(
+      db,
+      {
+        adjustmentType: "CORRECTION",
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: 10,
+        reasonCode: "receiving-error",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.adjustmentType).toBe("CORRECTION");
+      expect(result.value.adjustment.quantityDelta).toBe(10);
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates CORRECTION adjustment with negative quantityDelta", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const created = { ...baseDraftAdjustment, adjustmentType: "CORRECTION", quantityDelta: -5 };
+    spies.select.mockReturnValueOnce(baseZone); // location found
+    spies.insert.mockReturnValue(created);
+
+    const result = await run(
+      db,
+      {
+        adjustmentType: "CORRECTION",
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: -5,
+        reasonCode: "damage",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.quantityDelta).toBe(-5);
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates SCRAP adjustment with negative quantityDelta", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const created = { ...baseDraftAdjustment, adjustmentType: "SCRAP", quantityDelta: -3 };
+    spies.select.mockReturnValueOnce(baseZone); // location found
+    spies.insert.mockReturnValue(created);
+
+    const result = await run(
+      db,
+      {
+        adjustmentType: "SCRAP",
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: -3,
+        reasonCode: "expired",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.adjustmentType).toBe("SCRAP");
+      expect(result.value.adjustment.quantityDelta).toBe(-3);
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates adjustment linked to inventory count", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const created = { ...baseDraftAdjustment, inventoryCountId: "count-1" };
+    spies.select.mockReturnValueOnce(baseZone); // location found
+    spies.insert.mockReturnValue(created);
+
+    const result = await run(
+      db,
+      {
+        adjustmentType: "CORRECTION",
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: -2,
+        reasonCode: "count-variance",
+        inventoryCountId: "count-1",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.adjustment.inventoryCountId).toBe("count-1");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("defaults adjustmentType to CORRECTION when not specified", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const created = { ...baseDraftAdjustment, adjustmentType: "CORRECTION" };
+    spies.select.mockReturnValueOnce(baseZone); // location found
+    spies.insert.mockReturnValue(created);
+
+    const result = await run(
+      db,
+      {
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: 5,
+        reasonCode: "correction",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(true);
+    expect(spies.values).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ adjustmentType: "CORRECTION" }),
+    );
+  });
+
+  it("returns error when lot not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseZone) // location found
+      .mockReturnValueOnce(undefined); // lot not found
+
+    const result = await run(
+      db,
+      {
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: 5,
+        reasonCode: "correction",
+        lotId: "nonexistent-lot",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(LotNotFoundError);
+    }
+  });
+
+  it("returns error when serial number not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseZone) // location found
+      .mockReturnValueOnce(undefined); // serial not found
+
+    const result = await run(
+      db,
+      {
+        itemId: "item-1",
+        storageLocationId: "location-1",
+        quantityDelta: 5,
+        reasonCode: "correction",
+        serialNumberId: "nonexistent-serial",
+      },
+      ctx,
+      mockGetItemFound,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SerialNumberNotFoundError);
+    }
+  });
+});

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

@@ -0,0 +1,124 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ItemNotFoundError,
+  StorageLocationNotFoundError,
+  ReasonCodeRequiredError,
+  ScrapQuantityMustBeNegativeError,
+  LotNotFoundError,
+  SerialNumberNotFoundError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface ItemManagementQueries {
+  getItem: (
+    db: unknown,
+    input: { id: string },
+    ctx: CommandContext,
+  ) => Promise<{ ok: true; value: { item: { id: string } | null } }>;
+}
+
+export interface CreateInventoryAdjustmentInput {
+  adjustmentType?: "CORRECTION" | "SCRAP";
+  itemId: string;
+  storageLocationId: string;
+  quantityDelta: number;
+  reasonCode?: string;
+  inventoryCountId?: string;
+  lotId?: string;
+  serialNumberId?: string;
+}
+
+/**
+ * Function: createInventoryAdjustment
+ *
+ * Creates a new inventory adjustment record in DRAFT status.
+ * CORRECTION: Manual corrections to on-hand quantities (positive or negative).
+ * SCRAP: Controlled disposal of unusable stock (must be negative).
+ */
+export async function run(
+  db: Transaction,
+  input: CreateInventoryAdjustmentInput,
+  ctx: CommandContext,
+  itemManagementQueries: ItemManagementQueries,
+) {
+  const {
+    adjustmentType = "CORRECTION",
+    itemId,
+    storageLocationId,
+    quantityDelta,
+    reasonCode,
+    inventoryCountId,
+    lotId,
+    serialNumberId,
+  } = input;
+
+  // 1. Validate item exists
+  const itemResult = await itemManagementQueries.getItem(db, { id: itemId }, ctx);
+  if (!itemResult.value.item) {
+    return err(new ItemNotFoundError(itemId));
+  }
+
+  // 2. Validate storage location exists
+  const location = await db
+    .selectFrom("StorageLocation")
+    .selectAll()
+    .where("id", "=", storageLocationId)
+    .executeTakeFirst();
+
+  if (!location) {
+    return err(new StorageLocationNotFoundError(storageLocationId));
+  }
+
+  // 3. Validate reason code provided
+  if (!reasonCode) {
+    return err(new ReasonCodeRequiredError(itemId));
+  }
+
+  // 4. For SCRAP, quantityDelta must be negative
+  if (adjustmentType === "SCRAP" && quantityDelta >= 0) {
+    return err(new ScrapQuantityMustBeNegativeError(itemId));
+  }
+
+  // 5. Validate lot exists if provided
+  if (lotId) {
+    const lot = await db.selectFrom("Lot").selectAll().where("id", "=", lotId).executeTakeFirst();
+
+    if (!lot) {
+      return err(new LotNotFoundError(lotId));
+    }
+  }
+
+  // 6. Validate serial number exists if provided
+  if (serialNumberId) {
+    const serial = await db
+      .selectFrom("SerialNumber")
+      .selectAll()
+      .where("id", "=", serialNumberId)
+      .executeTakeFirst();
+
+    if (!serial) {
+      return err(new SerialNumberNotFoundError(serialNumberId));
+    }
+  }
+
+  // 7. Create adjustment in DRAFT status
+  const adjustment = await db
+    .insertInto("InventoryAdjustment")
+    .values({
+      adjustmentType,
+      itemId,
+      storageLocationId,
+      quantityDelta,
+      reasonCode,
+      status: "DRAFT",
+      inventoryCountId: inventoryCountId ?? null,
+      lotId: lotId ?? null,
+      serialNumberId: serialNumberId ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ adjustment: adjustment! });
+}

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

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