@tailor-platform/erp-kit 0.4.1 → 0.5.1

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

@@ -0,0 +1,246 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WarehouseNotFoundError,
+  WarehouseInactiveError,
+  InvalidLocationTypeError,
+  ParentZoneNotFoundError,
+  ParentNotAZoneError,
+  ParentInDifferentWarehouseError,
+  DuplicateLocationNameError,
+} from "../lib/errors.generated";
+import { baseActiveWarehouse, baseInactiveWarehouse, baseZone, baseBin } from "../testing/fixtures";
+import { run } from "./createStorageLocation";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("createStorageLocation", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:createStorageLocation"],
+  };
+
+  it("returns error when warehouse not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // warehouse not found
+
+    const result = await run(
+      db,
+      { name: "Zone A", code: "ZA", warehouseId: "nonexistent", locationType: "zone" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WarehouseNotFoundError);
+    }
+  });
+
+  it("returns error when warehouse inactive", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseInactiveWarehouse); // warehouse inactive
+
+    const result = await run(
+      db,
+      { name: "Zone A", code: "ZA", warehouseId: baseInactiveWarehouse.id, locationType: "zone" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(WarehouseInactiveError);
+    }
+  });
+
+  it("returns error when invalid location type", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWarehouse); // warehouse found
+
+    const result = await run(
+      db,
+      { name: "Area 1", code: "A1", warehouseId: baseActiveWarehouse.id, locationType: "shelf" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidLocationTypeError);
+    }
+  });
+
+  it("returns error when bin has no parent", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseActiveWarehouse); // warehouse found
+
+    const result = await run(
+      db,
+      { name: "Bin 1", code: "B1", warehouseId: baseActiveWarehouse.id, locationType: "bin" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentZoneNotFoundError);
+    }
+  });
+
+  it("returns error when bin parent is another bin", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseActiveWarehouse) // warehouse found
+      .mockReturnValueOnce(baseBin); // parent is a bin, not a zone
+
+    const result = await run(
+      db,
+      {
+        name: "Bin 2",
+        code: "B2",
+        warehouseId: baseActiveWarehouse.id,
+        locationType: "bin",
+        parentId: baseBin.id,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentNotAZoneError);
+    }
+  });
+
+  it("returns error when parent zone is in different warehouse", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const zoneInOtherWarehouse = { ...baseZone, warehouseId: "warehouse-other" };
+    spies.select
+      .mockReturnValueOnce(baseActiveWarehouse) // warehouse found
+      .mockReturnValueOnce(zoneInOtherWarehouse); // parent in different warehouse
+
+    const result = await run(
+      db,
+      {
+        name: "Bin 3",
+        code: "B3",
+        warehouseId: baseActiveWarehouse.id,
+        locationType: "bin",
+        parentId: zoneInOtherWarehouse.id,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentInDifferentWarehouseError);
+    }
+  });
+
+  it("returns error when location name already exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseActiveWarehouse) // warehouse found
+      .mockReturnValueOnce(baseZone); // duplicate name found
+
+    const result = await run(
+      db,
+      { name: "Zone A", code: "ZA-NEW", warehouseId: baseActiveWarehouse.id, locationType: "zone" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateLocationNameError);
+    }
+  });
+
+  it("creates zone with null parentId", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdZone = { ...baseZone, id: "new-zone-id", name: "Zone B", code: "ZB" };
+
+    spies.select
+      .mockReturnValueOnce(baseActiveWarehouse) // warehouse found
+      .mockReturnValueOnce(undefined); // no duplicate
+    spies.insert.mockReturnValue(createdZone);
+
+    const result = await run(
+      db,
+      { name: "Zone B", code: "ZB", warehouseId: baseActiveWarehouse.id, locationType: "zone" },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.storageLocation.locationType).toBe("zone");
+      expect(result.value.storageLocation.parentId).toBeNull();
+      expect(result.value.storageLocation.name).toBe("Zone B");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates bin with parent zone", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdBin = {
+      ...baseBin,
+      id: "new-bin-id",
+      name: "Bin A-2",
+      code: "BA2",
+      parentId: baseZone.id,
+    };
+
+    spies.select
+      .mockReturnValueOnce(baseActiveWarehouse) // warehouse found
+      .mockReturnValueOnce(baseZone) // parent zone found
+      .mockReturnValueOnce(undefined); // no duplicate
+    spies.insert.mockReturnValue(createdBin);
+
+    const result = await run(
+      db,
+      {
+        name: "Bin A-2",
+        code: "BA2",
+        warehouseId: baseActiveWarehouse.id,
+        locationType: "bin",
+        parentId: baseZone.id,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.storageLocation.locationType).toBe("bin");
+      expect(result.value.storageLocation.parentId).toBe(baseZone.id);
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates location with storage condition", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdZone = {
+      ...baseZone,
+      id: "new-zone-id",
+      name: "Cold Zone",
+      code: "CZ",
+      storageCondition: "cold",
+    };
+
+    spies.select
+      .mockReturnValueOnce(baseActiveWarehouse) // warehouse found
+      .mockReturnValueOnce(undefined); // no duplicate
+    spies.insert.mockReturnValue(createdZone);
+
+    const result = await run(
+      db,
+      {
+        name: "Cold Zone",
+        code: "CZ",
+        warehouseId: baseActiveWarehouse.id,
+        locationType: "zone",
+        storageCondition: "cold",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.storageLocation.storageCondition).toBe("cold");
+    }
+  });
+});

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

@@ -0,0 +1,126 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  WarehouseNotFoundError,
+  WarehouseInactiveError,
+  InvalidLocationTypeError,
+  ParentZoneNotFoundError,
+  ParentNotAZoneError,
+  ParentInDifferentWarehouseError,
+  DuplicateLocationNameError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export interface CreateStorageLocationInput {
+  name: string;
+  code: string;
+  warehouseId: string;
+  locationType: string;
+  parentId?: string | null;
+  storageCondition?: string | null;
+  capacity?: number | null;
+}
+
+/**
+ * Function: createStorageLocation
+ *
+ * Creates a new storage location (zone or bin) within a warehouse.
+ * Zones are top-level divisions; bins are subdivisions within a zone.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateStorageLocationInput & CF,
+  _ctx: CommandContext,
+) {
+  const {
+    name,
+    code,
+    warehouseId,
+    locationType,
+    parentId,
+    storageCondition,
+    capacity,
+    ...customFields
+  } = input;
+
+  // 1. Validate warehouse exists
+  const warehouse = await db
+    .selectFrom("Warehouse")
+    .selectAll()
+    .where("id", "=", warehouseId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!warehouse) {
+    return err(new WarehouseNotFoundError(warehouseId));
+  }
+
+  // 2. Validate warehouse is ACTIVE
+  if (warehouse.status !== "ACTIVE") {
+    return err(new WarehouseInactiveError(warehouseId));
+  }
+
+  // 3. Validate locationType
+  if (locationType !== "zone" && locationType !== "bin") {
+    return err(new InvalidLocationTypeError(locationType));
+  }
+
+  // 4. Validate hierarchy constraints
+  if (locationType === "bin") {
+    if (!parentId) {
+      return err(new ParentZoneNotFoundError(parentId ?? "null"));
+    }
+
+    const parent = await db
+      .selectFrom("StorageLocation")
+      .selectAll()
+      .where("id", "=", parentId)
+      .forUpdate()
+      .executeTakeFirst();
+
+    if (!parent) {
+      return err(new ParentZoneNotFoundError(parentId));
+    }
+
+    if (parent.locationType !== "zone") {
+      return err(new ParentNotAZoneError(parentId));
+    }
+
+    if (parent.warehouseId !== warehouseId) {
+      return err(new ParentInDifferentWarehouseError(parentId));
+    }
+  }
+
+  // 5. Validate name and code uniqueness within warehouse
+  const duplicateName = await db
+    .selectFrom("StorageLocation")
+    .selectAll()
+    .where("warehouseId", "=", warehouseId)
+    .where((eb) => eb.or([eb("name", "=", name), eb("code", "=", code)]))
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (duplicateName) {
+    return err(new DuplicateLocationNameError(name));
+  }
+
+  // 6. Create storage location
+  const storageLocation = await db
+    .insertInto("StorageLocation")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      name,
+      code,
+      warehouseId,
+      locationType,
+      parentId: locationType === "zone" ? null : (parentId ?? null),
+      storageCondition: storageCondition ?? null,
+      capacity: capacity ?? null,
+      status: "ACTIVE",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ storageLocation: storageLocation! });
+}

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

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

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

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidCostingMethodError, StandardCostRateRequiredError } from "../lib/errors.generated";
+import { baseFifoPolicy, baseAvcoPolicy, baseStandardCostPolicy } from "../testing/fixtures";
+import { run } from "./createValuationPolicy";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("createValuationPolicy", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:createValuationPolicy"],
+  };
+
+  it("returns error when invalid costing method", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { name: "Bad Policy", costingMethod: "LIFO" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidCostingMethodError);
+    }
+  });
+
+  it("returns error when standard cost without rate", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { name: "Std Policy", costingMethod: "STANDARD_COST" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(StandardCostRateRequiredError);
+    }
+  });
+
+  it("creates FIFO policy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.insert.mockReturnValue(baseFifoPolicy);
+
+    const result = await run(db, { name: "FIFO Policy", costingMethod: "FIFO" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.valuationPolicy.costingMethod).toBe("FIFO");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates AVCO policy", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.insert.mockReturnValue(baseAvcoPolicy);
+
+    const result = await run(db, { name: "AVCO Policy", costingMethod: "AVCO" }, ctx);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.valuationPolicy.costingMethod).toBe("AVCO");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates standard cost policy with rate", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.insert.mockReturnValue(baseStandardCostPolicy);
+
+    const result = await run(
+      db,
+      { name: "Standard Cost Policy", costingMethod: "STANDARD_COST", standardCostRate: 10.5 },
+      ctx,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.valuationPolicy.costingMethod).toBe("STANDARD_COST");
+      expect(result.value.valuationPolicy.standardCostRate).toBe(10.5);
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,52 @@
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidCostingMethodError, StandardCostRateRequiredError } from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+const VALID_COSTING_METHODS = ["FIFO", "AVCO", "STANDARD_COST"] as const;
+type CostingMethod = (typeof VALID_COSTING_METHODS)[number];
+
+export interface CreateValuationPolicyInput {
+  name: string;
+  costingMethod: string;
+  standardCostRate?: number | null;
+}
+
+/**
+ * Function: createValuationPolicy
+ *
+ * Creates a new valuation policy that defines the costing method used to
+ * calculate inventory value. Supported costing methods are FIFO, AVCO,
+ * and STANDARD_COST.
+ */
+export async function run(
+  db: Transaction,
+  input: CreateValuationPolicyInput,
+  _ctx: CommandContext,
+) {
+  const { name, costingMethod, standardCostRate } = input;
+
+  // 1. Validate costingMethod
+  if (!VALID_COSTING_METHODS.includes(costingMethod as CostingMethod)) {
+    return err(new InvalidCostingMethodError(costingMethod));
+  }
+
+  // 2. Require standardCostRate for STANDARD_COST
+  if (costingMethod === "STANDARD_COST" && standardCostRate == null) {
+    return err(new StandardCostRateRequiredError(costingMethod));
+  }
+
+  // 3. Create valuation policy
+  const policy = await db
+    .insertInto("ValuationPolicy")
+    .values({
+      name,
+      costingMethod: costingMethod as CostingMethod,
+      standardCostRate: standardCostRate ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ valuationPolicy: policy! });
+}

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

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

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

@@ -0,0 +1,143 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  SiteNotFoundError,
+  SiteInactiveError,
+  DuplicateWarehouseNameError,
+} from "../lib/errors.generated";
+import { baseActiveWarehouse } from "../testing/fixtures";
+import { run, type OrganizationQueries } from "./createWarehouse";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("createWarehouse", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["inventory:createWarehouse"],
+  };
+
+  const activeSite = { id: "site-1", name: "Main Site", status: "ACTIVE" };
+  const inactiveSite = { id: "site-2", name: "Closed Site", status: "INACTIVE" };
+
+  const makeQueries = (
+    site: { id: string; status: string; name: string } | null,
+  ): Pick<OrganizationQueries, "getSite"> => ({
+    getSite: () =>
+      Promise.resolve({
+        ok: true as const,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-explicit-any
+        value: { site: site as any },
+      }),
+  });
+
+  it("returns error when site not found", async () => {
+    const { db } = createMockDb<Transaction>();
+    const queries = makeQueries(null);
+
+    const result = await run(db, { name: "Warehouse A", siteId: "nonexistent" }, ctx, queries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SiteNotFoundError);
+    }
+  });
+
+  it("returns error when site is inactive", async () => {
+    const { db } = createMockDb<Transaction>();
+    const queries = makeQueries(inactiveSite);
+
+    const result = await run(db, { name: "Warehouse A", siteId: "site-2" }, ctx, queries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SiteInactiveError);
+    }
+  });
+
+  it("returns error when warehouse name already exists at site", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const queries = makeQueries(activeSite);
+    spies.select.mockReturnValueOnce(baseActiveWarehouse);
+
+    const result = await run(db, { name: "Main Warehouse", siteId: "site-1" }, ctx, queries);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateWarehouseNameError);
+    }
+  });
+
+  it("creates warehouse with ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const queries = makeQueries(activeSite);
+    const createdWarehouse = {
+      ...baseActiveWarehouse,
+      id: "new-warehouse-id",
+      name: "New Warehouse",
+    };
+
+    spies.select.mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValue(createdWarehouse);
+
+    const result = await run(db, { name: "New Warehouse", siteId: "site-1" }, ctx, queries);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.warehouse.status).toBe("ACTIVE");
+      expect(result.value.warehouse.name).toBe("New Warehouse");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("creates warehouse with optional storage condition", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const queries = makeQueries(activeSite);
+    const createdWarehouse = {
+      ...baseActiveWarehouse,
+      id: "new-warehouse-id",
+      name: "Cold Warehouse",
+      storageCondition: "cold",
+    };
+
+    spies.select.mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValue(createdWarehouse);
+
+    const result = await run(
+      db,
+      { name: "Cold Warehouse", siteId: "site-1", storageCondition: "cold" },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.warehouse.storageCondition).toBe("cold");
+    }
+  });
+
+  it("creates warehouse with optional capacity", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const queries = makeQueries(activeSite);
+    const createdWarehouse = {
+      ...baseActiveWarehouse,
+      id: "new-warehouse-id",
+      name: "Large Warehouse",
+      capacity: 10000,
+    };
+
+    spies.select.mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValue(createdWarehouse);
+
+    const result = await run(
+      db,
+      { name: "Large Warehouse", siteId: "site-1", capacity: 10000 },
+      ctx,
+      queries,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.warehouse.capacity).toBe(10000);
+    }
+  });
+});