@tailor-platform/erp-kit 0.1.1 → 0.2.0

package/src/modules/primitives/command/createUnit.test.ts

@@ -1,18 +1,16 @@
 import { describe, expect, it } from "vitest";
 import { createMockDb } from "../../testing/index";
-import { InsufficientPermissionError, type CommandContext } from "../../shared/internal";
+import { type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
 import {
   CategoryNotActiveError,
   DuplicateUnitSymbolError,
   InvalidConversionFactorError,
   InvalidRoundingPrecisionError,
-  UoMCategoryNotFoundError,
-} from "../lib/errors";
+  UomCategoryNotFoundError,
+} from "../lib/errors.generated";
 import { baseUoMCategory, baseUnitKg } from "../testing/fixtures";
-import { makeCreateUnit } from "./createUnit";
-
-const createUnit = makeCreateUnit();
+import { run } from "./createUnit";
 
 describe("createUnit", () => {
   const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:createUnit"] };
@@ -27,38 +25,44 @@ describe("createUnit", () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined);
 
-    await expect(
-      createUnit(
-        db,
-        {
-          categoryId: "nonexistent-category",
-          name: "Ounce",
-          symbol: "oz",
-          conversionFactor: 0.0283495,
-          roundingPrecision: 2,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(UoMCategoryNotFoundError);
+    const result = await run(
+      db,
+      {
+        categoryId: "nonexistent-category",
+        name: "Ounce",
+        symbol: "oz",
+        conversionFactor: 0.0283495,
+        roundingPrecision: 2,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UomCategoryNotFoundError);
+    }
   });
 
   it("throws when category is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(inactiveCategory);
 
-    await expect(
-      createUnit(
-        db,
-        {
-          categoryId: inactiveCategory.id,
-          name: "Ounce",
-          symbol: "oz",
-          conversionFactor: 0.0283495,
-          roundingPrecision: 2,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CategoryNotActiveError);
+    const result = await run(
+      db,
+      {
+        categoryId: inactiveCategory.id,
+        name: "Ounce",
+        symbol: "oz",
+        conversionFactor: 0.0283495,
+        roundingPrecision: 2,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CategoryNotActiveError);
+    }
   });
 
   it("throws when symbol already exists in category", async () => {
@@ -67,19 +71,22 @@ describe("createUnit", () => {
       .mockReturnValueOnce(baseUoMCategory) // Category lookup
       .mockReturnValueOnce(baseUnitKg); // Existing unit with same symbol
 
-    await expect(
-      createUnit(
-        db,
-        {
-          categoryId: baseUoMCategory.id,
-          name: "Kilogram Duplicate",
-          symbol: "kg",
-          conversionFactor: 1.0,
-          roundingPrecision: 2,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(DuplicateUnitSymbolError);
+    const result = await run(
+      db,
+      {
+        categoryId: baseUoMCategory.id,
+        name: "Kilogram Duplicate",
+        symbol: "kg",
+        conversionFactor: 1.0,
+        roundingPrecision: 2,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateUnitSymbolError);
+    }
   });
 
   it("throws when conversion factor is not positive", async () => {
@@ -88,19 +95,22 @@ describe("createUnit", () => {
       .mockReturnValueOnce(baseUoMCategory) // Category lookup
       .mockReturnValueOnce(undefined); // No duplicate symbol
 
-    await expect(
-      createUnit(
-        db,
-        {
-          categoryId: baseUoMCategory.id,
-          name: "Invalid Unit",
-          symbol: "inv",
-          conversionFactor: 0,
-          roundingPrecision: 2,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InvalidConversionFactorError);
+    const result = await run(
+      db,
+      {
+        categoryId: baseUoMCategory.id,
+        name: "Invalid Unit",
+        symbol: "inv",
+        conversionFactor: 0,
+        roundingPrecision: 2,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidConversionFactorError);
+    }
   });
 
   it("throws when rounding precision is negative", async () => {
@@ -109,19 +119,22 @@ describe("createUnit", () => {
       .mockReturnValueOnce(baseUoMCategory) // Category lookup
       .mockReturnValueOnce(undefined); // No duplicate symbol
 
-    await expect(
-      createUnit(
-        db,
-        {
-          categoryId: baseUoMCategory.id,
-          name: "Invalid Unit",
-          symbol: "inv",
-          conversionFactor: 1.0,
-          roundingPrecision: -1,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InvalidRoundingPrecisionError);
+    const result = await run(
+      db,
+      {
+        categoryId: baseUoMCategory.id,
+        name: "Invalid Unit",
+        symbol: "inv",
+        conversionFactor: 1.0,
+        roundingPrecision: -1,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidRoundingPrecisionError);
+    }
   });
 
   // Success cases
@@ -144,7 +157,7 @@ describe("createUnit", () => {
       .mockReturnValueOnce(undefined); // No duplicate symbol
     spies.insert.mockReturnValue(createdUnit);
 
-    const result = await createUnit(
+    const result = await run(
       db,
       {
         categoryId: baseUoMCategory.id,
@@ -156,32 +169,16 @@ describe("createUnit", () => {
       ctx,
     );
 
-    expect(result.unit.name).toBe("Ounce");
-    expect(result.unit.symbol).toBe("oz");
-    expect(result.unit.isActive).toBe(true);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.unit.name).toBe("Ounce");
+      expect(result.value.unit.symbol).toBe("oz");
+      expect(result.value.unit.isActive).toBe(true);
+    }
     expect(spies.insert).toHaveBeenCalled();
   });
 
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      createUnit(
-        db,
-        {
-          categoryId: "cat-1",
-          name: "Test",
-          symbol: "t",
-          conversionFactor: 1,
-          roundingPrecision: 2,
-        },
-        denied,
-      ),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
-  });
-
   it("passes custom fields through to insert", async () => {
-    const createUnitWithFields = makeCreateUnit<{ displayOrder: number }>();
     const { db, spies } = createMockDb<DB>();
     const createdUnit = {
       ...baseUnitKg,
@@ -196,7 +193,7 @@ describe("createUnit", () => {
       .mockReturnValueOnce(undefined); // No duplicate symbol
     spies.insert.mockReturnValue(createdUnit);
 
-    await createUnitWithFields(
+    await run(
       db,
       {
         categoryId: baseUoMCategory.id,

package/src/modules/primitives/command/createUnit.ts

@@ -1,13 +1,13 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
 import {
   CategoryNotActiveError,
   DuplicateUnitSymbolError,
   InvalidConversionFactorError,
   InvalidRoundingPrecisionError,
-  UoMCategoryNotFoundError,
-} from "../lib/errors";
-import { permissions } from "../permissions";
+  UomCategoryNotFoundError,
+} from "../lib/errors.generated";
+import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 interface CreateUnitInput {
   categoryId: string;
@@ -23,66 +23,63 @@ interface CreateUnitInput {
  * Adds a new unit of measure to an existing category with its symbol,
  * display name, and conversion factor relative to the reference unit.
  */
-export function makeCreateUnit<CF extends Record<string, unknown>>() {
-  return defineCommand(permissions.createUnit, async (db: DB, input: CreateUnitInput & CF) => {
-    const { categoryId, name, symbol, conversionFactor, roundingPrecision, ...customFields } =
-      input;
+export async function run<CF extends Record<string, unknown>>(
+  db: DB,
+  input: CreateUnitInput & CF,
+  ctx: CommandContext,
+) {
+  const { categoryId, name, symbol, conversionFactor, roundingPrecision, ...customFields } = input;
 
-    // 1. Check category exists
-    const category = await db
-      .selectFrom("UoMCategory")
-      .selectAll()
-      .where("id", "=", categoryId)
-      .executeTakeFirst();
+  // 1. Check category exists
+  const { uoMCategory } = await getUoMCategory(db, { id: categoryId }, ctx);
 
-    if (!category) {
-      throw new UoMCategoryNotFoundError(categoryId);
-    }
+  if (!uoMCategory) {
+    return err(new UomCategoryNotFoundError(categoryId));
+  }
 
-    // 2. Check category is active
-    if (!category.isActive) {
-      throw new CategoryNotActiveError(categoryId);
-    }
+  // 2. Check category is active
+  if (!uoMCategory.isActive) {
+    return err(new CategoryNotActiveError(categoryId));
+  }
 
-    // 3. Check symbol uniqueness within category
-    const existingUnit = await db
-      .selectFrom("Unit")
-      .selectAll()
-      .where("categoryId", "=", categoryId)
-      .where("symbol", "=", symbol)
-      .executeTakeFirst();
+  // 3. Check symbol uniqueness within category
+  const existingUnit = await db
+    .selectFrom("Unit")
+    .selectAll()
+    .where("categoryId", "=", categoryId)
+    .where("symbol", "=", symbol)
+    .executeTakeFirst();
 
-    if (existingUnit) {
-      throw new DuplicateUnitSymbolError(symbol, categoryId);
-    }
+  if (existingUnit) {
+    return err(new DuplicateUnitSymbolError(`${symbol} in ${categoryId}`));
+  }
 
-    // 4. Validate conversion factor
-    if (conversionFactor <= 0) {
-      throw new InvalidConversionFactorError(conversionFactor);
-    }
+  // 4. Validate conversion factor
+  if (conversionFactor <= 0) {
+    return err(new InvalidConversionFactorError(String(conversionFactor)));
+  }
 
-    // 5. Validate rounding precision
-    if (roundingPrecision < 0) {
-      throw new InvalidRoundingPrecisionError(roundingPrecision);
-    }
+  // 5. Validate rounding precision
+  if (roundingPrecision < 0) {
+    return err(new InvalidRoundingPrecisionError(String(roundingPrecision)));
+  }
 
-    // 6. Create unit
-    const unit = await db
-      .insertInto("Unit")
-      .values({
-        ...(customFields as Record<string, unknown>),
-        name,
-        symbol,
-        categoryId,
-        conversionFactor,
-        roundingPrecision,
-        isActive: true,
-        createdAt: new Date(),
-        updatedAt: null,
-      })
-      .returningAll()
-      .executeTakeFirst();
+  // 6. Create unit
+  const unit = await db
+    .insertInto("Unit")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      name,
+      symbol,
+      categoryId,
+      conversionFactor,
+      roundingPrecision,
+      isActive: true,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-    return { unit: unit! };
-  });
+  return ok({ unit: unit! });
 }

package/src/modules/primitives/command/deactivateCategory.generated.ts

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

package/src/modules/primitives/command/deactivateCategory.test.ts

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb, testNotFound, testPermissionDenied } from "../../testing/index";
+import { createMockDb, testNotFound } from "../../testing/index";
 import { type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { CategoryHasActiveUnitsError, UoMCategoryNotFoundError } from "../lib/errors";
+import { CategoryHasActiveUnitsError, UomCategoryNotFoundError } from "../lib/errors.generated";
 import { baseUoMCategory, baseUnitKg } from "../testing/fixtures";
-import { deactivateCategory } from "./deactivateCategory";
+import { run } from "./deactivateCategory";
 
 describe("deactivateCategory", () => {
   const ctx: CommandContext = {
@@ -19,12 +19,7 @@ describe("deactivateCategory", () => {
 
   it(
     "throws when category doesn't exist",
-    testNotFound(
-      deactivateCategory,
-      { categoryId: "nonexistent-category" },
-      ctx,
-      UoMCategoryNotFoundError,
-    ),
+    testNotFound(run, { categoryId: "nonexistent-category" }, ctx, UomCategoryNotFoundError),
   );
 
   it("throws when category has active units", async () => {
@@ -33,15 +28,18 @@ describe("deactivateCategory", () => {
       .mockReturnValueOnce(baseUoMCategory) // Category lookup
       .mockReturnValueOnce([baseUnitKg]); // Active units check
 
-    await expect(
-      deactivateCategory(
-        db,
-        {
-          categoryId: baseUoMCategory.id,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CategoryHasActiveUnitsError);
+    const result = await run(
+      db,
+      {
+        categoryId: baseUoMCategory.id,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CategoryHasActiveUnitsError);
+    }
   });
 
   // Idempotent case needs multi-mock setup, kept inline
@@ -51,7 +49,7 @@ describe("deactivateCategory", () => {
       .mockReturnValueOnce(inactiveCategory) // Category lookup
       .mockReturnValueOnce([]); // No active units
 
-    const result = await deactivateCategory(
+    const result = await run(
       db,
       {
         categoryId: inactiveCategory.id,
@@ -59,7 +57,10 @@ describe("deactivateCategory", () => {
       ctx,
     );
 
-    expect(result.category).toEqual(inactiveCategory);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.uoMCategory).toEqual(inactiveCategory);
+    }
     expect(spies.update).not.toHaveBeenCalled();
   });
 
@@ -77,7 +78,7 @@ describe("deactivateCategory", () => {
       .mockReturnValueOnce([]); // No active units
     spies.update.mockReturnValue(deactivatedCategory);
 
-    const result = await deactivateCategory(
+    const result = await run(
       db,
       {
         categoryId: baseUoMCategory.id,
@@ -85,13 +86,11 @@ describe("deactivateCategory", () => {
       ctx,
     );
 
-    expect(result.category.isActive).toBe(false);
-    expect(result.category.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.uoMCategory.isActive).toBe(false);
+      expect(result.value.uoMCategory.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it(
-    "throws when permission is missing",
-    testPermissionDenied(deactivateCategory, { categoryId: "cat-1" }),
-  );
 });

package/src/modules/primitives/command/deactivateCategory.ts

@@ -1,7 +1,7 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { CategoryHasActiveUnitsError, UoMCategoryNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { CategoryHasActiveUnitsError, UomCategoryNotFoundError } from "../lib/errors.generated";
+import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 export interface DeactivateCategoryInput {
   categoryId: string;
@@ -13,50 +13,43 @@ export interface DeactivateCategoryInput {
  * Disables a UoM category from being used in new product assignments
  * while preserving historical data. All units must be deactivated first.
  */
-export const deactivateCategory = defineCommand(
-  permissions.deactivateCategory,
-  async (db: DB, input: DeactivateCategoryInput) => {
-    // 1. Find category by ID
-    const category = await db
-      .selectFrom("UoMCategory")
-      .selectAll()
-      .where("id", "=", input.categoryId)
-      .executeTakeFirst();
-
-    // 2. If not found, throw error
-    if (!category) {
-      throw new UoMCategoryNotFoundError(input.categoryId);
-    }
-
-    // 3. Check for active units in this category
-    const activeUnits = await db
-      .selectFrom("Unit")
-      .selectAll()
-      .where("categoryId", "=", input.categoryId)
-      .where("isActive", "=", true)
-      .execute();
-
-    if (activeUnits.length > 0) {
-      throw new CategoryHasActiveUnitsError(input.categoryId);
-    }
-
-    // 4. If already inactive, return category (idempotent)
-    if (!category.isActive) {
-      return { category };
-    }
-
-    // 5. Update isActive = false
-    const updatedCategory = await db
-      .updateTable("UoMCategory")
-      .set({
-        isActive: false,
-        updatedAt: new Date(),
-      })
-      .where("id", "=", input.categoryId)
-      .returningAll()
-      .executeTakeFirst();
-
-    // 6. Return updated category
-    return { category: updatedCategory! };
-  },
-);
+export async function run(db: DB, input: DeactivateCategoryInput, ctx: CommandContext) {
+  // 1. Find category by ID
+  const { uoMCategory } = await getUoMCategory(db, { id: input.categoryId }, ctx);
+
+  // 2. If not found, throw error
+  if (!uoMCategory) {
+    return err(new UomCategoryNotFoundError(input.categoryId));
+  }
+
+  // Active units must be deactivated before their category
+  const activeUnits = await db
+    .selectFrom("Unit")
+    .selectAll()
+    .where("categoryId", "=", input.categoryId)
+    .where("isActive", "=", true)
+    .execute();
+
+  if (activeUnits.length > 0) {
+    return err(new CategoryHasActiveUnitsError(input.categoryId));
+  }
+
+  // 4. If already inactive, return category (idempotent)
+  if (!uoMCategory.isActive) {
+    return ok({ uoMCategory });
+  }
+
+  // 5. Update isActive = false
+  const updatedCategory = await db
+    .updateTable("UoMCategory")
+    .set({
+      isActive: false,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.categoryId)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 6. Return updated category
+  return ok({ uoMCategory: updatedCategory! });
+}

package/src/modules/primitives/command/deactivateCurrency.generated.ts

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