@tailor-platform/erp-kit 0.4.1 → 0.5.0

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

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { LotNotFoundError, LotFullyConsumedError } from "../lib/errors.generated";
+import { baseActiveLot, baseFullyConsumedLot } from "../testing/fixtures";
+import { run } from "./updateLot";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateLot", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:updateLot"],
+  };
+
+  it("returns error when lot not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // lot lookup fails
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(LotNotFoundError);
+    }
+  });
+
+  it("returns error when lot is FULLY_CONSUMED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseFullyConsumedLot); // fully consumed lot
+
+    const result = await run(db, { id: "lot-2", expirationDate: new Date("2026-01-01") }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(LotFullyConsumedError);
+    }
+  });
+
+  it("updates expiration date", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const newExpiration = new Date("2026-06-01");
+    const updatedLot = { ...baseActiveLot, expirationDate: newExpiration };
+    spies.select.mockReturnValueOnce(baseActiveLot); // existing lot
+    spies.update.mockReturnValue(updatedLot);
+
+    const result = await run(db, { id: "lot-1", expirationDate: newExpiration }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.lot.expirationDate).toEqual(newExpiration);
+    }
+  });
+
+  it("updates supplier lot reference", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLot = { ...baseActiveLot, supplierLotReference: "NEW-SUP-REF" };
+    spies.select.mockReturnValueOnce(baseActiveLot); // existing lot
+    spies.update.mockReturnValue(updatedLot);
+
+    const result = await run(db, { id: "lot-1", supplierLotReference: "NEW-SUP-REF" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.lot.supplierLotReference).toBe("NEW-SUP-REF");
+    }
+  });
+
+  it("lot number cannot be changed", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLot = { ...baseActiveLot }; // lotNumber remains the same
+    spies.select.mockReturnValueOnce(baseActiveLot); // existing lot
+    spies.update.mockReturnValue(updatedLot);
+
+    // Pass a lotNumber in the input — it should be ignored since
+    // UpdateLotInput does not include lotNumber
+    const result = await run(
+      db,
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
+      { id: "lot-1", supplierLotReference: "test" } as any,
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.lot.lotNumber).toBe("LOT-001");
+    }
+    // Verify that the set call does not include lotNumber
+    expect(spies.set).toHaveBeenCalledWith(
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      expect.not.objectContaining({ lotNumber: expect.anything() }),
+    );
+  });
+});

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

@@ -0,0 +1,52 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { LotNotFoundError, LotFullyConsumedError } from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateLotInput {
+  id: string;
+  manufactureDate?: Date | null;
+  expirationDate?: Date | null;
+  supplierLotReference?: string | null;
+}
+
+/**
+ * Function: updateLot
+ *
+ * Updates the mutable fields of a lot record. The lotNumber is immutable
+ * after creation and cannot be changed. Cannot update a FULLY_CONSUMED lot.
+ */
+export async function run(db: Transaction, input: UpdateLotInput, _ctx: CommandContext) {
+  const { id, manufactureDate, expirationDate, supplierLotReference } = input;
+
+  // 1. Fetch existing lot
+  const existing = await db
+    .selectFrom("Lot")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new LotNotFoundError(id));
+  }
+
+  // 2. Check status
+  if (existing.status === "FULLY_CONSUMED") {
+    return err(new LotFullyConsumedError(id));
+  }
+
+  // 3. Update mutable fields
+  const updated = await db
+    .updateTable("Lot")
+    .set({
+      ...(manufactureDate !== undefined && { manufactureDate }),
+      ...(expirationDate !== undefined && { expirationDate }),
+      ...(supplierLotReference !== undefined && { supplierLotReference }),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ lot: updated! });
+}

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

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

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

@@ -0,0 +1,250 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  StockMovementNotFoundError,
+  StockMovementNotDraftError,
+  ItemNotActiveError,
+  InvalidQuantityError,
+  SameSourceDestinationError,
+  StorageLocationNotFoundError,
+} from "../lib/errors.generated";
+import { baseDraftMovement, baseConfirmedMovement, baseZone } from "../testing/fixtures";
+import { run } from "./updateStockMovement";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateStockMovement", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:updateStockMovement"],
+  };
+
+  const activeItem = { id: "item-1", status: "ACTIVE", isLotTracked: false };
+  const inactiveItem = { id: "item-2", status: "DRAFT", isLotTracked: false };
+
+  const makeGetItem = (items: Record<string, unknown>) => ({
+    getItem: vi.fn().mockImplementation((_db: unknown, input: { id: string }) => {
+      const item = items[input.id] ?? null;
+      return Promise.resolve({ ok: true, value: { item } });
+    }),
+  });
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // movement not found
+    const queries = makeGetItem({});
+
+    const result = await run(db, { id: "nonexistent" }, ctx, queries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StockMovementNotFoundError);
+    }
+  });
+
+  it("returns error when not in DRAFT", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseConfirmedMovement);
+    const queries = makeGetItem({});
+
+    const result = await run(db, { id: baseConfirmedMovement.id }, ctx, queries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StockMovementNotDraftError);
+    }
+  });
+
+  it("updates movement date", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseDraftMovement, reasonCode: "new-reason", updatedAt: new Date() };
+    spies.select.mockReturnValueOnce(baseDraftMovement);
+    spies.update.mockReturnValue(updated);
+    const queries = makeGetItem({});
+
+    const result = await run(
+      db,
+      { id: baseDraftMovement.id, reasonCode: "new-reason" },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.movement.reasonCode).toBe("new-reason");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("returns error when line item not active", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseDraftMovement, updatedAt: new Date() };
+    spies.select.mockReturnValueOnce(baseDraftMovement); // movement lookup
+    spies.update.mockReturnValue(updated);
+    const queries = makeGetItem({ "item-2": inactiveItem });
+
+    const result = await run(
+      db,
+      {
+        id: baseDraftMovement.id,
+        lines: [{ itemId: "item-2", quantity: 10, destinationLocationId: "location-1" }],
+      },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ItemNotActiveError);
+    }
+  });
+
+  it("returns error when line quantity is zero or negative", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseDraftMovement, updatedAt: new Date() };
+    spies.select.mockReturnValueOnce(baseDraftMovement); // movement lookup
+    spies.update.mockReturnValue(updated);
+    const queries = makeGetItem({ "item-1": activeItem });
+
+    const result = await run(
+      db,
+      {
+        id: baseDraftMovement.id,
+        lines: [{ itemId: "item-1", quantity: 0, destinationLocationId: "location-1" }],
+      },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidQuantityError);
+    }
+  });
+
+  it("returns error when source equals destination", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseDraftMovement, updatedAt: new Date() };
+    spies.select.mockReturnValueOnce(baseDraftMovement); // movement lookup
+    spies.update.mockReturnValue(updated);
+    const queries = makeGetItem({ "item-1": activeItem });
+
+    const result = await run(
+      db,
+      {
+        id: baseDraftMovement.id,
+        lines: [
+          {
+            itemId: "item-1",
+            quantity: 10,
+            sourceLocationId: "location-1",
+            destinationLocationId: "location-1",
+          },
+        ],
+      },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SameSourceDestinationError);
+    }
+  });
+
+  it("returns error when location not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseDraftMovement, updatedAt: new Date() };
+    spies.select
+      .mockReturnValueOnce(baseDraftMovement) // movement lookup
+      .mockReturnValueOnce(undefined); // destination location not found
+    spies.update.mockReturnValue(updated);
+    const queries = makeGetItem({ "item-1": activeItem });
+
+    const result = await run(
+      db,
+      {
+        id: baseDraftMovement.id,
+        lines: [{ itemId: "item-1", quantity: 10, destinationLocationId: "nonexistent" }],
+      },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StorageLocationNotFoundError);
+    }
+  });
+
+  it("adds new move line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseDraftMovement, updatedAt: new Date() };
+    spies.select
+      .mockReturnValueOnce(baseDraftMovement) // movement lookup
+      .mockReturnValueOnce(baseZone); // destination location lookup
+    spies.update.mockReturnValue(updated);
+    const queries = makeGetItem({ "item-1": activeItem });
+
+    const newLine = {
+      id: "line-new",
+      stockMovementId: baseDraftMovement.id,
+      itemId: "item-1",
+      quantity: 30,
+      sourceLocationId: null,
+      destinationLocationId: "location-1",
+      lotId: null,
+      serialNumberId: null,
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    spies.insert.mockReturnValueOnce(newLine);
+
+    const result = await run(
+      db,
+      {
+        id: baseDraftMovement.id,
+        lines: [{ itemId: "item-1", quantity: 30, destinationLocationId: "location-1" }],
+      },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+      const value = result.value as any;
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      expect(value.moveLines).toHaveLength(1);
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      expect(value.moveLines![0].quantity).toBe(30);
+    }
+  });
+
+  it("removes move line", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updated = { ...baseDraftMovement, updatedAt: new Date() };
+    spies.select.mockReturnValueOnce(baseDraftMovement);
+    spies.update.mockReturnValue(updated);
+    const queries = makeGetItem({});
+
+    // Provide empty lines array to replace all existing lines with none
+    const result = await run(
+      db,
+      {
+        id: baseDraftMovement.id,
+        lines: [],
+      },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+      const value = result.value as any;
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      expect(value.moveLines).toHaveLength(0);
+    }
+  });
+});

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

@@ -0,0 +1,164 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  StockMovementNotFoundError,
+  StockMovementNotDraftError,
+  ItemNotFoundError,
+  ItemNotActiveError,
+  InvalidQuantityError,
+  SameSourceDestinationError,
+  StorageLocationNotFoundError,
+  LotRequiredForTrackedItemError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateMoveLineInput {
+  itemId: string;
+  quantity: number;
+  sourceLocationId?: string | null;
+  destinationLocationId?: string | null;
+  lotId?: string | null;
+  serialNumberId?: string | null;
+}
+
+export interface UpdateStockMovementInput {
+  id: string;
+  reasonCode?: string | null;
+  lines?: UpdateMoveLineInput[];
+}
+
+export interface ItemManagementQueries {
+  getItem: (
+    db: unknown,
+    input: { id: string },
+    ctx: CommandContext,
+  ) => Promise<{
+    ok: true;
+    value: { item: { id: string; status: string; isLotTracked?: boolean } | null };
+  }>;
+}
+
+/**
+ * Function: updateStockMovement
+ *
+ * Updates a stock movement that is still in DRAFT status.
+ * Fields can be updated and move lines can be replaced.
+ * Same validation rules as creation apply to new lines.
+ */
+export async function run(
+  db: Transaction,
+  input: UpdateStockMovementInput,
+  ctx: CommandContext,
+  itemManagementQueries: ItemManagementQueries,
+) {
+  const { id, reasonCode, lines } = 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. Update movement fields
+  const updatedMovement = await db
+    .updateTable("StockMovement")
+    .set({
+      reasonCode: reasonCode !== undefined ? (reasonCode ?? null) : movement.reasonCode,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 4. If lines provided, validate then delete old lines and re-create
+  if (lines) {
+    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));
+      }
+
+      if (line.quantity <= 0) {
+        return err(new InvalidQuantityError(line.itemId));
+      }
+
+      if (
+        line.sourceLocationId &&
+        line.destinationLocationId &&
+        line.sourceLocationId === line.destinationLocationId
+      ) {
+        return err(new SameSourceDestinationError(line.sourceLocationId));
+      }
+
+      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));
+        }
+      }
+
+      // Lot-tracked item requires lotId
+      if (item.isLotTracked && !line.lotId) {
+        return err(new LotRequiredForTrackedItemError(line.itemId));
+      }
+    }
+
+    await db.deleteFrom("StockMoveLine").where("stockMovementId", "=", id).execute();
+
+    const newLines = [];
+    for (const line of lines) {
+      const moveLine = await db
+        .insertInto("StockMoveLine")
+        .values({
+          stockMovementId: id,
+          itemId: line.itemId,
+          quantity: line.quantity,
+          sourceLocationId: line.sourceLocationId ?? null,
+          destinationLocationId: line.destinationLocationId ?? null,
+          lotId: line.lotId ?? null,
+          serialNumberId: line.serialNumberId ?? null,
+          createdAt: new Date(),
+          updatedAt: null,
+        })
+        .returningAll()
+        .executeTakeFirst();
+      newLines.push(moveLine!);
+    }
+
+    return ok({ movement: updatedMovement!, moveLines: newLines });
+  }
+
+  return ok({ movement: updatedMovement! });
+}

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

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

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

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { StorageLocationNotFoundError, DuplicateLocationNameError } from "../lib/errors.generated";
+import { baseZone } from "../testing/fixtures";
+import { run } from "./updateStorageLocation";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateStorageLocation", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:updateStorageLocation"],
+  };
+
+  it("returns error when location not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { id: "nonexistent", name: "New Name" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StorageLocationNotFoundError);
+    }
+  });
+
+  it("returns error when new name conflicts", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseZone) // location found
+      .mockReturnValueOnce({ ...baseZone, id: "other-location", name: "Existing Zone" }); // duplicate found
+
+    const result = await run(db, { id: baseZone.id, name: "Existing Zone" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateLocationNameError);
+    }
+  });
+
+  it("updates location name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLocation = { ...baseZone, name: "Renamed Zone" };
+    spies.select
+      .mockReturnValueOnce(baseZone) // location found
+      .mockReturnValueOnce(undefined); // no duplicate
+    spies.update.mockReturnValue(updatedLocation);
+
+    const result = await run(db, { id: baseZone.id, name: "Renamed Zone" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.storageLocation.name).toBe("Renamed Zone");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates storage condition", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedLocation = { ...baseZone, storageCondition: "cold" };
+    spies.select.mockReturnValueOnce(baseZone); // location found
+    spies.update.mockReturnValue(updatedLocation);
+
+    const result = await run(db, { id: baseZone.id, storageCondition: "cold" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.storageLocation.storageCondition).toBe("cold");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+});