@tailor-platform/erp-kit 0.1.1 → 0.2.0

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

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  NodeHasAssignmentsError,
+  NodeHasChildrenError,
+  NodeNotFoundError,
+} from "../lib/errors.generated";
+import { baseAssignment, baseChildNode, baseLeafNode, baseRootNode } from "../testing/fixtures";
+import { run } from "./deleteTaxonomyNode";
+
+describe("deleteTaxonomyNode", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:deleteTaxonomyNode"],
+  };
+
+  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" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NodeNotFoundError);
+    }
+  });
+
+  it("returns error when node has children", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseRootNode) // getTaxonomyNode
+      .mockReturnValueOnce([baseChildNode]); // getTaxonomyNodeChildren (execute returns array)
+
+    const result = await run(db, { id: baseRootNode.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NodeHasChildrenError);
+    }
+  });
+
+  it("returns error when node has item assignments", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode
+      .mockReturnValueOnce([]) // getTaxonomyNodeChildren (no children)
+      .mockReturnValueOnce([baseAssignment]); // getTaxonomyNodeAssignments (has assignment)
+
+    const result = await run(db, { id: baseLeafNode.id }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NodeHasAssignmentsError);
+    }
+  });
+
+  it("deletes a leaf node with no assignments", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode
+      .mockReturnValueOnce([]) // getTaxonomyNodeChildren (no children)
+      .mockReturnValueOnce([]); // getTaxonomyNodeAssignments (no assignments)
+    spies.delete.mockReturnValue(undefined);
+
+    const result = await run(db, { id: baseLeafNode.id }, 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/deleteTaxonomyNode.ts

@@ -0,0 +1,50 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  NodeHasAssignmentsError,
+  NodeHasChildrenError,
+  NodeNotFoundError,
+} from "../lib/errors.generated";
+import { getTaxonomyNode } from "../query/getTaxonomyNode.generated";
+import { getTaxonomyNodeChildren } from "../query/getTaxonomyNodeChildren.generated";
+import { getTaxonomyNodeAssignments } from "../query/getTaxonomyNodeAssignments.generated";
+
+export interface DeleteTaxonomyNodeInput {
+  id: string;
+}
+
+/**
+ * Function: deleteTaxonomyNode
+ *
+ * Permanently removes a leaf taxonomy node with no item assignments.
+ * The node's code becomes available for reuse.
+ */
+export async function run(db: DB, input: DeleteTaxonomyNodeInput, ctx: CommandContext) {
+  const { id } = input;
+
+  // 1. Check node exists
+  const { node } = await getTaxonomyNode(db, { id }, ctx);
+
+  if (!node) {
+    return err(new NodeNotFoundError(id));
+  }
+
+  // 2. Check no children
+  const { children } = await getTaxonomyNodeChildren(db, { parentId: id }, ctx);
+
+  if (children.length > 0) {
+    return err(new NodeHasChildrenError(id));
+  }
+
+  // 3. Check no item assignments
+  const { assignments } = await getTaxonomyNodeAssignments(db, { taxonomyNodeId: id }, ctx);
+
+  if (assignments.length > 0) {
+    return err(new NodeHasAssignmentsError(id));
+  }
+
+  // 4. Delete node
+  await db.deleteFrom("TaxonomyNode").where("id", "=", id).execute();
+
+  return ok({ success: true as const });
+}

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

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

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

@@ -0,0 +1,136 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import { type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  CircularReferenceError,
+  MaxDepthExceededError,
+  NodeNotFoundError,
+  ParentNodeNotFoundError,
+} from "../lib/errors.generated";
+import { baseChildNode, baseLeafNode, baseRootNode, secondRootNode } from "../testing/fixtures";
+import { run } from "./moveTaxonomyNode";
+
+describe("moveTaxonomyNode", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["item-management:moveTaxonomyNode"],
+  };
+
+  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", newParentId: null }, ctx, { maxDepth: 10 });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NodeNotFoundError);
+    }
+  });
+
+  it("returns error when new parent does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseChildNode) // getTaxonomyNode for node
+      .mockReturnValueOnce(undefined); // getTaxonomyNode for new parent
+
+    const result = await run(db, { id: baseChildNode.id, newParentId: "nonexistent" }, ctx, {
+      maxDepth: 10,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentNodeNotFoundError);
+    }
+  });
+
+  it("returns error when moving node under itself", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseRootNode) // getTaxonomyNode for node
+      .mockReturnValueOnce(baseRootNode); // getTaxonomyNode for new parent
+
+    const result = await run(db, { id: baseRootNode.id, newParentId: baseRootNode.id }, ctx, {
+      maxDepth: 10,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CircularReferenceError);
+    }
+  });
+
+  it("returns error when moving node under its descendant", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseRootNode) // getTaxonomyNode for node (node-1)
+      .mockReturnValueOnce(baseLeafNode) // getTaxonomyNode for new parent (node-3)
+      .mockReturnValueOnce(baseLeafNode) // detectCircularReference: lookup node-3
+      .mockReturnValueOnce(baseChildNode); // detectCircularReference: lookup node-2 → parentId=node-1=nodeId → circular!
+
+    const result = await run(db, { id: baseRootNode.id, newParentId: baseLeafNode.id }, ctx, {
+      maxDepth: 10,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CircularReferenceError);
+    }
+  });
+
+  it("promotes node to root by setting parent to null", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const movedNode = { ...baseChildNode, parentId: null };
+    spies.select.mockReturnValueOnce(baseChildNode); // getTaxonomyNode for node
+    spies.update.mockReturnValue(movedNode);
+
+    const result = await run(db, { id: baseChildNode.id, newParentId: null }, ctx, {
+      maxDepth: 10,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.node.parentId).toBeNull();
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("moves node to different parent", async () => {
+    const { db, spies } = createMockDb<DB>();
+    const movedNode = { ...baseChildNode, parentId: secondRootNode.id };
+    spies.select
+      .mockReturnValueOnce(baseChildNode) // getTaxonomyNode for node (node-2)
+      .mockReturnValueOnce(secondRootNode) // getTaxonomyNode for new parent (node-4)
+      .mockReturnValueOnce(secondRootNode) // detectCircularReference: lookup node-4 → parentId=null → not circular
+      .mockReturnValueOnce(secondRootNode) // calculateNodeDepth: lookup node-4 → parentId=null → depth=1
+      .mockReturnValueOnce([baseLeafNode]) // calculateSubtreeDepth: children of node-2
+      .mockReturnValueOnce([]); // calculateSubtreeDepth: children of node-3 (leaf, no children)
+    spies.update.mockReturnValue(movedNode);
+
+    const result = await run(db, { id: baseChildNode.id, newParentId: secondRootNode.id }, ctx, {
+      maxDepth: 10,
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.node.parentId).toBe(secondRootNode.id);
+    }
+  });
+
+  it("returns error when subtree depth + new parent depth exceeds maxDepth", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseChildNode) // getTaxonomyNode for node (node-2)
+      .mockReturnValueOnce(secondRootNode) // getTaxonomyNode for new parent (node-4)
+      .mockReturnValueOnce(secondRootNode) // detectCircularReference: lookup node-4 → not circular
+      .mockReturnValueOnce(secondRootNode) // calculateNodeDepth: lookup node-4 → depth=1
+      .mockReturnValueOnce([baseLeafNode]) // calculateSubtreeDepth: children of node-2
+      .mockReturnValueOnce([]); // calculateSubtreeDepth: children of node-3 (leaf)
+
+    // newParentDepth=1 (root), subtreeDepth=2 (child+leaf), totalDepth=3 > maxDepth=2
+    const result = await run(db, { id: baseChildNode.id, newParentId: secondRootNode.id }, ctx, {
+      maxDepth: 2,
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MaxDepthExceededError);
+    }
+  });
+});

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

@@ -0,0 +1,85 @@
+import { ok, err, type CommandContext } from "../../shared/internal";
+import { DB } from "../generated/kysely-tailordb";
+import {
+  CircularReferenceError,
+  MaxDepthExceededError,
+  NodeNotFoundError,
+  ParentNodeNotFoundError,
+} from "../lib/errors.generated";
+import { getTaxonomyNode } from "../query/getTaxonomyNode.generated";
+import { detectCircularReference } from "../query/detectCircularReference.generated";
+import { calculateNodeDepth } from "../query/calculateNodeDepth.generated";
+import { calculateSubtreeDepth } from "../query/calculateSubtreeDepth.generated";
+
+export interface MoveTaxonomyNodeInput {
+  id: string;
+  newParentId: string | null;
+}
+
+/**
+ * Function: moveTaxonomyNode
+ *
+ * Reparents a taxonomy node. Moving to null promotes to root.
+ * Validates circular references and depth limits.
+ */
+export async function run(
+  db: DB,
+  input: MoveTaxonomyNodeInput,
+  ctx: CommandContext,
+  config?: { maxDepth: number },
+) {
+  const { maxDepth } = config!;
+  const { id, newParentId } = input;
+
+  // 1. Check node exists
+  const { node } = await getTaxonomyNode(db, { id }, ctx);
+
+  if (!node) {
+    return err(new NodeNotFoundError(id));
+  }
+
+  // 2. If promoting to root, just update
+  if (newParentId === null) {
+    const movedNode = await db
+      .updateTable("TaxonomyNode")
+      .set({ parentId: null, updatedAt: new Date() })
+      .where("id", "=", id)
+      .returningAll()
+      .executeTakeFirst();
+
+    return ok({ node: movedNode! });
+  }
+
+  // 3. Check new parent exists
+  const { node: newParent } = await getTaxonomyNode(db, { id: newParentId }, ctx);
+
+  if (!newParent) {
+    return err(new ParentNodeNotFoundError(newParentId));
+  }
+
+  // 4. Check circular reference
+  const { isCircular } = await detectCircularReference(db, { nodeId: id, newParentId }, ctx);
+
+  if (isCircular) {
+    return err(new CircularReferenceError(`${id} -> ${newParentId}`));
+  }
+
+  // 5. Check depth limit: new parent depth + subtree depth of moved node
+  const { depth: newParentDepth } = await calculateNodeDepth(db, { nodeId: newParentId }, ctx);
+  const { depth: subtreeDepth } = await calculateSubtreeDepth(db, { nodeId: id }, ctx);
+  const totalDepth = newParentDepth + subtreeDepth;
+
+  if (totalDepth > maxDepth) {
+    return err(new MaxDepthExceededError(`${totalDepth} exceeds ${maxDepth}`));
+  }
+
+  // 6. Update parent
+  const movedNode = await db
+    .updateTable("TaxonomyNode")
+    .set({ parentId: newParentId, updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ node: movedNode! });
+}

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

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

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);