@tailor-platform/erp-kit 0.2.1 → 0.2.2

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

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import { baseLeafCategory, baseChildCategory, baseCategoryAssignment } from "../testing/fixtures";
+import {
+  CategoryNotFoundError,
+  HasChildrenError,
+  HasAssignmentsError,
+} from "../lib/errors.generated";
+import type { DeleteProductCategoryInput } from "./deleteProductCategory";
+import { run } from "./deleteProductCategory";
+
+describe("deleteProductCategory", () => {
+  it("should return CategoryNotFoundError when category does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // select for category -> not found
+    spies.select.mockReturnValueOnce(undefined);
+    const input: DeleteProductCategoryInput = { id: "non-existent" };
+    const result = await run(db, input);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CategoryNotFoundError);
+    }
+  });
+
+  it("should return HasChildrenError when category has children", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1st select: category found
+    spies.select.mockReturnValueOnce(baseChildCategory);
+    // 2nd select: child exists (executeTakeFirst)
+    spies.select.mockReturnValueOnce(baseLeafCategory);
+    const input: DeleteProductCategoryInput = { id: baseChildCategory.id };
+    const result = await run(db, input);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(HasChildrenError);
+    }
+  });
+
+  it("should return HasAssignmentsError when category has assignments", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1st select: category found
+    spies.select.mockReturnValueOnce(baseLeafCategory);
+    // 2nd select: no children (executeTakeFirst)
+    spies.select.mockReturnValueOnce(undefined);
+    // 3rd select: assignment exists (executeTakeFirst)
+    spies.select.mockReturnValueOnce(baseCategoryAssignment);
+    const input: DeleteProductCategoryInput = { id: baseLeafCategory.id };
+    const result = await run(db, input);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(HasAssignmentsError);
+    }
+  });
+
+  it("should delete leaf category successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1st select: category found
+    spies.select.mockReturnValueOnce(baseLeafCategory);
+    // 2nd select: no children (executeTakeFirst)
+    spies.select.mockReturnValueOnce(undefined);
+    // 3rd select: no assignments (executeTakeFirst)
+    spies.select.mockReturnValueOnce(undefined);
+    // delete executes
+    spies.delete.mockReturnValueOnce(undefined);
+
+    const input: DeleteProductCategoryInput = { id: baseLeafCategory.id };
+    const result = await run(db, input);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.id).toBe(baseLeafCategory.id);
+    }
+  });
+});

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

@@ -0,0 +1,53 @@
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  CategoryNotFoundError,
+  HasChildrenError,
+  HasAssignmentsError,
+} from "../lib/errors.generated";
+
+export interface DeleteProductCategoryInput {
+  id: string;
+}
+
+/**
+ * Function: deleteProductCategory
+ *
+ * Deletes a leaf category with no product assignments.
+ */
+export async function run(db: Transaction, input: DeleteProductCategoryInput) {
+  const { id } = input;
+
+  const category = await db
+    .selectFrom("ProductCategory")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!category) {
+    return err(new CategoryNotFoundError(id));
+  }
+
+  const child = await db
+    .selectFrom("ProductCategory")
+    .select("id")
+    .where("parentId", "=", id)
+    .executeTakeFirst();
+  if (child) {
+    return err(new HasChildrenError(id));
+  }
+
+  const assignment = await db
+    .selectFrom("ProductCategoryAssignment")
+    .select("id")
+    .where("categoryId", "=", id)
+    .executeTakeFirst();
+  if (assignment) {
+    return err(new HasAssignmentsError(id));
+  }
+
+  await db.deleteFrom("ProductCategory").where("id", "=", id).execute();
+
+  return ok({ id });
+}

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

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

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

@@ -0,0 +1,365 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import { err, type CommandContext } from "../../../shared";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  baseActiveProduct,
+  baseDraftProduct,
+  baseColorAttribute,
+  baseSizeAttribute,
+  baseAttributeAssignment,
+} from "../testing/fixtures";
+import {
+  ProductNotFoundError,
+  InvalidProductStatusError,
+  NoVariantAxesError,
+  AttributeNotFoundError,
+  AttributeValueNotFoundError,
+  ItemCreationFailedError,
+} from "../lib/errors.generated";
+import { UnitNotFoundError } from "../../item-management/lib/errors.generated";
+import type { GenerateVariantsInput } from "./generateVariants";
+import { run } from "./generateVariants";
+
+describe("generateVariants", () => {
+  const ctx: CommandContext = {
+    actorId: "test-actor",
+    permissions: ["product-management:generateVariants"],
+  };
+
+  const mockCreateItem = (_db: unknown, input: { sku: string; name: string; unitId: string }) =>
+    Promise.resolve({
+      ok: true as const,
+      value: {
+        item: {
+          id: `item-${input.sku}`,
+          sku: input.sku,
+          name: input.name,
+          barcode: null,
+          unitId: input.unitId,
+          status: "ACTIVE" as const,
+          createdAt: new Date(),
+          updatedAt: null,
+        },
+      },
+    });
+  const skuStrategy = (code: string, _values: string[], count: number) =>
+    `${code}-${String(count + 1).padStart(3, "0")}`;
+  const deps = {
+    itemManagement: { createItem: mockCreateItem },
+    skuStrategy,
+  };
+
+  it("should return ProductNotFoundError when product does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProduct -> null
+    spies.select.mockReturnValueOnce(undefined);
+    const input: GenerateVariantsInput = { productId: "non-existent" };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ProductNotFoundError);
+    }
+  });
+
+  it("should return InvalidProductStatusError when product is not ACTIVE", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // getProduct -> draft product (not ACTIVE)
+    spies.select.mockReturnValueOnce(baseDraftProduct);
+    const input: GenerateVariantsInput = { productId: baseDraftProduct.id };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidProductStatusError);
+    }
+  });
+
+  it("should return NoVariantAxesError when no attribute assignments exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProduct -> active product
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2. listProductAttributeAssignments -> empty
+    spies.select.mockReturnValueOnce([]);
+
+    const input: GenerateVariantsInput = { productId: baseActiveProduct.id };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(NoVariantAxesError);
+    }
+  });
+
+  it("should return AttributeNotFoundError when referenced attribute no longer exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProduct -> active product
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2. listProductAttributeAssignments -> assignment referencing an attribute
+    const colorRedAssignment = {
+      ...baseAttributeAssignment,
+      valueId: "value-1",
+    };
+    spies.select.mockReturnValueOnce([colorRedAssignment]);
+    // 3. data integrity: select ProductAttribute by ID -> deleted between queries
+    spies.select.mockReturnValueOnce(undefined);
+
+    const input: GenerateVariantsInput = { productId: baseActiveProduct.id };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AttributeNotFoundError);
+    }
+  });
+
+  it("should return AttributeValueNotFoundError when referenced value no longer exists", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProduct -> active product
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2. listProductAttributeAssignments -> assignment with a value ID
+    const colorRedAssignment = {
+      ...baseAttributeAssignment,
+      valueId: "value-1",
+    };
+    spies.select.mockReturnValueOnce([colorRedAssignment]);
+    // 3. data integrity: attribute exists
+    spies.select.mockReturnValueOnce(baseColorAttribute);
+    // 4. data integrity: value deleted between queries
+    spies.select.mockReturnValueOnce(undefined);
+
+    const input: GenerateVariantsInput = { productId: baseActiveProduct.id };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(AttributeValueNotFoundError);
+    }
+  });
+
+  it("should skip existing variant combinations (idempotency)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProduct -> active product
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2. listProductAttributeAssignments -> one assignment
+    const colorRedAssignment = {
+      ...baseAttributeAssignment,
+      valueId: "value-1",
+    };
+    spies.select.mockReturnValueOnce([colorRedAssignment]);
+    // 3. data integrity: attribute exists
+    spies.select.mockReturnValueOnce(baseColorAttribute);
+    // 4. data integrity: value exists
+    spies.select.mockReturnValueOnce({ id: "value-1" });
+    // 5. listProductVariants -> existing variant with same key
+    const existingVariant = {
+      id: "variant-existing",
+      productId: baseActiveProduct.id,
+      axisValueKey: "value-1",
+      itemId: "item-existing",
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    spies.select.mockReturnValueOnce([existingVariant]);
+
+    const input: GenerateVariantsInput = { productId: baseActiveProduct.id };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.variants).toHaveLength(0);
+    }
+    // No inserts should have happened since all combinations already exist
+    expect(spies.insert).not.toHaveBeenCalled();
+  });
+
+  it("should return ItemCreationFailedError when item creation fails", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const failingCreateItem = () => Promise.resolve(err(new UnitNotFoundError("unit-pcs")));
+    const failingDeps = {
+      itemManagement: { createItem: failingCreateItem },
+      skuStrategy,
+    };
+
+    // 1. getProduct -> active product
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2. listProductAttributeAssignments -> one assignment
+    const colorRedAssignment = {
+      ...baseAttributeAssignment,
+      valueId: "value-1",
+    };
+    spies.select.mockReturnValueOnce([colorRedAssignment]);
+    // 3. data integrity: attribute exists
+    spies.select.mockReturnValueOnce(baseColorAttribute);
+    // 4. data integrity: value exists
+    spies.select.mockReturnValueOnce({ id: "value-1" });
+    // 5. listProductVariants -> no existing variants
+    spies.select.mockReturnValueOnce([]);
+
+    const input: GenerateVariantsInput = { productId: baseActiveProduct.id };
+    const result = await run(db, input, ctx, failingDeps);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ItemCreationFailedError);
+    }
+  });
+
+  it("should generate multi-axis cartesian product variants", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProduct -> active product
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2. listProductAttributeAssignments -> color and size assignments
+    const colorRedAssignment = {
+      ...baseAttributeAssignment,
+      valueId: "value-1",
+    };
+    const colorBlueAssignment = {
+      ...baseAttributeAssignment,
+      id: "assignment-2",
+      valueId: "value-2",
+    };
+    const sizeSmallAssignment = {
+      ...baseAttributeAssignment,
+      id: "assignment-3",
+      attributeId: baseSizeAttribute.id,
+      valueId: "value-3",
+    };
+    spies.select.mockReturnValueOnce([
+      colorRedAssignment,
+      colorBlueAssignment,
+      sizeSmallAssignment,
+    ]);
+    // 3. data integrity: attributes exist (color, size)
+    spies.select.mockReturnValueOnce(baseColorAttribute);
+    spies.select.mockReturnValueOnce(baseSizeAttribute);
+    // 4. data integrity: values exist (value-1, value-2, value-3)
+    spies.select.mockReturnValueOnce({ id: "value-1" });
+    spies.select.mockReturnValueOnce({ id: "value-2" });
+    spies.select.mockReturnValueOnce({ id: "value-3" });
+    // 5. listProductVariants -> no existing variants
+    spies.select.mockReturnValueOnce([]);
+    // 6. For each combination (2 combos: [value-1,value-3], [value-2,value-3]):
+    const variant1 = {
+      id: "variant-new-1",
+      productId: baseActiveProduct.id,
+      axisValueKey: "value-1|value-3",
+      itemId: `item-${baseActiveProduct.code}-001`,
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    const variant2 = {
+      id: "variant-new-2",
+      productId: baseActiveProduct.id,
+      axisValueKey: "value-2|value-3",
+      itemId: `item-${baseActiveProduct.code}-002`,
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    spies.insert.mockReturnValueOnce(variant1);
+    spies.insert.mockReturnValueOnce(variant2);
+
+    const input: GenerateVariantsInput = { productId: baseActiveProduct.id };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.variants).toHaveLength(2);
+    }
+  });
+
+  it("should only generate new combinations when some already exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProduct -> active product
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2. listProductAttributeAssignments -> two color assignments
+    const colorRedAssignment = {
+      ...baseAttributeAssignment,
+      valueId: "value-1",
+    };
+    const colorBlueAssignment = {
+      ...baseAttributeAssignment,
+      id: "assignment-2",
+      valueId: "value-2",
+    };
+    spies.select.mockReturnValueOnce([colorRedAssignment, colorBlueAssignment]);
+    // 3. data integrity: attribute exists
+    spies.select.mockReturnValueOnce(baseColorAttribute);
+    // 4. data integrity: values exist
+    spies.select.mockReturnValueOnce({ id: "value-1" });
+    spies.select.mockReturnValueOnce({ id: "value-2" });
+    // 5. listProductVariants -> one existing variant for value-1
+    const existingVariant = {
+      id: "variant-existing",
+      productId: baseActiveProduct.id,
+      axisValueKey: "value-1",
+      itemId: "item-existing",
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    spies.select.mockReturnValueOnce([existingVariant]);
+    // 6. Only value-2 combination should be created
+    const newVariant = {
+      id: "variant-new-1",
+      productId: baseActiveProduct.id,
+      axisValueKey: "value-2",
+      itemId: `item-${baseActiveProduct.code}-002`,
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    spies.insert.mockReturnValueOnce(newVariant);
+
+    const input: GenerateVariantsInput = { productId: baseActiveProduct.id };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.variants).toHaveLength(1);
+      expect(result.value.variants[0]).toEqual(newVariant);
+    }
+  });
+
+  it("should generate variants successfully", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    // 1. getProduct -> active product
+    spies.select.mockReturnValueOnce(baseActiveProduct);
+    // 2. listProductAttributeAssignments -> assignments for color
+    const colorRedAssignment = {
+      ...baseAttributeAssignment,
+      valueId: "value-1",
+    };
+    const colorBlueAssignment = {
+      ...baseAttributeAssignment,
+      id: "assignment-2",
+      valueId: "value-2",
+    };
+    spies.select.mockReturnValueOnce([colorRedAssignment, colorBlueAssignment]);
+    // 3. data integrity: attribute exists
+    spies.select.mockReturnValueOnce(baseColorAttribute);
+    // 4. data integrity: values exist
+    spies.select.mockReturnValueOnce({ id: "value-1" });
+    spies.select.mockReturnValueOnce({ id: "value-2" });
+    // 5. listProductVariants -> no existing variants
+    spies.select.mockReturnValueOnce([]);
+    // 6. For each combination (2 combos: value-1, value-2):
+    const variant1 = {
+      id: "variant-new-1",
+      productId: baseActiveProduct.id,
+      axisValueKey: "value-1",
+      itemId: `item-${baseActiveProduct.code}-001`,
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    const variant2 = {
+      id: "variant-new-2",
+      productId: baseActiveProduct.id,
+      axisValueKey: "value-2",
+      itemId: `item-${baseActiveProduct.code}-002`,
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    spies.insert.mockReturnValueOnce(variant1);
+    spies.insert.mockReturnValueOnce(variant2);
+
+    const input: GenerateVariantsInput = { productId: baseActiveProduct.id };
+    const result = await run(db, input, ctx, deps);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.variants).toHaveLength(2);
+      expect(result.value.variants[0]).toEqual(variant1);
+      expect(result.value.variants[1]).toEqual(variant2);
+    }
+  });
+});

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

@@ -0,0 +1,168 @@
+import { ok, err, type CommandContext } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  ProductNotFoundError,
+  InvalidProductStatusError,
+  NoVariantAxesError,
+  AttributeNotFoundError,
+  AttributeValueNotFoundError,
+  ItemCreationFailedError,
+} from "../lib/errors.generated";
+import type { ItemManagementCommands, SkuStrategy } from "../module";
+
+export interface GenerateVariantsInput {
+  productId: string;
+}
+
+/**
+ * Function: generateVariants
+ *
+ * Generates product variants from cartesian product of attribute values.
+ * All attributes are variant axes.
+ */
+export async function run(
+  db: Transaction,
+  input: GenerateVariantsInput,
+  ctx: CommandContext,
+  deps: {
+    itemManagement: Pick<ItemManagementCommands, "createItem">;
+    skuStrategy: SkuStrategy;
+  },
+) {
+  const { productId } = input;
+  const { itemManagement, skuStrategy } = deps;
+
+  // Check product exists
+  const product = await db
+    .selectFrom("Product")
+    .selectAll()
+    .where("id", "=", productId)
+    .executeTakeFirst();
+  if (!product) {
+    return err(new ProductNotFoundError(productId));
+  }
+
+  // Must be ACTIVE
+  if (product.status !== "ACTIVE") {
+    return err(new InvalidProductStatusError(productId));
+  }
+
+  // Get all attribute assignments for this product
+  const assignments = await db
+    .selectFrom("ProductAttributeAssignment")
+    .selectAll()
+    .where("productId", "=", productId)
+    .execute();
+
+  // Group assignments by attribute (all attributes are variant axes)
+  const axisValuesByAttribute = new Map<string, string[]>();
+  for (const assignment of assignments) {
+    const values = axisValuesByAttribute.get(assignment.attributeId) ?? [];
+    values.push(assignment.valueId);
+    axisValuesByAttribute.set(assignment.attributeId, values);
+  }
+
+  if (axisValuesByAttribute.size === 0) {
+    return err(new NoVariantAxesError(productId));
+  }
+
+  // Data integrity check: verify all referenced attributes still exist
+  for (const attributeId of axisValuesByAttribute.keys()) {
+    const attr = await db
+      .selectFrom("ProductAttribute")
+      .select("id")
+      .where("id", "=", attributeId)
+      .executeTakeFirst();
+
+    if (!attr) {
+      return err(new AttributeNotFoundError(attributeId));
+    }
+  }
+
+  // Data integrity check: verify all referenced values still exist
+  for (const values of axisValuesByAttribute.values()) {
+    for (const valueId of values) {
+      const val = await db
+        .selectFrom("ProductAttributeValue")
+        .select("id")
+        .where("id", "=", valueId)
+        .executeTakeFirst();
+
+      if (!val) {
+        return err(new AttributeValueNotFoundError(valueId));
+      }
+    }
+  }
+
+  // Compute cartesian product
+  const axisEntries = Array.from(axisValuesByAttribute.values());
+  const combinations = cartesianProduct(axisEntries);
+
+  // Get existing variants (with lock for axisValueKey uniqueness)
+  const existingVariants = await db
+    .selectFrom("ProductVariant")
+    .selectAll()
+    .where("productId", "=", productId)
+    .forUpdate()
+    .execute();
+  const existingKeys = new Set(existingVariants.map((v) => v.axisValueKey));
+
+  const newVariants = [];
+  let variantCount = existingVariants.length;
+
+  for (const combination of combinations) {
+    const sortedValues = [...combination].sort();
+    const axisValueKey = sortedValues.join("|");
+
+    if (existingKeys.has(axisValueKey)) {
+      continue;
+    }
+
+    // Generate SKU
+    const sku = skuStrategy(product.code, combination, variantCount);
+    variantCount++;
+
+    // Create Item in item-management
+    const itemResult = await itemManagement.createItem(
+      db,
+      { sku, name: `${product.name} - ${sku}`, unitId: product.unitId },
+      ctx,
+    );
+
+    if (!itemResult.ok) {
+      return err(new ItemCreationFailedError(sku));
+    }
+
+    const itemId = (itemResult.value as { item: { id: string } }).item.id;
+
+    // Create ProductVariant record
+    const variant = await db
+      .insertInto("ProductVariant")
+      .values({
+        productId,
+        axisValueKey,
+        itemId,
+        createdAt: new Date(),
+        updatedAt: null,
+      })
+      .returningAll()
+      .executeTakeFirstOrThrow();
+
+    newVariants.push(variant);
+  }
+
+  return ok({ variants: newVariants });
+}
+
+function cartesianProduct(arrays: string[][]): string[][] {
+  if (arrays.length === 0) return [[]];
+  const [first, ...rest] = arrays;
+  const restCombinations = cartesianProduct(rest);
+  const result: string[][] = [];
+  for (const value of first) {
+    for (const combination of restCombinations) {
+      result.push([value, ...combination]);
+    }
+  }
+  return result;
+}

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

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