@tailor-platform/erp-kit 0.2.0 → 0.2.2

package/src/modules/product-management/query/detectCategoryCircularReference.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { CategoryNotFoundError } from "../lib/errors.generated";
+import { run } from "./detectCategoryCircularReference";
+
+describe("detectCategoryCircularReference", () => {
+  it("returns CategoryNotFoundError when category does not exist", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce(undefined);
+
+    const result = await run(db, { categoryId: "nonexistent", newParentId: "category-2" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CategoryNotFoundError);
+    }
+  });
+
+  it("detects self-reference as circular", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce({ id: "category-1" });
+
+    const result = await run(db, { categoryId: "category-1", newParentId: "category-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(true);
+    }
+  });
+
+  it("detects circular reference when moving node under its descendant", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select
+      .mockReturnValueOnce({ id: "category-1" })
+      .mockReturnValueOnce({ parentId: "category-1" });
+
+    const result = await run(db, { categoryId: "category-1", newParentId: "category-2" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(true);
+    }
+  });
+
+  it("returns not circular for valid move", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce({ id: "category-3" }).mockReturnValueOnce({ parentId: null });
+
+    const result = await run(db, { categoryId: "category-3", newParentId: "category-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(false);
+    }
+  });
+
+  it("returns not circular when ancestor chain is broken", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValueOnce({ id: "category-1" }).mockReturnValueOnce(undefined);
+
+    const result = await run(db, {
+      categoryId: "category-1",
+      newParentId: "category-orphan",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.isCircular).toBe(false);
+    }
+  });
+});

package/src/modules/product-management/query/detectCategoryCircularReference.ts

@@ -0,0 +1,44 @@
+import { ok, err, type ReadonlyDB } from "../../../shared";
+import type { DB } from "../generated/kysely-tailordb";
+import { CategoryNotFoundError } from "../lib/errors.generated";
+
+export interface DetectCategoryCircularReferenceInput {
+  categoryId: string;
+  newParentId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: DetectCategoryCircularReferenceInput) {
+  const category = await db
+    .selectFrom("ProductCategory")
+    .select("id")
+    .where("id", "=", input.categoryId)
+    .executeTakeFirst();
+
+  if (!category) {
+    return err(new CategoryNotFoundError(input.categoryId));
+  }
+
+  if (input.newParentId === input.categoryId) {
+    return ok({ isCircular: true });
+  }
+
+  let currentId: string | null = input.newParentId;
+
+  while (currentId) {
+    const node = await db
+      .selectFrom("ProductCategory")
+      .select("parentId")
+      .where("id", "=", currentId)
+      .executeTakeFirst();
+
+    if (!node) break;
+
+    currentId = node.parentId;
+
+    if (currentId === input.categoryId) {
+      return ok({ isCircular: true });
+    }
+  }
+
+  return ok({ isCircular: false });
+}

package/src/modules/product-management/query/getProduct.generated.ts

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

package/src/modules/product-management/query/getProduct.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseDraftProduct } from "../testing/fixtures";
+import { run } from "./getProduct";
+
+describe("getProduct", () => {
+  describe("by id", () => {
+    it("returns product when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseDraftProduct);
+
+      const result = await run(db, { id: "product-1" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.product).toEqual(baseDraftProduct);
+      }
+    });
+
+    it("returns null when not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { id: "nonexistent" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.product).toBeNull();
+      }
+    });
+  });
+
+  describe("by code", () => {
+    it("returns product when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseDraftProduct);
+
+      const result = await run(db, { code: "CLASSIC-TSHIRT" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.product).toEqual(baseDraftProduct);
+      }
+    });
+
+    it("returns null when not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { code: "NONEXISTENT" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.product).toBeNull();
+      }
+    });
+  });
+});

package/src/modules/product-management/query/getProduct.ts

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

package/src/modules/product-management/query/getProductAttribute.generated.ts

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

package/src/modules/product-management/query/getProductAttribute.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseColorAttribute } from "../testing/fixtures";
+import { run } from "./getProductAttribute";
+
+describe("getProductAttribute", () => {
+  describe("by id", () => {
+    it("returns attribute when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseColorAttribute);
+
+      const result = await run(db, { id: "attr-1" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.attribute).toEqual(baseColorAttribute);
+      }
+    });
+
+    it("returns null when not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { id: "nonexistent" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.attribute).toBeNull();
+      }
+    });
+  });
+
+  describe("by code", () => {
+    it("returns attribute when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseColorAttribute);
+
+      const result = await run(db, { code: "COLOR" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.attribute).toEqual(baseColorAttribute);
+      }
+    });
+
+    it("returns null when not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { code: "NONEXISTENT" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.attribute).toBeNull();
+      }
+    });
+  });
+});

package/src/modules/product-management/query/getProductAttribute.ts

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

package/src/modules/product-management/query/getProductAttributeAssignment.generated.ts

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

package/src/modules/product-management/query/getProductAttributeAssignment.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseAttributeAssignment } from "../testing/fixtures";
+import { run } from "./getProductAttributeAssignment";
+
+describe("getProductAttributeAssignment", () => {
+  it("returns assignments when found by productId and attributeId", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseAttributeAssignment]);
+
+    const result = await run(db, {
+      productId: "product-2",
+      attributeId: "attr-1",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignments).toEqual([baseAttributeAssignment]);
+    }
+  });
+
+  it("returns empty array when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, {
+      productId: "product-2",
+      attributeId: "nonexistent",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignments).toEqual([]);
+    }
+  });
+});

package/src/modules/product-management/query/getProductAttributeAssignment.ts

@@ -0,0 +1,18 @@
+import { ok, type ReadonlyDB } from "../../../shared";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetProductAttributeAssignmentInput {
+  productId: string;
+  attributeId: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetProductAttributeAssignmentInput) {
+  const assignments = await db
+    .selectFrom("ProductAttributeAssignment")
+    .selectAll()
+    .where("productId", "=", input.productId)
+    .where("attributeId", "=", input.attributeId)
+    .execute();
+
+  return ok({ assignments });
+}

package/src/modules/product-management/query/getProductAttributeValue.generated.ts

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

package/src/modules/product-management/query/getProductAttributeValue.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseColorRed } from "../testing/fixtures";
+import { run } from "./getProductAttributeValue";
+
+describe("getProductAttributeValue", () => {
+  it("returns value when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseColorRed);
+
+    const result = await run(db, { id: "value-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.value).toEqual(baseColorRed);
+    }
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.value).toBeNull();
+    }
+  });
+});

package/src/modules/product-management/query/getProductAttributeValue.ts

@@ -0,0 +1,16 @@
+import { ok, type ReadonlyDB } from "../../../shared";
+import type { DB } from "../generated/kysely-tailordb";
+
+export interface GetProductAttributeValueInput {
+  id: string;
+}
+
+export async function run(db: ReadonlyDB<DB>, input: GetProductAttributeValueInput) {
+  const value = await db
+    .selectFrom("ProductAttributeValue")
+    .selectAll()
+    .where("id", "=", input.id)
+    .executeTakeFirst();
+
+  return ok({ value: value ?? null });
+}

package/src/modules/product-management/query/getProductCategory.generated.ts

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

package/src/modules/product-management/query/getProductCategory.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseRootCategory } from "../testing/fixtures";
+import { run } from "./getProductCategory";
+
+describe("getProductCategory", () => {
+  describe("by id", () => {
+    it("returns category when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseRootCategory);
+
+      const result = await run(db, { id: "category-1" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.category).toEqual(baseRootCategory);
+      }
+    });
+
+    it("returns null when not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { id: "nonexistent" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.category).toBeNull();
+      }
+    });
+  });
+
+  describe("by code", () => {
+    it("returns category when found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(baseRootCategory);
+
+      const result = await run(db, { code: "CLOTHING" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.category).toEqual(baseRootCategory);
+      }
+    });
+
+    it("returns null when not found", async () => {
+      const { db, spies } = createMockDb<DB>();
+      spies.select.mockReturnValue(undefined);
+
+      const result = await run(db, { code: "NONEXISTENT" });
+
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.category).toBeNull();
+      }
+    });
+  });
+});

package/src/modules/product-management/query/getProductCategory.ts

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

package/src/modules/product-management/query/getProductCategoryAssignment.generated.ts

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

package/src/modules/product-management/query/getProductCategoryAssignment.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseCategoryAssignment } from "../testing/fixtures";
+import { run } from "./getProductCategoryAssignment";
+
+describe("getProductCategoryAssignment", () => {
+  it("returns assignment when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseCategoryAssignment);
+
+    const result = await run(db, {
+      productId: "product-2",
+      categoryId: "category-2",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment).toEqual(baseCategoryAssignment);
+    }
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, {
+      productId: "product-2",
+      categoryId: "nonexistent",
+    });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment).toBeNull();
+    }
+  });
+});

package/src/modules/product-management/query/getProductCategoryAssignment.ts

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

package/src/modules/product-management/query/getProductVariant.generated.ts

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

package/src/modules/product-management/query/getProductVariant.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseVariant } from "../testing/fixtures";
+import { run } from "./getProductVariant";
+
+describe("getProductVariant", () => {
+  it("returns variant by id", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseVariant);
+
+    const result = await run(db, { id: "variant-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.variant).toEqual(baseVariant);
+    }
+  });
+
+  it("returns variant by productId and axisValueKey", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(baseVariant);
+
+    const result = await run(db, { productId: "product-2", axisValueKey: "value-1|value-3" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.variant).toEqual(baseVariant);
+    }
+  });
+
+  it("returns null when not found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.variant).toBeNull();
+    }
+  });
+});

package/src/modules/product-management/query/getProductVariant.ts

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

package/src/modules/product-management/query/listAttributeAssignmentsByAttribute.generated.ts

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

package/src/modules/product-management/query/listAttributeAssignmentsByAttribute.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { DB } from "../generated/kysely-tailordb";
+import { baseAttributeAssignment } from "../testing/fixtures";
+import { run } from "./listAttributeAssignmentsByAttribute";
+
+describe("listAttributeAssignmentsByAttribute", () => {
+  it("returns assignments when found", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([baseAttributeAssignment]);
+
+    const result = await run(db, { attributeId: "attr-1" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignments).toEqual([baseAttributeAssignment]);
+    }
+  });
+
+  it("returns empty array when no assignments", async () => {
+    const { db, spies } = createMockDb<DB>();
+    spies.select.mockReturnValue([]);
+
+    const result = await run(db, { attributeId: "attr-3" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignments).toEqual([]);
+    }
+  });
+});