@tailor-platform/erp-kit 0.1.1 → 0.2.0

package/src/modules/item-management/query/calculateNodeDepth.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseRootNode, baseChildNode, baseLeafNode } from "../testing/fixtures";
+import { run } from "./calculateNodeDepth";
+
+describe("calculateNodeDepth", () => {
+  it("returns depth 1 for root node", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseRootNode);
+
+    const result = await run(db, { nodeId: "node-1" });
+
+    expect(result.depth).toBe(1);
+  });
+
+  it("returns depth 2 for child of root", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseChildNode).mockReturnValueOnce(baseRootNode);
+
+    const result = await run(db, { nodeId: "node-2" });
+
+    expect(result.depth).toBe(2);
+  });
+
+  it("returns depth 3 for grandchild of root", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce(baseLeafNode)
+      .mockReturnValueOnce(baseChildNode)
+      .mockReturnValueOnce(baseRootNode);
+
+    const result = await run(db, { nodeId: "node-3" });
+
+    expect(result.depth).toBe(3);
+  });
+
+  it("returns depth 1 when node not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { nodeId: "nonexistent" });
+
+    expect(result.depth).toBe(1);
+  });
+
+  it("handles broken ancestor chain gracefully", async () => {
+    const brokenNode = { ...baseChildNode, parentId: "missing-parent" };
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(brokenNode).mockReturnValueOnce(undefined);
+
+    const result = await run(db, { nodeId: "node-2" });
+
+    expect(result.depth).toBe(2);
+  });
+});

package/src/modules/item-management/query/calculateNodeDepth.ts

@@ -0,0 +1,28 @@
+import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface CalculateNodeDepthInput {
+  nodeId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: CalculateNodeDepthInput) {
+  let depth = 1;
+  let currentId: string | null = input.nodeId;
+
+  while (currentId) {
+    const node = await db
+      .selectFrom("TaxonomyNode")
+      .selectAll()
+      .where("id", "=", currentId)
+      .executeTakeFirst();
+
+    if (!node) break;
+
+    if (!node.parentId) break;
+
+    depth++;
+    currentId = node.parentId;
+  }
+
+  return { depth };
+}

package/src/modules/item-management/query/calculateSubtreeDepth.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "../../shared/internal";
+import { run } from "./calculateSubtreeDepth";
+
+export const calculateSubtreeDepth = defineQuery(run);

package/src/modules/item-management/query/calculateSubtreeDepth.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseChildNode, baseLeafNode } from "../testing/fixtures";
+import { run } from "./calculateSubtreeDepth";
+
+describe("calculateSubtreeDepth", () => {
+  it("returns 1 for leaf node (no children)", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([]);
+
+    const result = await run(db, { nodeId: "node-3" });
+
+    expect(result.depth).toBe(1);
+  });
+
+  it("returns 2 for node with one level of children", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce([baseLeafNode]).mockReturnValueOnce([]);
+
+    const result = await run(db, { nodeId: "node-1" });
+
+    expect(result.depth).toBe(2);
+  });
+
+  it("returns 3 for node with two levels of children", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce([baseChildNode])
+      .mockReturnValueOnce([baseLeafNode])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { nodeId: "node-1" });
+
+    expect(result.depth).toBe(3);
+  });
+
+  it("returns max depth for node with multiple branches", async () => {
+    const shortChild = {
+      id: "short-1",
+      code: "S",
+      name: "Short",
+      parentId: "node-1",
+      createdAt: new Date("2024-01-01T00:00:00.000Z"),
+      updatedAt: null,
+    };
+    const deepChild = {
+      id: "deep-1",
+      code: "D",
+      name: "Deep",
+      parentId: "node-1",
+      createdAt: new Date("2024-01-01T00:00:00.000Z"),
+      updatedAt: null,
+    };
+    const deepGrandchild = {
+      id: "deep-2",
+      code: "DG",
+      name: "Deep Grand",
+      parentId: "deep-1",
+      createdAt: new Date("2024-01-01T00:00:00.000Z"),
+      updatedAt: null,
+    };
+
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce([shortChild, deepChild])
+      .mockReturnValueOnce([])
+      .mockReturnValueOnce([deepGrandchild])
+      .mockReturnValueOnce([]);
+
+    const result = await run(db, { nodeId: "node-1" });
+
+    expect(result.depth).toBe(3);
+  });
+});

package/src/modules/item-management/query/calculateSubtreeDepth.ts

@@ -0,0 +1,29 @@
+import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface CalculateSubtreeDepthInput {
+  nodeId: string;
+}
+
+async function getSubtreeDepth(db: ReadonlyDB<DB>, nodeId: string): Promise<number> {
+  const children = await db
+    .selectFrom("TaxonomyNode")
+    .selectAll()
+    .where("parentId", "=", nodeId)
+    .execute();
+
+  if (!children || children.length === 0) return 1;
+
+  let maxChildDepth = 0;
+  for (const child of children) {
+    const childDepth = await getSubtreeDepth(db, child.id);
+    if (childDepth > maxChildDepth) maxChildDepth = childDepth;
+  }
+
+  return 1 + maxChildDepth;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: CalculateSubtreeDepthInput) {
+  const depth = await getSubtreeDepth(db, input.nodeId);
+  return { depth };
+}

package/src/modules/item-management/query/detectCircularReference.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "../../shared/internal";
+import { run } from "./detectCircularReference";
+
+export const detectCircularReference = defineQuery(run);

package/src/modules/item-management/query/detectCircularReference.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseRootNode, baseChildNode, baseLeafNode } from "../testing/fixtures";
+import { run } from "./detectCircularReference";
+
+describe("detectCircularReference", () => {
+  it("detects self-reference as circular", async () => {
+    const { db } = createMockDb<DB>();
+
+    const result = await run(db, { nodeId: "node-1", newParentId: "node-1" });
+
+    expect(result.isCircular).toBe(true);
+  });
+
+  it("detects moving node under its child as circular", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseChildNode);
+
+    const result = await run(db, { nodeId: "node-1", newParentId: "node-2" });
+
+    expect(result.isCircular).toBe(true);
+  });
+
+  it("detects moving node under its grandchild as circular", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseLeafNode).mockReturnValueOnce(baseChildNode);
+
+    const result = await run(db, { nodeId: "node-1", newParentId: "node-3" });
+
+    expect(result.isCircular).toBe(true);
+  });
+
+  it("returns not circular for valid move", async () => {
+    const secondRoot = { ...baseRootNode, id: "node-4", parentId: null };
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(secondRoot);
+
+    const result = await run(db, { nodeId: "node-3", newParentId: "node-4" });
+
+    expect(result.isCircular).toBe(false);
+  });
+
+  it("returns not circular when new parent is root", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(baseRootNode);
+
+    const result = await run(db, { nodeId: "node-2", newParentId: "node-1" });
+
+    expect(result.isCircular).toBe(false);
+  });
+
+  it("handles broken ancestor chain gracefully (not circular)", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { nodeId: "node-1", newParentId: "missing-node" });
+
+    expect(result.isCircular).toBe(false);
+  });
+});

package/src/modules/item-management/query/detectCircularReference.ts

@@ -0,0 +1,32 @@
+import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface DetectCircularReferenceInput {
+  nodeId: string;
+  newParentId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: DetectCircularReferenceInput) {
+  if (input.newParentId === input.nodeId) {
+    return { isCircular: true };
+  }
+
+  // Walk up from new parent to root, checking if the moved node appears
+  let ancestorId: string | null = input.newParentId;
+  while (ancestorId) {
+    const ancestor = await db
+      .selectFrom("TaxonomyNode")
+      .selectAll()
+      .where("id", "=", ancestorId)
+      .executeTakeFirst();
+
+    if (!ancestor) break;
+
+    ancestorId = ancestor.parentId;
+    if (ancestorId === input.nodeId) {
+      return { isCircular: true };
+    }
+  }
+
+  return { isCircular: false };
+}

package/src/modules/item-management/query/getItem.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "../../shared/internal";
+import { run } from "./getItem";
+
+export const getItem = defineQuery(run);

package/src/modules/item-management/query/getItem.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseActiveItem, baseDraftItem } from "../testing/fixtures";
+import { run } from "./getItem";
+
+describe("getItem", () => {
+  describe("by id", () => {
+    it("returns item when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseDraftItem);
+
+      const result = await run(db, { id: "item-1" });
+
+      expect(result.item).toEqual(baseDraftItem);
+    });
+
+    it("returns null when item not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { id: "nonexistent" });
+
+      expect(result.item).toBeNull();
+    });
+  });
+
+  describe("by sku", () => {
+    it("returns item when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseDraftItem);
+
+      const result = await run(db, { sku: "SKU-001" });
+
+      expect(result.item).toEqual(baseDraftItem);
+    });
+
+    it("returns null when item not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { sku: "NONEXISTENT" });
+
+      expect(result.item).toBeNull();
+    });
+  });
+
+  describe("by barcode", () => {
+    it("returns item when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseActiveItem);
+
+      const result = await run(db, { barcode: "BAR-002" });
+
+      expect(result.item).toEqual(baseActiveItem);
+    });
+
+    it("returns null when item not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { barcode: "NONEXISTENT" });
+
+      expect(result.item).toBeNull();
+    });
+  });
+});

package/src/modules/item-management/query/getItem.ts

@@ -0,0 +1,20 @@
+import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export type GetItemInput = { id: string } | { sku: string } | { barcode: string };
+
+export async function run(db: ReadonlyDB<DB>, input: GetItemInput) {
+  let query = db.selectFrom("Item").selectAll();
+
+  if ("id" in input) {
+    query = query.where("id", "=", input.id);
+  } else if ("sku" in input) {
+    query = query.where("sku", "=", input.sku);
+  } else {
+    query = query.where("barcode", "=", input.barcode);
+  }
+
+  const item = await query.executeTakeFirst();
+
+  return { item: item ?? null };
+}

package/src/modules/item-management/query/getItemTaxonomyAssignment.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "../../shared/internal";
+import { run } from "./getItemTaxonomyAssignment";
+
+export const getItemTaxonomyAssignment = defineQuery(run);

package/src/modules/item-management/query/getItemTaxonomyAssignment.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseAssignment } from "../testing/fixtures";
+import { run } from "./getItemTaxonomyAssignment";
+
+describe("getItemTaxonomyAssignment", () => {
+  it("returns assignment when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseAssignment);
+
+    const result = await run(db, { itemId: "item-2", taxonomyNodeId: "node-2" });
+
+    expect(result.assignment).toEqual(baseAssignment);
+  });
+
+  it("returns null when assignment not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { itemId: "item-1", taxonomyNodeId: "node-1" });
+
+    expect(result.assignment).toBeNull();
+  });
+});

package/src/modules/item-management/query/getItemTaxonomyAssignment.ts

@@ -0,0 +1,18 @@
+import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetItemTaxonomyAssignmentInput {
+  itemId: string;
+  taxonomyNodeId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetItemTaxonomyAssignmentInput) {
+  const assignment = await db
+    .selectFrom("ItemTaxonomyAssignment")
+    .selectAll()
+    .where("itemId", "=", input.itemId)
+    .where("taxonomyNodeId", "=", input.taxonomyNodeId)
+    .executeTakeFirst();
+
+  return { assignment: assignment ?? null };
+}

package/src/modules/item-management/query/getTaxonomyNode.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "../../shared/internal";
+import { run } from "./getTaxonomyNode";
+
+export const getTaxonomyNode = defineQuery(run);

package/src/modules/item-management/query/getTaxonomyNode.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseRootNode } from "../testing/fixtures";
+import { run } from "./getTaxonomyNode";
+
+describe("getTaxonomyNode", () => {
+  describe("by id", () => {
+    it("returns node when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseRootNode);
+
+      const result = await run(db, { id: "node-1" });
+
+      expect(result.node).toEqual(baseRootNode);
+    });
+
+    it("returns null when node not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { id: "nonexistent" });
+
+      expect(result.node).toBeNull();
+    });
+  });
+
+  describe("by code", () => {
+    it("returns node when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseRootNode);
+
+      const result = await run(db, { code: "ELECTRONICS" });
+
+      expect(result.node).toEqual(baseRootNode);
+    });
+
+    it("returns null when node not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { code: "NONEXISTENT" });
+
+      expect(result.node).toBeNull();
+    });
+  });
+});

package/src/modules/item-management/query/getTaxonomyNode.ts

@@ -0,0 +1,18 @@
+import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export type GetTaxonomyNodeInput = { id: string } | { code: string };
+
+export async function run(db: ReadonlyDB<DB>, input: GetTaxonomyNodeInput) {
+  let query = db.selectFrom("TaxonomyNode").selectAll();
+
+  if ("id" in input) {
+    query = query.where("id", "=", input.id);
+  } else {
+    query = query.where("code", "=", input.code);
+  }
+
+  const node = await query.executeTakeFirst();
+
+  return { node: node ?? null };
+}

package/src/modules/item-management/query/getTaxonomyNodeAssignments.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "../../shared/internal";
+import { run } from "./getTaxonomyNodeAssignments";
+
+export const getTaxonomyNodeAssignments = defineQuery(run);

package/src/modules/item-management/query/getTaxonomyNodeAssignments.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseAssignment } from "../testing/fixtures";
+import { run } from "./getTaxonomyNodeAssignments";
+
+describe("getTaxonomyNodeAssignments", () => {
+  it("returns assignments when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseAssignment]);
+
+    const result = await run(db, { taxonomyNodeId: "node-2" });
+
+    expect(result.assignments).toEqual([baseAssignment]);
+  });
+
+  it("returns empty array when no assignments", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { taxonomyNodeId: "node-1" });
+
+    expect(result.assignments).toEqual([]);
+  });
+});

package/src/modules/item-management/query/getTaxonomyNodeAssignments.ts

@@ -0,0 +1,16 @@
+import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetTaxonomyNodeAssignmentsInput {
+  taxonomyNodeId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetTaxonomyNodeAssignmentsInput) {
+  const assignments = await db
+    .selectFrom("ItemTaxonomyAssignment")
+    .selectAll()
+    .where("taxonomyNodeId", "=", input.taxonomyNodeId)
+    .execute();
+
+  return { assignments };
+}

package/src/modules/item-management/query/getTaxonomyNodeChildren.generated.ts

@@ -0,0 +1,5 @@
+// @generated — do not edit
+import { defineQuery } from "../../shared/internal";
+import { run } from "./getTaxonomyNodeChildren";
+
+export const getTaxonomyNodeChildren = defineQuery(run);

package/src/modules/item-management/query/getTaxonomyNodeChildren.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseChildNode, baseLeafNode } from "../testing/fixtures";
+import { run } from "./getTaxonomyNodeChildren";
+
+describe("getTaxonomyNodeChildren", () => {
+  it("returns children when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseChildNode]);
+
+    const result = await run(db, { parentId: "node-1" });
+
+    expect(result.children).toEqual([baseChildNode]);
+  });
+
+  it("returns multiple children", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseChildNode, baseLeafNode]);
+
+    const result = await run(db, { parentId: "node-1" });
+
+    expect(result.children).toHaveLength(2);
+  });
+
+  it("returns empty array when no children", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { parentId: "node-3" });
+
+    expect(result.children).toEqual([]);
+  });
+});

package/src/modules/item-management/query/getTaxonomyNodeChildren.ts

@@ -0,0 +1,16 @@
+import type { ReadonlyDB } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetTaxonomyNodeChildrenInput {
+  parentId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetTaxonomyNodeChildrenInput) {
+  const children = await db
+    .selectFrom("TaxonomyNode")
+    .selectAll()
+    .where("parentId", "=", input.parentId)
+    .execute();
+
+  return { children };
+}

package/src/modules/item-management/tailor.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig, defineGenerators } from "@tailor-platform/sdk";
+
+export default defineConfig({
+  name: "item-management",
+  db: { "main-db": { files: [`./db/*.ts`, `./lib/_db_deps.ts`] } },
+});
+
+export const generators = defineGenerators(
+  ["@tailor-platform/kysely-type", { distPath: `./generated/kysely-tailordb.ts` }],
+  ["@tailor-platform/enum-constants", { distPath: "./generated/enums.ts" }],
+);