@tailor-platform/erp-kit 0.1.2 → 0.2.0

package/src/modules/item-management/command/reactivateItem.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import { InvalidStateTransitionError, ItemNotFoundError } from "../lib/errors.generated";
+import { baseActiveItem, baseDraftItem, baseInactiveItem } from "../testing/fixtures";
+import { run } from "./reactivateItem";
+
+describe("reactivateItem", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:reactivateItem"],
+  };
+
+  it("returns error when item does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ItemNotFoundError);
+    }
+  });
+
+  it("returns error when item is not INACTIVE", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveItem);
+
+    const result = await run(db, { id: baseActiveItem.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("returns error when item is DRAFT", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftItem);
+
+    const result = await run(db, { id: baseDraftItem.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("reactivates an INACTIVE item", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const reactivatedItem = { ...baseInactiveItem, status: "ACTIVE" };
+    spies.select.mockReturnValueOnce(baseInactiveItem);
+    spies.update.mockReturnValue(reactivatedItem);
+
+    const result = await run(db, { id: baseInactiveItem.id }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.status).toBe("ACTIVE");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("reactivates from custom status when from is overridden", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const reactivatedItem = { ...baseDraftItem, status: "ACTIVE" };
+    spies.select.mockReturnValueOnce(baseDraftItem);
+    spies.update.mockReturnValue(reactivatedItem);
+
+    const result = await run(db, { id: baseDraftItem.id, from: ["INACTIVE", "DRAFT"] }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.status).toBe("ACTIVE");
+    }
+  });
+});

package/src/modules/item-management/command/reactivateItem.ts

@@ -0,0 +1,42 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import { InvalidStateTransitionError, ItemNotFoundError } from "../lib/errors.generated";
+import { getItem } from "../query/getItem.generated";
+
+export interface ReactivateItemInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: reactivateItem
+ *
+ * Transitions an item from INACTIVE back to ACTIVE status,
+ * restoring a previously discontinued SKU for transactions.
+ */
+export async function run(db: DB, input: ReactivateItemInput, ctx: CommandContext) {
+  const { id, from } = input;
+
+  // 1. Check item exists
+  const { item } = await getItem(db, { id }, ctx);
+
+  if (!item) {
+    return err(new ItemNotFoundError(id));
+  }
+
+  // 2. Check status is valid for reactivation
+  const validFromStatuses = from ?? ["INACTIVE"];
+  if (!validFromStatuses.includes(item.status)) {
+    return err(new InvalidStateTransitionError(`${item.status} to ACTIVE`));
+  }
+
+  // 3. Update status to ACTIVE
+  const reactivatedItem = await db
+    .updateTable("Item")
+    .set({ status: "ACTIVE", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ item: reactivatedItem! });
+}

package/src/modules/item-management/command/removeItemFromTaxonomy.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./removeItemFromTaxonomy";
+
+export const removeItemFromTaxonomy = defineCommand(permissions.removeItemFromTaxonomy, run);

package/src/modules/item-management/command/removeItemFromTaxonomy.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import { AssignmentNotFoundError } from "../lib/errors.generated";
+import { baseAssignment } from "../testing/fixtures";
+import { run } from "./removeItemFromTaxonomy";
+
+describe("removeItemFromTaxonomy", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:removeItemFromTaxonomy"],
+  };
+
+  it("returns error when assignment does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { itemId: "item-99", taxonomyNodeId: "node-99" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AssignmentNotFoundError);
+    }
+  });
+
+  it("removes assignment successfully", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseAssignment);
+    spies.delete.mockReturnValue(undefined);
+
+    const result = await run(
+      db,
+      { itemId: baseAssignment.itemId, taxonomyNodeId: baseAssignment.taxonomyNodeId },
+      ctx,
+    );
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.success).toBe(true);
+    }
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

package/src/modules/item-management/command/removeItemFromTaxonomy.ts

@@ -0,0 +1,30 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import { AssignmentNotFoundError } from "../lib/errors.generated";
+import { getItemTaxonomyAssignment } from "../query/getItemTaxonomyAssignment.generated";
+
+export interface RemoveItemFromTaxonomyInput {
+  itemId: string;
+  taxonomyNodeId: string;
+}
+
+/**
+ * Function: removeItemFromTaxonomy
+ *
+ * Removes the link between an item and a taxonomy node.
+ */
+export async function run(db: DB, input: RemoveItemFromTaxonomyInput, ctx: CommandContext) {
+  const { itemId, taxonomyNodeId } = input;
+
+  // 1. Check assignment exists
+  const { assignment } = await getItemTaxonomyAssignment(db, { itemId, taxonomyNodeId }, ctx);
+
+  if (!assignment) {
+    return err(new AssignmentNotFoundError(`${itemId} in ${taxonomyNodeId}`));
+  }
+
+  // 2. Delete assignment
+  await db.deleteFrom("ItemTaxonomyAssignment").where("id", "=", assignment.id).execute();
+
+  return ok({ success: true as const });
+}

package/src/modules/item-management/command/updateItem.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./updateItem";
+
+export const updateItem = defineCommand(permissions.updateItem, run);

package/src/modules/item-management/command/updateItem.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  DuplicateBarcodeError,
+  UnitNotFoundError,
+  ItemNotFoundError,
+  NoFieldsToUpdateError,
+  SkuImmutableError,
+  UomLockedError,
+} from "../lib/errors.generated";
+import { baseActiveItem, baseDraftItem, baseInactiveItem } from "../testing/fixtures";
+import { getUnit } from "../../primitives";
+import { run } from "./updateItem";
+
+describe("updateItem", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:updateItem"],
+  };
+
+  it("returns error when item does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent", name: "New Name" }, ctx, { getUnit });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ItemNotFoundError);
+    }
+  });
+
+  it("returns error when attempting to change SKU", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftItem);
+
+    const result = await run(db, { id: baseDraftItem.id, sku: "NEW-SKU" }, ctx, { getUnit });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SkuImmutableError);
+    }
+  });
+
+  it("returns error when no fields to update", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseDraftItem);
+
+    const result = await run(db, { id: baseDraftItem.id }, ctx, { getUnit });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NoFieldsToUpdateError);
+    }
+  });
+
+  it("returns error when barcode is duplicate", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseDraftItem) // Item lookup
+      .mockReturnValueOnce(baseActiveItem); // Barcode already taken
+
+    const result = await run(db, { id: baseDraftItem.id, barcode: "BAR-002" }, ctx, { getUnit });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateBarcodeError);
+    }
+  });
+
+  it("returns error when changing UoM on non-DRAFT item", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseActiveItem);
+
+    const result = await run(db, { id: baseActiveItem.id, unitId: "unit-g" }, ctx, { getUnit });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UomLockedError);
+    }
+  });
+
+  it("returns error when changing UoM on INACTIVE item", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseInactiveItem);
+
+    const result = await run(db, { id: baseInactiveItem.id, unitId: "unit-g" }, ctx, { getUnit });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UomLockedError);
+    }
+  });
+
+  it("returns error when new UoM does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseDraftItem) // Item lookup
+      .mockReturnValueOnce(undefined); // UoM not found
+
+    const result = await run(db, { id: baseDraftItem.id, unitId: "nonexistent-unit" }, ctx, {
+      getUnit,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnitNotFoundError);
+    }
+  });
+
+  it("updates name in any status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const updatedItem = { ...baseActiveItem, name: "Updated Name" };
+    spies.select.mockReturnValueOnce(baseActiveItem);
+    spies.update.mockReturnValue(updatedItem);
+
+    const result = await run(db, { id: baseActiveItem.id, name: "Updated Name" }, ctx, { getUnit });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.name).toBe("Updated Name");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates barcode in any status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const updatedItem = { ...baseActiveItem, barcode: "NEW-BAR" };
+    spies.select
+      .mockReturnValueOnce(baseActiveItem) // Item lookup
+      .mockReturnValueOnce(undefined); // Barcode unique
+    spies.update.mockReturnValue(updatedItem);
+
+    const result = await run(db, { id: baseActiveItem.id, barcode: "NEW-BAR" }, ctx, { getUnit });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.barcode).toBe("NEW-BAR");
+    }
+  });
+
+  it("clears barcode by setting to null", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const updatedItem = { ...baseActiveItem, barcode: null };
+    spies.select.mockReturnValueOnce(baseActiveItem);
+    spies.update.mockReturnValue(updatedItem);
+
+    const result = await run(db, { id: baseActiveItem.id, barcode: null }, ctx, { getUnit });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.barcode).toBeNull();
+    }
+  });
+
+  it("updates UoM in DRAFT status", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const activeUnit = { id: "unit-g", isActive: true };
+    const updatedItem = { ...baseDraftItem, unitId: "unit-g" };
+    spies.select
+      .mockReturnValueOnce(baseDraftItem) // Item lookup
+      .mockReturnValueOnce(activeUnit); // UoM valid
+    spies.update.mockReturnValue(updatedItem);
+
+    const result = await run(db, { id: baseDraftItem.id, unitId: "unit-g" }, ctx, { getUnit });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.item.unitId).toBe("unit-g");
+    }
+  });
+
+  it("passes custom fields through to set", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const updatedItem = { ...baseDraftItem, priority: 10 };
+    spies.select.mockReturnValueOnce(baseDraftItem);
+    spies.update.mockReturnValue(updatedItem);
+
+    await run(db, { id: baseDraftItem.id, priority: 10 }, ctx, { getUnit });
+
+    expect(spies.set).toHaveBeenNthCalledWith(1, expect.objectContaining({ priority: 10 }));
+  });
+});

package/src/modules/item-management/command/updateItem.ts

@@ -0,0 +1,103 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  DuplicateBarcodeError,
+  UnitNotFoundError,
+  ItemNotFoundError,
+  NoFieldsToUpdateError,
+  SkuImmutableError,
+  UomLockedError,
+} from "../lib/errors.generated";
+import { getItem } from "../query/getItem.generated";
+import { type PrimitivesQueries } from "../module";
+
+export interface UpdateItemInput {
+  id: string;
+  sku?: string;
+  name?: string;
+  barcode?: string | null;
+  unitId?: string;
+}
+
+/**
+ * Function: updateItem
+ *
+ * Updates mutable fields of an existing item. SKU is immutable.
+ * UoM can only be changed in DRAFT status.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: DB,
+  input: UpdateItemInput & Partial<CF>,
+  ctx: CommandContext,
+  primitivesQueries?: Pick<PrimitivesQueries, "getUnit">,
+) {
+  const { id, sku, name, barcode, unitId, ...customFields } = input;
+
+  // 1. Check item exists
+  const { item } = await getItem(db, { id }, ctx);
+
+  if (!item) {
+    return err(new ItemNotFoundError(id));
+  }
+
+  // 2. SKU is immutable
+  if (sku !== undefined) {
+    return err(new SkuImmutableError(id));
+  }
+
+  // 3. Check at least one field provided
+  const hasName = name !== undefined;
+  const hasBarcode = barcode !== undefined;
+  const hasUnitId = unitId !== undefined;
+  const hasCustomFields = Object.keys(customFields).length > 0;
+
+  if (!hasName && !hasBarcode && !hasUnitId && !hasCustomFields) {
+    return err(new NoFieldsToUpdateError(id));
+  }
+
+  // 4. Check barcode uniqueness when provided (non-null)
+  if (hasBarcode && barcode !== null) {
+    const existingBarcode = await db
+      .selectFrom("Item")
+      .selectAll()
+      .where("barcode", "=", barcode)
+      .where("id", "!=", id)
+      .executeTakeFirst();
+
+    if (existingBarcode) {
+      return err(new DuplicateBarcodeError(barcode));
+    }
+  }
+
+  // 5. UoM can only be changed in DRAFT status
+  if (hasUnitId) {
+    if (item.status !== "DRAFT") {
+      return err(new UomLockedError(id));
+    }
+
+    // Validate UoM exists and is active
+    const { unit } = await primitivesQueries!.getUnit(db, { id: unitId }, ctx);
+
+    if (!unit?.isActive) {
+      return err(new UnitNotFoundError(unitId));
+    }
+  }
+
+  // 6. Apply updates
+  const updates: Record<string, unknown> = {
+    ...(customFields as Record<string, unknown>),
+    updatedAt: new Date(),
+  };
+  if (hasName) updates.name = name;
+  if (hasBarcode) updates.barcode = barcode;
+  if (hasUnitId) updates.unitId = unitId;
+
+  const updatedItem = await db
+    .updateTable("Item")
+    .set(updates)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ item: updatedItem });
+}

package/src/modules/item-management/command/updateTaxonomyNode.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./updateTaxonomyNode";
+
+export const updateTaxonomyNode = defineCommand(permissions.updateTaxonomyNode, run);

package/src/modules/item-management/command/updateTaxonomyNode.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  CodeImmutableError,
+  MissingRequiredFieldsError,
+  NodeNotFoundError,
+} from "../lib/errors.generated";
+import { baseRootNode } from "../testing/fixtures";
+import { run } from "./updateTaxonomyNode";
+
+describe("updateTaxonomyNode", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:updateTaxonomyNode"],
+  };
+
+  it("returns error when node does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent", name: "New Name" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NodeNotFoundError);
+    }
+  });
+
+  it("returns error when attempting to change code", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseRootNode);
+
+    const result = await run(db, { id: baseRootNode.id, code: "NEW-CODE" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CodeImmutableError);
+    }
+  });
+
+  it("returns error when name is empty", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseRootNode);
+
+    const result = await run(db, { id: baseRootNode.id, name: "" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("returns error when name is not provided", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseRootNode);
+
+    const result = await run(db, { id: baseRootNode.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldsError);
+    }
+  });
+
+  it("updates node name", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const updatedNode = { ...baseRootNode, name: "Consumer Electronics" };
+    spies.select.mockReturnValueOnce(baseRootNode);
+    spies.update.mockReturnValue(updatedNode);
+
+    const result = await run(db, { id: baseRootNode.id, name: "Consumer Electronics" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.node.name).toBe("Consumer Electronics");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("passes custom fields through to set", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const updatedNode = { ...baseRootNode, sortOrder: 5 };
+    spies.select.mockReturnValueOnce(baseRootNode);
+    spies.update.mockReturnValue(updatedNode);
+
+    await run(db, { id: baseRootNode.id, name: "Electronics", sortOrder: 5 }, ctx);
+
+    expect(spies.set).toHaveBeenNthCalledWith(1, expect.objectContaining({ sortOrder: 5 }));
+  });
+});

package/src/modules/item-management/command/updateTaxonomyNode.ts

@@ -0,0 +1,62 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  CodeImmutableError,
+  MissingRequiredFieldsError,
+  NodeNotFoundError,
+} from "../lib/errors.generated";
+import { getTaxonomyNode } from "../query/getTaxonomyNode.generated";
+
+export interface UpdateTaxonomyNodeInput {
+  id: string;
+  code?: string;
+  name?: string;
+}
+
+/**
+ * Function: updateTaxonomyNode
+ *
+ * Updates the display name of an existing taxonomy node.
+ * Node code is immutable.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: DB,
+  input: UpdateTaxonomyNodeInput & Partial<CF>,
+  ctx: CommandContext,
+) {
+  const { id, code, name, ...customFields } = input;
+
+  // 1. Check node exists
+  const { node } = await getTaxonomyNode(db, { id }, ctx);
+
+  if (!node) {
+    return err(new NodeNotFoundError(id));
+  }
+
+  // 2. Code is immutable
+  if (code !== undefined) {
+    return err(new CodeImmutableError(id));
+  }
+
+  // 3. Name must be provided and non-empty (unless custom fields provided)
+  const hasCustomFields = Object.keys(customFields).length > 0;
+  if (!name && !hasCustomFields) {
+    return err(new MissingRequiredFieldsError("name"));
+  }
+
+  // 4. Update fields
+  const updates: Record<string, unknown> = {
+    ...(customFields as Record<string, unknown>),
+    updatedAt: new Date(),
+  };
+  if (name) updates.name = name;
+
+  const updatedNode = await db
+    .updateTable("TaxonomyNode")
+    .set(updates)
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ node: updatedNode });
+}