@tailor-platform/erp-kit 0.4.1 → 0.5.0

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

@@ -0,0 +1,77 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { StorageLocationNotFoundError, DuplicateLocationNameError } from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateStorageLocationInput {
+  id: string;
+  name?: string;
+  code?: string;
+  storageCondition?: string | null;
+  capacity?: number | null;
+}
+
+/**
+ * Function: updateStorageLocation
+ *
+ * Modifies the mutable fields of a storage location, including name, code,
+ * storageCondition, and capacity. warehouseId, parentId, and locationType
+ * are immutable after creation.
+ */
+export async function run(
+  db: Transaction,
+  input: UpdateStorageLocationInput,
+  _ctx: CommandContext,
+) {
+  const { id, name, code, storageCondition, capacity } = input;
+
+  // 1. Check storage location exists
+  const location = await db
+    .selectFrom("StorageLocation")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!location) {
+    return err(new StorageLocationNotFoundError(id));
+  }
+
+  // 2. If name or code changed, check uniqueness within warehouse
+  const nameChanged = name !== undefined && name !== location.name;
+  const codeChanged = code !== undefined && code !== location.code;
+
+  if (nameChanged || codeChanged) {
+    const checkName = name ?? location.name;
+    const checkCode = code ?? location.code;
+
+    const duplicate = await db
+      .selectFrom("StorageLocation")
+      .selectAll()
+      .where("warehouseId", "=", location.warehouseId)
+      .where("id", "!=", id)
+      .where((eb) => eb.or([eb("name", "=", checkName), eb("code", "=", checkCode)]))
+      .forUpdate()
+      .executeTakeFirst();
+
+    if (duplicate) {
+      return err(new DuplicateLocationNameError(checkName));
+    }
+  }
+
+  // 3. Build update set
+  const updates: Record<string, unknown> = { updatedAt: new Date() };
+  if (name !== undefined) updates.name = name;
+  if (code !== undefined) updates.code = code;
+  if (storageCondition !== undefined) updates.storageCondition = storageCondition;
+  if (capacity !== undefined) updates.capacity = capacity;
+
+  // 4. Update location
+  const updatedLocation = await db
+    .updateTable("StorageLocation")
+    .set(updates)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ storageLocation: updatedLocation });
+}

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

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

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

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ValuationPolicyNotFoundError,
+  StandardCostRateRequiredError,
+} from "../lib/errors.generated";
+import { baseFifoPolicy, baseAvcoPolicy, baseStandardCostPolicy } from "../testing/fixtures";
+import { run } from "./updateValuationPolicy";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateValuationPolicy", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:updateValuationPolicy"],
+  };
+
+  it("returns error when not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // policy lookup fails
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ValuationPolicyNotFoundError);
+    }
+  });
+
+  it("updates policy name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedPolicy = { ...baseFifoPolicy, name: "Renamed FIFO" };
+    spies.select.mockReturnValueOnce(baseFifoPolicy); // existing policy
+    spies.update.mockReturnValue(updatedPolicy);
+
+    const result = await run(db, { id: "policy-1", name: "Renamed FIFO" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.valuationPolicy.name).toBe("Renamed FIFO");
+      expect(result.value.revaluationEvent).toBe(false);
+    }
+  });
+
+  it("returns error when standard cost rate required", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // Changing from AVCO to STANDARD_COST without providing standardCostRate
+    spies.select.mockReturnValueOnce(baseAvcoPolicy); // existing policy (no standardCostRate)
+
+    const result = await run(db, { id: "policy-2", costingMethod: "STANDARD_COST" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StandardCostRateRequiredError);
+    }
+  });
+
+  it("updates standard cost rate and emits revaluation event", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedPolicy = { ...baseStandardCostPolicy, standardCostRate: 15.0 };
+    spies.select.mockReturnValueOnce(baseStandardCostPolicy); // existing policy
+    spies.update.mockReturnValue(updatedPolicy);
+
+    const result = await run(db, { id: "policy-3", standardCostRate: 15.0 }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.valuationPolicy.standardCostRate).toBe(15.0);
+      expect(result.value.revaluationEvent).toBe(true);
+    }
+  });
+});

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

@@ -0,0 +1,74 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  ValuationPolicyNotFoundError,
+  StandardCostRateRequiredError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateValuationPolicyInput {
+  id: string;
+  name?: string;
+  costingMethod?: string;
+  standardCostRate?: number | null;
+}
+
+/**
+ * Function: updateValuationPolicy
+ *
+ * Updates an existing valuation policy. When the standardCostRate is changed
+ * for a STANDARD_COST policy, a revaluation event is emitted.
+ */
+export async function run(
+  db: Transaction,
+  input: UpdateValuationPolicyInput,
+  _ctx: CommandContext,
+) {
+  const { id, name, costingMethod, standardCostRate } = input;
+
+  // 1. Fetch existing policy
+  const existing = await db
+    .selectFrom("ValuationPolicy")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!existing) {
+    return err(new ValuationPolicyNotFoundError(id));
+  }
+
+  // 2. Determine effective costing method after update
+  const effectiveCostingMethod = costingMethod ?? existing.costingMethod;
+
+  // 3. If STANDARD_COST, require standardCostRate
+  if (
+    effectiveCostingMethod === "STANDARD_COST" &&
+    standardCostRate == null &&
+    existing.standardCostRate == null
+  ) {
+    return err(new StandardCostRateRequiredError(id));
+  }
+
+  // 4. Update policy
+  const updated = await db
+    .updateTable("ValuationPolicy")
+    .set({
+      ...(name != null && { name }),
+      ...(costingMethod != null && {
+        costingMethod: costingMethod as "FIFO" | "AVCO" | "STANDARD_COST",
+      }),
+      ...(standardCostRate !== undefined && { standardCostRate }),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 5. Check if standard cost rate changed (emit revaluation event)
+  const revaluationEvent =
+    effectiveCostingMethod === "STANDARD_COST" &&
+    standardCostRate != null &&
+    existing.standardCostRate !== standardCostRate;
+
+  return ok({ valuationPolicy: updated!, revaluationEvent });
+}

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

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

package/src/modules/inventory/command/updateWarehouse.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 { WarehouseNotFoundError, DuplicateWarehouseNameError } from "../lib/errors.generated";
+import { baseActiveWarehouse } from "../testing/fixtures";
+import { run } from "./updateWarehouse";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateWarehouse", () => {
+  const ctx: CommandContext = { actorId: "test-actor", permissions: ["inventory:updateWarehouse"] };
+
+  it("returns error when warehouse 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(WarehouseNotFoundError);
+    }
+  });
+
+  it("returns error when new name conflicts", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseActiveWarehouse) // warehouse found
+      .mockReturnValueOnce({
+        ...baseActiveWarehouse,
+        id: "warehouse-other",
+        name: "Existing Name",
+      }); // duplicate found
+
+    const result = await run(db, { id: baseActiveWarehouse.id, name: "Existing Name" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateWarehouseNameError);
+    }
+  });
+
+  it("updates warehouse name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedWarehouse = { ...baseActiveWarehouse, name: "Renamed Warehouse" };
+    spies.select
+      .mockReturnValueOnce(baseActiveWarehouse) // warehouse found
+      .mockReturnValueOnce(undefined); // no duplicate
+    spies.update.mockReturnValue(updatedWarehouse);
+
+    const result = await run(db, { id: baseActiveWarehouse.id, name: "Renamed Warehouse" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.warehouse.name).toBe("Renamed Warehouse");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates storage condition", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedWarehouse = { ...baseActiveWarehouse, storageCondition: "cold" };
+    spies.select.mockReturnValueOnce(baseActiveWarehouse); // warehouse found
+    spies.update.mockReturnValue(updatedWarehouse);
+
+    const result = await run(db, { id: baseActiveWarehouse.id, storageCondition: "cold" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.warehouse.storageCondition).toBe("cold");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates capacity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedWarehouse = { ...baseActiveWarehouse, capacity: 5000 };
+    spies.select.mockReturnValueOnce(baseActiveWarehouse); // warehouse found
+    spies.update.mockReturnValue(updatedWarehouse);
+
+    const result = await run(db, { id: baseActiveWarehouse.id, capacity: 5000 }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.warehouse.capacity).toBe(5000);
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,64 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { WarehouseNotFoundError, DuplicateWarehouseNameError } from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface UpdateWarehouseInput {
+  id: string;
+  name?: string;
+  storageCondition?: string | null;
+  capacity?: number | null;
+}
+
+/**
+ * Function: updateWarehouse
+ *
+ * Modifies the mutable fields of an existing warehouse, including name,
+ * storageCondition, and capacity. The siteId is immutable after creation.
+ */
+export async function run(db: Transaction, input: UpdateWarehouseInput, _ctx: CommandContext) {
+  const { id, name, storageCondition, capacity } = input;
+
+  // 1. Check warehouse exists
+  const warehouse = await db
+    .selectFrom("Warehouse")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!warehouse) {
+    return err(new WarehouseNotFoundError(id));
+  }
+
+  // 2. If name is changing, check uniqueness within site
+  if (name !== undefined && name !== warehouse.name) {
+    const duplicate = await db
+      .selectFrom("Warehouse")
+      .selectAll()
+      .where("name", "=", name)
+      .where("siteId", "=", warehouse.siteId)
+      .where("id", "!=", id)
+      .forUpdate()
+      .executeTakeFirst();
+
+    if (duplicate) {
+      return err(new DuplicateWarehouseNameError(name));
+    }
+  }
+
+  // 3. Build update set
+  const updates: Record<string, unknown> = { updatedAt: new Date() };
+  if (name !== undefined) updates.name = name;
+  if (storageCondition !== undefined) updates.storageCondition = storageCondition;
+  if (capacity !== undefined) updates.capacity = capacity;
+
+  // 4. Update warehouse
+  const updatedWarehouse = await db
+    .updateTable("Warehouse")
+    .set(updates)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ warehouse: updatedWarehouse });
+}

package/src/modules/inventory/db/costLayer.ts

@@ -0,0 +1,54 @@
+import {
+  db,
+  type TailorAnyDBField,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { item as itemStub } from "../lib/_db_deps";
+import { valuationPolicy } from "./valuationPolicy";
+import { stockMovement } from "./stockMovement";
+
+export interface CreateCostLayerTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+}
+
+export function createCostLayerType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateCostLayerTypeParams<F>,
+) {
+  return db
+    .type("CostLayer", {
+      itemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: itemStub },
+          backward: "costLayers",
+        })
+        .description("Foreign key to Item"),
+      valuationPolicyId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: valuationPolicy },
+          backward: "costLayers",
+        })
+        .description("Foreign key to ValuationPolicy (FIFO)"),
+      stockMovementId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: stockMovement },
+          backward: "costLayers",
+        })
+        .description("Foreign key to the goods receipt StockMovement"),
+      quantity: db.float().description("Original quantity received in this layer"),
+      unitCost: db.float().description("Cost per unit for this layer"),
+      remainingQuantity: db.float().description("Unconsumed quantity remaining in this layer"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const costLayer = createCostLayerType({});

package/src/modules/inventory/db/inventoryAdjustment.ts

@@ -0,0 +1,88 @@
+import {
+  db,
+  type TailorAnyDBField,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { item as itemStub } from "../lib/_db_deps";
+import { storageLocation } from "./storageLocation";
+import { inventoryCount } from "./inventoryCount";
+import { lot } from "./lot";
+import { serialNumber } from "./serialNumber";
+
+export const ADJUSTMENT_TYPES = ["CORRECTION", "SCRAP"] as const;
+export const BASE_ADJUSTMENT_STATUSES = [
+  "DRAFT",
+  "PENDING_APPROVAL",
+  "APPROVED",
+  "REJECTED",
+  "CONFIRMED",
+] as const;
+
+export interface CreateInventoryAdjustmentTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+}
+
+export function createInventoryAdjustmentType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateInventoryAdjustmentTypeParams<F>,
+) {
+  return db
+    .type("InventoryAdjustment", {
+      adjustmentType: db
+        .enum([...ADJUSTMENT_TYPES] as [string, ...string[]])
+        .description("Adjustment type: CORRECTION or SCRAP"),
+      itemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: itemStub },
+          backward: "inventoryAdjustments",
+        })
+        .description("Foreign key to Item"),
+      storageLocationId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: storageLocation },
+          backward: "inventoryAdjustments",
+        })
+        .description("Foreign key to StorageLocation"),
+      quantityDelta: db
+        .float()
+        .description("Quantity change (positive for increase, negative for decrease)"),
+      reasonCode: db.string().description("Reason code for the adjustment"),
+      status: db
+        .enum([...BASE_ADJUSTMENT_STATUSES] as [string, ...string[]])
+        .description("Lifecycle status: DRAFT, PENDING_APPROVAL, APPROVED, REJECTED, CONFIRMED"),
+      inventoryCountId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: inventoryCount },
+          backward: "inventoryAdjustments",
+        })
+        .description("Optional link to originating inventory count"),
+      lotId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: lot },
+          backward: "inventoryAdjustments",
+        })
+        .description("Optional foreign key to Lot for lot-tracked items"),
+      serialNumberId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: serialNumber },
+          backward: "inventoryAdjustments",
+        })
+        .description("Optional foreign key to SerialNumber for serial-tracked items"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const inventoryAdjustment = createInventoryAdjustmentType({});

package/src/modules/inventory/db/inventoryCount.ts

@@ -0,0 +1,58 @@
+import {
+  db,
+  type TailorAnyDBField,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { warehouse } from "./warehouse";
+import { storageLocation } from "./storageLocation";
+
+export const COUNT_TYPES = ["FULL", "CYCLE"] as const;
+export const BASE_INVENTORY_COUNT_STATUSES = [
+  "PLANNED",
+  "IN_PROGRESS",
+  "COMPLETED",
+  "CANCELLED",
+] as const;
+
+export interface CreateInventoryCountTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+}
+
+export function createInventoryCountType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateInventoryCountTypeParams<F>,
+) {
+  return db
+    .type("InventoryCount", {
+      countType: db
+        .enum([...COUNT_TYPES] as [string, ...string[]])
+        .description("Count type: FULL (entire warehouse) or CYCLE (specific locations)"),
+      warehouseId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: warehouse },
+          backward: "inventoryCounts",
+        })
+        .description("Optional foreign key to Warehouse for full counts"),
+      storageLocationId: db
+        .uuid({ optional: true })
+        .relation({
+          type: "n-1",
+          toward: { type: storageLocation },
+          backward: "inventoryCounts",
+        })
+        .description("Optional foreign key to StorageLocation for cycle counts"),
+      plannedDate: db.datetime().description("Planned date for the count session"),
+      status: db
+        .enum([...BASE_INVENTORY_COUNT_STATUSES] as [string, ...string[]])
+        .description("Lifecycle status: PLANNED, IN_PROGRESS, COMPLETED, CANCELLED"),
+      isFrozen: db.bool().description("Whether stock movements are frozen for counted locations"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const inventoryCount = createInventoryCountType({});

package/src/modules/inventory/db/inventoryCountLine.ts

@@ -0,0 +1,61 @@
+import {
+  db,
+  type TailorAnyDBField,
+  unsafeAllowAllGqlPermission,
+  unsafeAllowAllTypePermission,
+} from "@tailor-platform/sdk";
+import { item as itemStub } from "../lib/_db_deps";
+import { inventoryCount } from "./inventoryCount";
+import { storageLocation } from "./storageLocation";
+
+export const BASE_COUNT_LINE_STATUSES = ["PENDING", "APPROVED", "REJECTED", "RECOUNT"] as const;
+
+export interface CreateInventoryCountLineTypeParams<F extends Record<string, TailorAnyDBField>> {
+  fields?: F;
+}
+
+export function createInventoryCountLineType<const F extends Record<string, TailorAnyDBField>>(
+  params: CreateInventoryCountLineTypeParams<F>,
+) {
+  return db
+    .type("InventoryCountLine", {
+      inventoryCountId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: inventoryCount },
+          backward: "countLines",
+        })
+        .description("Foreign key to InventoryCount"),
+      itemId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: itemStub },
+          backward: "inventoryCountLines",
+        })
+        .description("Foreign key to Item"),
+      storageLocationId: db
+        .uuid()
+        .relation({
+          type: "n-1",
+          toward: { type: storageLocation },
+          backward: "inventoryCountLines",
+        })
+        .description("Foreign key to StorageLocation"),
+      systemQuantity: db.float().description("System quantity snapshot at count start"),
+      countedQuantity: db.float({ optional: true }).description("Physically counted quantity"),
+      variance: db
+        .float({ optional: true })
+        .description("Computed variance: countedQuantity - systemQuantity"),
+      status: db
+        .enum([...BASE_COUNT_LINE_STATUSES] as [string, ...string[]])
+        .description("Review status: PENDING, APPROVED, REJECTED, RECOUNT"),
+      ...((params.fields ?? {}) as F),
+      ...db.fields.timestamps(),
+    })
+    .permission(unsafeAllowAllTypePermission)
+    .gqlPermission(unsafeAllowAllGqlPermission);
+}
+
+export const inventoryCountLine = createInventoryCountLineType({});