@tailor-platform/erp-kit 0.2.1 → 0.2.2

package/src/modules/product-management/command/createProductCategory.test.ts

@@ -0,0 +1,135 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { baseRootCategory, baseChildCategory } from "../testing/fixtures";
+import {
+  MissingRequiredFieldError,
+  DuplicateCodeError,
+  ParentNotFoundError,
+  MaxDepthExceededError,
+} from "../lib/errors.generated";
+import { run } from "./createProductCategory";
+
+describe("createProductCategory", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["product-management:createProductCategory"],
+  };
+
+  const deps = { maxDepth: 3 };
+
+  it("should return MissingRequiredFieldError when code is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+    const input = { code: "", name: "Clothing" };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
+  });
+
+  it("should return MissingRequiredFieldError when name is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+    const input = { code: "CLOTHING", name: "" };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
+  });
+
+  it("should return DuplicateCodeError when code already exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProductCategory by code returns existing
+    spies.select.mockReturnValueOnce(baseRootCategory);
+    const input = { code: "CLOTHING", name: "Clothing" };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateCodeError);
+    }
+  });
+
+  it("should return ParentNotFoundError when parent does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1st select: code uniqueness check -> null (no duplicate)
+    spies.select.mockReturnValueOnce(undefined);
+    // 2nd select: getProductCategory by parentId -> null (not found)
+    spies.select.mockReturnValueOnce(undefined);
+    const input = {
+      code: "TOPS",
+      name: "Tops",
+      parentId: "non-existent",
+    };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ParentNotFoundError);
+    }
+  });
+
+  it("should return MaxDepthExceededError when depth exceeds maxDepth", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1st select: code uniqueness -> null
+    spies.select.mockReturnValueOnce(undefined);
+    // 2nd select: getProductCategory by parentId -> found
+    spies.select.mockReturnValueOnce(baseChildCategory);
+    // calculateCategoryDepth walks up the parent chain:
+    // 1st iteration: categoryId=category-2, returns { parentId: "category-1" }
+    spies.select.mockReturnValueOnce({ parentId: "category-1" });
+    // 2nd iteration: categoryId=category-1, returns { parentId: null }
+    spies.select.mockReturnValueOnce({ parentId: null });
+    // depth = 2, new child depth = 3, but maxDepth = 2
+    const result = await run(
+      db,
+      { code: "VNECKS", name: "V-Necks", parentId: baseChildCategory.id },
+      ctx,
+      { maxDepth: 2 },
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MaxDepthExceededError);
+    }
+  });
+
+  it("should create a root category when no parentId is provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // code uniqueness -> null
+    spies.select.mockReturnValueOnce(undefined);
+    // insert returns the new category
+    const newCategory = { ...baseRootCategory, id: "new-id" };
+    spies.insert.mockReturnValueOnce(newCategory);
+
+    const input = { code: "CLOTHING", name: "Clothing" };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.category).toEqual(newCategory);
+    }
+  });
+
+  it("should create a child category when parentId is provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // code uniqueness -> null
+    spies.select.mockReturnValueOnce(undefined);
+    // getProductCategory by parentId -> found
+    spies.select.mockReturnValueOnce(baseRootCategory);
+    // calculateCategoryDepth: categoryId=category-1, returns { parentId: null }
+    spies.select.mockReturnValueOnce({ parentId: null });
+    // depth = 1, child depth = 2, maxDepth = 3 -> ok
+    const newCategory = { ...baseChildCategory, id: "new-child-id" };
+    spies.insert.mockReturnValueOnce(newCategory);
+
+    const input = {
+      code: "TOPS",
+      name: "Tops",
+      parentId: baseRootCategory.id,
+    };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.category).toEqual(newCategory);
+    }
+  });
+});

package/src/modules/product-management/command/createProductCategory.ts

@@ -0,0 +1,82 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  DuplicateCodeError,
+  MissingRequiredFieldError,
+  ParentNotFoundError,
+  MaxDepthExceededError,
+} from "../lib/errors.generated";
+import { calculateCategoryDepth } from "../query/calculateCategoryDepth.generated";
+
+export interface CreateProductCategoryInput {
+  code: string;
+  name: string;
+  parentId?: string;
+}
+
+/**
+ * Function: createProductCategory
+ *
+ * Creates a new category node in the product category tree.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateProductCategoryInput & CF,
+  ctx: CommandContext,
+  deps: { maxDepth: number },
+) {
+  const { maxDepth } = deps;
+  const { code, name, parentId, ...customFields } = input;
+
+  if (!code?.trim()) {
+    return err(new MissingRequiredFieldError("code"));
+  }
+  if (!name?.trim()) {
+    return err(new MissingRequiredFieldError("name"));
+  }
+
+  // Check code uniqueness
+  const existing = await db
+    .selectFrom("ProductCategory")
+    .select("id")
+    .where("code", "=", code)
+    .forUpdate()
+    .executeTakeFirst();
+  if (existing) {
+    return err(new DuplicateCodeError(code));
+  }
+
+  // If parent specified, check it exists and validate depth
+  if (parentId) {
+    const parent = await db
+      .selectFrom("ProductCategory")
+      .select("id")
+      .where("id", "=", parentId)
+      .executeTakeFirst();
+    if (!parent) {
+      return err(new ParentNotFoundError(parentId));
+    }
+
+    const depthResult = await calculateCategoryDepth(db, { categoryId: parentId }, ctx);
+    if (!depthResult.ok) return err(new ParentNotFoundError(parentId));
+    const depth = depthResult.value.depth + 1;
+    if (depth > maxDepth) {
+      return err(new MaxDepthExceededError(`${depth} exceeds ${maxDepth}`));
+    }
+  }
+
+  const category = await db
+    .insertInto("ProductCategory")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      code,
+      name,
+      parentId: parentId ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ category });
+}

package/src/modules/product-management/command/deactivateProduct.generated.ts

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

package/src/modules/product-management/command/deactivateProduct.test.ts

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { InvalidStateTransitionError, ProductNotFoundError } from "../lib/errors.generated";
+import { baseActiveProduct, baseDraftProduct } from "../testing/fixtures";
+import { run } from "./deactivateProduct";
+
+describe("deactivateProduct", () => {
+  it("returns error when product not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+    const result = await run(db, { id: "nonexistent" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductNotFoundError);
+    }
+  });
+
+  it("returns error when not in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseDraftProduct });
+    const result = await run(db, { id: "product-1" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStateTransitionError);
+    }
+  });
+
+  it("deactivates ACTIVE product to ARCHIVED", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const archived = { ...baseActiveProduct, status: "ARCHIVED" };
+    spies.select.mockReturnValueOnce({ ...baseActiveProduct });
+    spies.update.mockReturnValueOnce(archived);
+    const result = await run(db, { id: "product-2" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.product.status).toBe("ARCHIVED");
+    }
+  });
+});

package/src/modules/product-management/command/deactivateProduct.ts

@@ -0,0 +1,42 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import { ProductNotFoundError, InvalidStateTransitionError } from "../lib/errors.generated";
+
+export interface DeactivateProductInput {
+  id: string;
+  from?: string[];
+}
+
+/**
+ * Function: deactivateProduct
+ *
+ * Transitions a product from ACTIVE to ARCHIVED.
+ */
+export async function run(db: Transaction, input: DeactivateProductInput) {
+  const { id } = input;
+  const validFrom = input.from ?? ["ACTIVE"];
+
+  const product = await db
+    .selectFrom("Product")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!product) {
+    return err(new ProductNotFoundError(id));
+  }
+
+  if (!validFrom.includes(product.status)) {
+    return err(new InvalidStateTransitionError(id));
+  }
+
+  const updated = await db
+    .updateTable("Product")
+    .set({ status: "ARCHIVED", updatedAt: new Date() })
+    .where("id", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ product: updated! });
+}

package/src/modules/product-management/command/deleteProduct.generated.ts

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

package/src/modules/product-management/command/deleteProduct.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { DeleteNotAllowedError, ProductNotFoundError } from "../lib/errors.generated";
+import { baseActiveProduct, baseDraftProduct } from "../testing/fixtures";
+import { run } from "./deleteProduct";
+
+describe("deleteProduct", () => {
+  it("returns error when product not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+    const result = await run(db, { id: "nonexistent" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductNotFoundError);
+    }
+  });
+
+  it("returns error when not DRAFT", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseActiveProduct });
+    const result = await run(db, { id: "product-2" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DeleteNotAllowedError);
+    }
+  });
+
+  it("deletes DRAFT product and associated records", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce({ ...baseDraftProduct });
+    // delete calls for ProductAttributeAssignment, ProductCategoryAssignment, Product
+    spies.delete.mockReturnValueOnce([]);
+    spies.delete.mockReturnValueOnce([]);
+    spies.delete.mockReturnValueOnce([]);
+    const result = await run(db, { id: "product-1" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.id).toBe("product-1");
+    }
+  });
+});

package/src/modules/product-management/command/deleteProduct.ts

@@ -0,0 +1,42 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import { ProductNotFoundError, DeleteNotAllowedError } from "../lib/errors.generated";
+
+export interface DeleteProductInput {
+  id: string;
+}
+
+/**
+ * Function: deleteProduct
+ *
+ * Permanently deletes a DRAFT product and all associated assignments.
+ */
+export async function run(db: Transaction, input: DeleteProductInput) {
+  const { id } = input;
+
+  const product = await db
+    .selectFrom("Product")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!product) {
+    return err(new ProductNotFoundError(id));
+  }
+
+  if (product.status !== "DRAFT") {
+    return err(new DeleteNotAllowedError(id));
+  }
+
+  // Remove attribute assignments
+  await db.deleteFrom("ProductAttributeAssignment").where("productId", "=", id).execute();
+
+  // Remove category assignments
+  await db.deleteFrom("ProductCategoryAssignment").where("productId", "=", id).execute();
+
+  // Delete product
+  await db.deleteFrom("Product").where("id", "=", id).execute();
+
+  return ok({ id });
+}

package/src/modules/product-management/command/deleteProductAttribute.generated.ts

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

package/src/modules/product-management/command/deleteProductAttribute.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
+import { AttributeNotFoundError, AttributeInUseError } from "../lib/errors.generated";
+import { baseColorAttribute, baseAttributeAssignment } from "../testing/fixtures";
+import { run } from "./deleteProductAttribute";
+
+describe("deleteProductAttribute", () => {
+  it("returns error when attribute not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // attribute lookup
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AttributeNotFoundError);
+    }
+  });
+
+  it("returns error when attribute is in use", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(baseAttributeAssignment); // assignment exists (executeTakeFirst)
+
+    const result = await run(db, { id: baseColorAttribute.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AttributeInUseError);
+    }
+  });
+
+  it("deletes attribute and values successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(undefined); // no assignments (executeTakeFirst)
+
+    const result = await run(db, { id: baseColorAttribute.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.id).toBe(baseColorAttribute.id);
+    }
+    expect(spies.delete).toHaveBeenCalled();
+  });
+});

package/src/modules/product-management/command/deleteProductAttribute.ts

@@ -0,0 +1,45 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import { AttributeNotFoundError, AttributeInUseError } from "../lib/errors.generated";
+
+export interface DeleteProductAttributeInput {
+  id: string;
+}
+
+/**
+ * Function: deleteProductAttribute
+ *
+ * Deletes an attribute that is not assigned to any product.
+ */
+export async function run(db: Transaction, input: DeleteProductAttributeInput) {
+  const { id } = input;
+
+  const attribute = await db
+    .selectFrom("ProductAttribute")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!attribute) {
+    return err(new AttributeNotFoundError(id));
+  }
+
+  // Check if assigned to any product
+  const assignments = await db
+    .selectFrom("ProductAttributeAssignment")
+    .select("id")
+    .where("attributeId", "=", id)
+    .executeTakeFirst();
+  if (assignments) {
+    return err(new AttributeInUseError(id));
+  }
+
+  // Remove attribute values
+  await db.deleteFrom("ProductAttributeValue").where("attributeId", "=", id).execute();
+
+  // Delete attribute
+  await db.deleteFrom("ProductAttribute").where("id", "=", id).execute();
+
+  return ok({ id });
+}

package/src/modules/product-management/command/deleteProductAttributeValue.generated.ts

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

package/src/modules/product-management/command/deleteProductAttributeValue.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  ValueNotFoundError,
+  ValueInUseError,
+  AttributeNotFoundError,
+} from "../lib/errors.generated";
+import { baseColorRed } from "../testing/fixtures";
+import { run } from "./deleteProductAttributeValue";
+
+describe("deleteProductAttributeValue", () => {
+  it("returns error when value not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // value not found
+
+    const result = await run(db, { id: "nonexistent" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ValueNotFoundError);
+    }
+  });
+
+  it("returns error when parent attribute does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const orphanValue = { ...baseColorRed, attributeId: "nonexistent-attr" };
+    spies.select
+      .mockReturnValueOnce(orphanValue) // value found
+      .mockReturnValueOnce(undefined); // attribute not found
+
+    const result = await run(db, { id: orphanValue.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AttributeNotFoundError);
+    }
+  });
+
+  it("returns error when value is in use on ACTIVE product", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseColorRed) // value found
+      .mockReturnValueOnce({ id: baseColorRed.attributeId }) // attribute exists
+      .mockReturnValueOnce({ id: "variant-1" }); // join query finds active variant usage
+
+    const result = await run(db, { id: baseColorRed.id });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ValueInUseError);
+    }
+  });
+
+  it("deletes value and cleans up DRAFT product assignments", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseColorRed) // value found
+      .mockReturnValueOnce({ id: baseColorRed.attributeId }) // attribute exists
+      .mockReturnValueOnce(undefined); // no active variant usage
+
+    const result = await run(db, { id: baseColorRed.id });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.id).toBe(baseColorRed.id);
+    }
+    // Should have called delete twice: once for assignment cleanup, once for value deletion
+    expect(spies.delete).toHaveBeenCalledTimes(2);
+  });
+});

package/src/modules/product-management/command/deleteProductAttributeValue.ts

@@ -0,0 +1,68 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  ValueNotFoundError,
+  ValueInUseError,
+  AttributeNotFoundError,
+} from "../lib/errors.generated";
+
+export interface DeleteProductAttributeValueInput {
+  id: string;
+}
+
+/**
+ * Function: deleteProductAttributeValue
+ *
+ * Deletes a value from an attribute if not in use on ACTIVE products.
+ */
+export async function run(db: Transaction, input: DeleteProductAttributeValueInput) {
+  const { id } = input;
+
+  const value = await db
+    .selectFrom("ProductAttributeValue")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!value) {
+    return err(new ValueNotFoundError(id));
+  }
+
+  // Data integrity check: verify parent attribute exists
+  const attribute = await db
+    .selectFrom("ProductAttribute")
+    .select("id")
+    .where("id", "=", value.attributeId)
+    .executeTakeFirst();
+
+  if (!attribute) {
+    return err(new AttributeNotFoundError(value.attributeId));
+  }
+
+  // Check if value is in use on ACTIVE products
+  // Find variants that include this value ID in their axisValueKey
+  const activeVariantUsage = await db
+    .selectFrom("ProductVariant")
+    .innerJoin("Product", "Product.id", "ProductVariant.productId")
+    .select("ProductVariant.id")
+    .where("Product.status", "=", "ACTIVE")
+    .where("ProductVariant.axisValueKey", "like", `%${id}%`)
+    .executeTakeFirst();
+
+  if (activeVariantUsage) {
+    return err(new ValueInUseError(id));
+  }
+
+  // Remove attribute assignment references on DRAFT products
+  await db
+    .deleteFrom("ProductAttributeAssignment")
+    .where("valueId", "=", id)
+    .where("productId", "in", db.selectFrom("Product").select("id").where("status", "=", "DRAFT"))
+    .execute();
+
+  // Delete the value
+  await db.deleteFrom("ProductAttributeValue").where("id", "=", id).execute();
+
+  return ok({ id });
+}

package/src/modules/product-management/command/deleteProductCategory.generated.ts

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