@tailor-platform/erp-kit 0.2.0 → 0.2.2

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

@@ -0,0 +1,90 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { baseActiveProduct, baseChildCategory, baseCategoryAssignment } from "../testing/fixtures";
+import { ProductNotFoundError, CategoryNotFoundError } from "../lib/errors.generated";
+import type { AssignProductToCategoryInput } from "./assignProductToCategory";
+import { run } from "./assignProductToCategory";
+
+describe("assignProductToCategory", () => {
+  it("should return ProductNotFoundError when product does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProduct -> null
+    spies.select.mockReturnValueOnce(undefined);
+    const input: AssignProductToCategoryInput = {
+      productId: "non-existent",
+      categoryId: baseChildCategory.id,
+    };
+    const result = await run(db, input);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductNotFoundError);
+    }
+  });
+
+  it("should return CategoryNotFoundError when category does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1st select: getProduct -> found
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2nd select: getProductCategory -> null
+    spies.select.mockReturnValueOnce(undefined);
+    const input: AssignProductToCategoryInput = {
+      productId: baseActiveProduct.id,
+      categoryId: "non-existent",
+    };
+    const result = await run(db, input);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CategoryNotFoundError);
+    }
+  });
+
+  it("should create assignment successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1st select: getProduct -> found
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2nd select: getProductCategory -> found
+    spies.select.mockReturnValueOnce(baseChildCategory);
+    // 3rd select: getProductCategoryAssignment -> null (no existing)
+    spies.select.mockReturnValueOnce(undefined);
+    // insert returns new assignment
+    const newAssignment = {
+      ...baseCategoryAssignment,
+      id: "new-assign-id",
+      productId: baseActiveProduct.id,
+      categoryId: baseChildCategory.id,
+    };
+    spies.insert.mockReturnValueOnce(newAssignment);
+
+    const input: AssignProductToCategoryInput = {
+      productId: baseActiveProduct.id,
+      categoryId: baseChildCategory.id,
+    };
+    const result = await run(db, input);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment).toEqual(newAssignment);
+    }
+  });
+
+  it("should return existing assignment when already assigned (idempotent)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1st select: getProduct -> found
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2nd select: getProductCategory -> found
+    spies.select.mockReturnValueOnce(baseChildCategory);
+    // 3rd select: getProductCategoryAssignment -> existing
+    spies.select.mockReturnValueOnce(baseCategoryAssignment);
+
+    const input: AssignProductToCategoryInput = {
+      productId: baseActiveProduct.id,
+      categoryId: baseChildCategory.id,
+    };
+    const result = await run(db, input);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment).toEqual(baseCategoryAssignment);
+    }
+    expect(spies.insert).not.toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,62 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import { ProductNotFoundError, CategoryNotFoundError } from "../lib/errors.generated";
+
+export interface AssignProductToCategoryInput {
+  productId: string;
+  categoryId: string;
+}
+
+/**
+ * Function: assignProductToCategory
+ *
+ * Assigns a product to a category. Idempotent.
+ */
+export async function run(db: Transaction, input: AssignProductToCategoryInput) {
+  const { productId, categoryId } = input;
+
+  // Validate product exists
+  const product = await db
+    .selectFrom("Product")
+    .select("id")
+    .where("id", "=", productId)
+    .executeTakeFirst();
+  if (!product) {
+    return err(new ProductNotFoundError(productId));
+  }
+
+  // Validate category exists
+  const category = await db
+    .selectFrom("ProductCategory")
+    .select("id")
+    .where("id", "=", categoryId)
+    .executeTakeFirst();
+  if (!category) {
+    return err(new CategoryNotFoundError(categoryId));
+  }
+
+  // Check if already assigned (idempotent, with lock for uniqueness)
+  const existing = await db
+    .selectFrom("ProductCategoryAssignment")
+    .selectAll()
+    .where("productId", "=", productId)
+    .where("categoryId", "=", categoryId)
+    .forUpdate()
+    .executeTakeFirst();
+  if (existing) {
+    return ok({ assignment: existing });
+  }
+
+  const assignment = await db
+    .insertInto("ProductCategoryAssignment")
+    .values({
+      productId,
+      categoryId,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ assignment });
+}

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

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

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

@@ -0,0 +1,149 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { CommandContext } from "../../../shared";
+import type { GetUnitInput } from "../../primitives/query/getUnit";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  DuplicateCodeError,
+  InvalidUomError,
+  MissingRequiredFieldError,
+} from "../lib/errors.generated";
+import { baseDraftProduct } from "../testing/fixtures";
+import { run } from "./createProduct";
+
+describe("createProduct", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["product-management:createProduct"],
+  };
+
+  const baseUnit = {
+    id: "unit-pcs",
+    symbol: "pcs",
+    name: "Pieces",
+    roundingPrecision: 0,
+    isActive: true,
+    createdAt: new Date("2024-01-01"),
+    updatedAt: null,
+    categoryId: "uom-cat-1",
+    conversionFactor: 1,
+  };
+
+  const mockGetUnit = (_db: unknown, input: GetUnitInput) =>
+    Promise.resolve({
+      ok: true as const,
+      value: {
+        unit: "id" in input && input.id === "unit-pcs" ? baseUnit : null,
+      },
+    });
+  const primitivesQueries = { getUnit: mockGetUnit };
+
+  it("returns error when code is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+    const result = await run(
+      db,
+      { code: "", name: "Test", unitId: "unit-pcs" },
+      ctx,
+      primitivesQueries,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
+  });
+
+  it("returns error when name is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+    const result = await run(
+      db,
+      { code: "PROD-1", name: "", unitId: "unit-pcs" },
+      ctx,
+      primitivesQueries,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
+  });
+
+  it("returns error when code already exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProduct select returns existing product
+    spies.select.mockReturnValueOnce(baseDraftProduct);
+    const result = await run(
+      db,
+      { code: "CLASSIC-TSHIRT", name: "Another Shirt", unitId: "unit-pcs" },
+      ctx,
+      primitivesQueries,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateCodeError);
+    }
+  });
+
+  it("returns error when UoM is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProduct select returns no existing product
+    spies.select.mockReturnValueOnce(undefined);
+    const result = await run(
+      db,
+      { code: "PROD-1", name: "Test Product", unitId: "unit-invalid" },
+      ctx,
+      primitivesQueries,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidUomError);
+    }
+  });
+
+  it("creates product in DRAFT status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProduct select returns no existing product
+    spies.select.mockReturnValueOnce(undefined);
+    // insert returns the new product
+    spies.insert.mockReturnValueOnce({ ...baseDraftProduct });
+    const result = await run(
+      db,
+      { code: "CLASSIC-TSHIRT", name: "Classic T-Shirt", unitId: "unit-pcs" },
+      ctx,
+      primitivesQueries,
+    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.product).toEqual(baseDraftProduct);
+    }
+    expect(spies.values).toHaveBeenCalledWith(
+      expect.objectContaining({
+        code: "CLASSIC-TSHIRT",
+        name: "Classic T-Shirt",
+        unitId: "unit-pcs",
+        status: "DRAFT",
+      }),
+    );
+  });
+
+  it("passes custom fields through", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined);
+    spies.insert.mockReturnValueOnce({ ...baseDraftProduct, customField1: "value1" });
+    const result = await run(
+      db,
+      {
+        code: "CLASSIC-TSHIRT",
+        name: "Classic T-Shirt",
+        unitId: "unit-pcs",
+        customField1: "value1",
+      },
+      ctx,
+      primitivesQueries,
+    );
+    expect(result.ok).toBe(true);
+    expect(spies.values).toHaveBeenCalledWith(
+      expect.objectContaining({
+        customField1: "value1",
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,73 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  DuplicateCodeError,
+  MissingRequiredFieldError,
+  InvalidUomError,
+} from "../lib/errors.generated";
+import type { PrimitivesQueries } from "../module";
+
+export interface CreateProductInput {
+  code: string;
+  name: string;
+  description?: string;
+  unitId: string;
+}
+
+/**
+ * Function: createProduct
+ *
+ * Creates a new product in DRAFT status with a unique code.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateProductInput & CF,
+  ctx: CommandContext,
+  primitivesQueries: Pick<PrimitivesQueries, "getUnit">,
+) {
+  const { code, name, description, unitId, ...customFields } = input;
+
+  // Validate required fields
+  if (!code?.trim()) {
+    return err(new MissingRequiredFieldError("code"));
+  }
+  if (!name?.trim()) {
+    return err(new MissingRequiredFieldError("name"));
+  }
+
+  // Check code uniqueness
+  const existingCode = await db
+    .selectFrom("Product")
+    .select("id")
+    .where("code", "=", code)
+    .forUpdate()
+    .executeTakeFirst();
+  if (existingCode) {
+    return err(new DuplicateCodeError(code));
+  }
+
+  // Validate UoM
+  const unitResult = await primitivesQueries.getUnit(db, { id: unitId }, ctx);
+  if (!unitResult.ok) return err(new InvalidUomError(unitId));
+  if (!unitResult.value.unit?.isActive) {
+    return err(new InvalidUomError(unitId));
+  }
+
+  // Create product
+  const product = await db
+    .insertInto("Product")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      code,
+      name,
+      description: description ?? null,
+      unitId,
+      status: "DRAFT",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ product });
+}

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

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

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

@@ -0,0 +1,70 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
+import { DuplicateCodeError, MissingRequiredFieldError } from "../lib/errors.generated";
+import { baseColorAttribute } from "../testing/fixtures";
+import { run } from "./createProductAttribute";
+
+describe("createProductAttribute", () => {
+  it("returns error when code is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { code: "", name: "Color" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
+  });
+
+  it("returns error when name is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { code: "COLOR", name: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
+  });
+
+  it("returns error when code already exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseColorAttribute); // getProductAttribute finds existing
+
+    const result = await run(db, { code: "COLOR", name: "Color" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateCodeError);
+    }
+  });
+
+  it("creates attribute successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdAttribute = { ...baseColorAttribute, id: "new-attr-id" };
+
+    spies.select.mockReturnValueOnce(undefined); // No existing attribute
+    spies.insert.mockReturnValue(createdAttribute);
+
+    const result = await run(db, { code: "COLOR", name: "Color" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.attribute.code).toBe("COLOR");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+
+  it("passes custom fields through to insert", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdAttribute = { ...baseColorAttribute, id: "new-attr-id", priority: 5 };
+
+    spies.select.mockReturnValueOnce(undefined); // No existing attribute
+    spies.insert.mockReturnValue(createdAttribute);
+
+    await run(db, { code: "COLOR", name: "Color", priority: 5 });
+
+    expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ priority: 5 }));
+  });
+});

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

@@ -0,0 +1,53 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import { DuplicateCodeError, MissingRequiredFieldError } from "../lib/errors.generated";
+
+export interface CreateProductAttributeInput {
+  code: string;
+  name: string;
+}
+
+/**
+ * Function: createProductAttribute
+ *
+ * Creates a new product attribute with a unique code.
+ * All attributes are variant axes with predefined values.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: CreateProductAttributeInput & CF,
+) {
+  const { code, name, ...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("ProductAttribute")
+    .select("id")
+    .where("code", "=", code)
+    .forUpdate()
+    .executeTakeFirst();
+  if (existing) {
+    return err(new DuplicateCodeError(code));
+  }
+
+  const attribute = await db
+    .insertInto("ProductAttribute")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      code,
+      name,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ attribute });
+}

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

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

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

@@ -0,0 +1,68 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  AttributeNotFoundError,
+  InvalidLabelError,
+  DuplicateValueError,
+} from "../lib/errors.generated";
+import { baseColorAttribute, baseColorRed } from "../testing/fixtures";
+import { run } from "./createProductAttributeValue";
+
+describe("createProductAttributeValue", () => {
+  it("returns error when attribute not found", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(undefined); // attribute not found
+
+    const result = await run(db, { attributeId: "nonexistent", label: "Red" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AttributeNotFoundError);
+    }
+  });
+
+  it("returns error when label is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValueOnce(baseColorAttribute); // attribute found
+
+    const result = await run(db, { attributeId: baseColorAttribute.id, label: "" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidLabelError);
+    }
+  });
+
+  it("returns error when label already exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(baseColorRed); // existing value with same label
+
+    const result = await run(db, { attributeId: baseColorAttribute.id, label: "Red" });
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateValueError);
+    }
+  });
+
+  it("creates value successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const createdValue = { ...baseColorRed, id: "new-value-id", label: "Green" };
+
+    spies.select
+      .mockReturnValueOnce(baseColorAttribute) // attribute found
+      .mockReturnValueOnce(undefined); // no duplicate label
+    spies.insert.mockReturnValue(createdValue);
+
+    const result = await run(db, { attributeId: baseColorAttribute.id, label: "Green" });
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.value.label).toBe("Green");
+    }
+    expect(spies.insert).toHaveBeenCalled();
+  });
+});

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

@@ -0,0 +1,63 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  AttributeNotFoundError,
+  InvalidLabelError,
+  DuplicateValueError,
+} from "../lib/errors.generated";
+
+export interface CreateProductAttributeValueInput {
+  attributeId: string;
+  label: string;
+}
+
+/**
+ * Function: createProductAttributeValue
+ *
+ * Creates a new predefined value for an attribute.
+ */
+export async function run(db: Transaction, input: CreateProductAttributeValueInput) {
+  const { attributeId, label } = input;
+
+  // Check attribute exists
+  const attribute = await db
+    .selectFrom("ProductAttribute")
+    .selectAll()
+    .where("id", "=", attributeId)
+    .executeTakeFirst();
+
+  if (!attribute) {
+    return err(new AttributeNotFoundError(attributeId));
+  }
+
+  // Validate label
+  if (!label?.trim()) {
+    return err(new InvalidLabelError(attributeId));
+  }
+
+  // Check label uniqueness within attribute
+  const existingValue = await db
+    .selectFrom("ProductAttributeValue")
+    .selectAll()
+    .where("attributeId", "=", attributeId)
+    .where("label", "=", label)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (existingValue) {
+    return err(new DuplicateValueError(label));
+  }
+
+  const value = await db
+    .insertInto("ProductAttributeValue")
+    .values({
+      attributeId,
+      label,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return ok({ value });
+}

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

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