@tailor-platform/erp-kit 0.1.2 → 0.2.1

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

@@ -1,27 +1,22 @@
 import { describe, expect, it } from "vitest";
-import {
-  createMockDb,
-  testNotFound,
-  testPermissionDenied,
-  testIdempotent,
-} from "../../testing/index";
+import { createMockDb, testNotFound, testIdempotent } from "../../testing/index";
 import { type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { UnitNotFoundError } from "../lib/errors";
+import { UnitNotFoundError } from "../lib/errors.generated";
 import { baseUnitKg, inactiveUnit } from "../testing/fixtures";
-import { activateUnit } from "./activateUnit";
+import { run } from "./activateUnit";
 
 describe("activateUnit", () => {
   const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:activateUnit"] };
 
   it(
     "throws when unit doesn't exist",
-    testNotFound(activateUnit, { unitId: "nonexistent-unit" }, ctx, UnitNotFoundError),
+    testNotFound(run, { unitId: "nonexistent-unit" }, ctx, UnitNotFoundError),
   );
 
   it(
     "returns unit unchanged when already active",
-    testIdempotent(activateUnit, { unitId: baseUnitKg.id }, ctx, baseUnitKg, "unit"),
+    testIdempotent(run, { unitId: baseUnitKg.id }, ctx, baseUnitKg, "unit"),
   );
 
   // Success cases
@@ -36,7 +31,7 @@ describe("activateUnit", () => {
     spies.select.mockReturnValue(inactiveUnit);
     spies.update.mockReturnValue(activatedUnit);
 
-    const result = await activateUnit(
+    const result = await run(
       db,
       {
         unitId: inactiveUnit.id,
@@ -44,10 +39,11 @@ describe("activateUnit", () => {
       ctx,
     );
 
-    expect(result.unit.isActive).toBe(true);
-    expect(result.unit.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.unit.isActive).toBe(true);
+      expect(result.value.unit.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it("throws when permission is missing", testPermissionDenied(activateUnit, { unitId: "unit-1" }));
 });

package/src/modules/primitives/command/activateUnit.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 { UnitNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { UnitNotFoundError } from "../lib/errors.generated";
+import { getUnit } from "../query/getUnit.generated";
 
 export interface ActivateUnitInput {
   unitId: string;
@@ -13,38 +13,31 @@ export interface ActivateUnitInput {
  * Re-enables a previously deactivated unit of measure, making it available
  * for new product assignments and quantity conversions.
  */
-export const activateUnit = defineCommand(
-  permissions.activateUnit,
-  async (db: DB, input: ActivateUnitInput) => {
-    // 1. Find unit by ID
-    const unit = await db
-      .selectFrom("Unit")
-      .selectAll()
-      .where("id", "=", input.unitId)
-      .executeTakeFirst();
+export async function run(db: DB, input: ActivateUnitInput, ctx: CommandContext) {
+  // 1. Find unit by ID
+  const { unit } = await getUnit(db, { id: input.unitId }, ctx);
 
-    // 2. If not found, throw error
-    if (!unit) {
-      throw new UnitNotFoundError(input.unitId);
-    }
+  // 2. If not found, throw error
+  if (!unit) {
+    return err(new UnitNotFoundError(input.unitId));
+  }
 
-    // 3. If already active, return unit (idempotent)
-    if (unit.isActive) {
-      return { unit };
-    }
+  // 3. If already active, return unit (idempotent)
+  if (unit.isActive) {
+    return ok({ unit });
+  }
 
-    // 4. Update isActive = true
-    const updatedUnit = await db
-      .updateTable("Unit")
-      .set({
-        isActive: true,
-        updatedAt: new Date(),
-      })
-      .where("id", "=", input.unitId)
-      .returningAll()
-      .executeTakeFirst();
+  // 4. Update isActive = true
+  const updatedUnit = await db
+    .updateTable("Unit")
+    .set({
+      isActive: true,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.unitId)
+    .returningAll()
+    .executeTakeFirst();
 
-    // 5. Return updated unit
-    return { unit: updatedUnit! };
-  },
-);
+  // 5. Return updated unit
+  return ok({ unit: updatedUnit! });
+}

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

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

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

@@ -1,12 +1,10 @@
 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 { DuplicateCategoryNameError } from "../lib/errors";
+import { DuplicateCategoryNameError } from "../lib/errors.generated";
 import { baseUoMCategory, baseUnitKg } from "../testing/fixtures";
-import { makeCreateCategory } from "./createCategory";
-
-const createCategory = makeCreateCategory();
+import { run } from "./createCategory";
 
 describe("createCategory", () => {
   const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:createCategory"] };
@@ -16,20 +14,23 @@ describe("createCategory", () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(baseUoMCategory);
 
-    await expect(
-      createCategory(
-        db,
-        {
-          name: baseUoMCategory.name,
-          referenceUnit: {
-            name: "Kilogram",
-            symbol: "kg",
-            roundingPrecision: 2,
-          },
+    const result = await run(
+      db,
+      {
+        name: baseUoMCategory.name,
+        referenceUnit: {
+          name: "Kilogram",
+          symbol: "kg",
+          roundingPrecision: 2,
         },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(DuplicateCategoryNameError);
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateCategoryNameError);
+    }
   });
 
   // Success cases
@@ -50,7 +51,7 @@ describe("createCategory", () => {
     spies.insert.mockReturnValueOnce(createdCategory).mockReturnValueOnce(createdUnit);
     spies.update.mockReturnValue({ ...createdCategory, referenceUnitId: "new-unit-id" });
 
-    const result = await createCategory(
+    const result = await run(
       db,
       {
         name: "Weight",
@@ -64,29 +65,16 @@ describe("createCategory", () => {
       ctx,
     );
 
-    expect(result.category.name).toBe("Weight");
-    expect(result.category.isActive).toBe(true);
-    expect(result.referenceUnit.conversionFactor).toBe(1.0);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.uoMCategory.name).toBe("Weight");
+      expect(result.value.uoMCategory.isActive).toBe(true);
+      expect(result.value.referenceUnit.conversionFactor).toBe(1.0);
+    }
     expect(spies.insert).toHaveBeenCalled();
   });
 
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      createCategory(
-        db,
-        { name: "Test", referenceUnit: { name: "Unit", symbol: "u", roundingPrecision: 2 } },
-        denied,
-      ),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
-  });
-
   it("passes custom fields through to insert", async () => {
-    const createCategoryWithFields = makeCreateCategory<
-      { priority: number },
-      { tolerance: number }
-    >();
     const { db, spies } = createMockDb<DB>();
     const createdCategory = {
       ...baseUoMCategory,
@@ -103,7 +91,7 @@ describe("createCategory", () => {
     spies.insert.mockReturnValueOnce(createdCategory).mockReturnValueOnce(createdUnit);
     spies.update.mockReturnValue({ ...createdCategory, referenceUnitId: "new-unit-id" });
 
-    await createCategoryWithFields(
+    await run(
       db,
       {
         name: "Weight",

package/src/modules/primitives/command/createCategory.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 { DuplicateCategoryNameError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { DuplicateCategoryNameError } from "../lib/errors.generated";
+import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 interface CreateCategoryInput<UnitCF extends Record<string, unknown>> {
   name: string;
@@ -19,71 +19,62 @@ interface CreateCategoryInput<UnitCF extends Record<string, unknown>> {
  * Establishes a new unit of measure category that groups related units.
  * Creates the category with a reference unit that has conversion factor 1.0.
  */
-export function makeCreateCategory<
+export async function run<
   CatCF extends Record<string, unknown>,
   UnitCF extends Record<string, unknown>,
->() {
-  return defineCommand(
-    permissions.createCategory,
-    async (db: DB, input: CreateCategoryInput<UnitCF> & CatCF) => {
-      const { name, description, referenceUnit, ...categoryCustomFields } = input;
-      const { name: unitName, symbol, roundingPrecision, ...unitCustomFields } = referenceUnit;
+>(db: DB, input: CreateCategoryInput<UnitCF> & CatCF, ctx: CommandContext) {
+  const { name, description, referenceUnit, ...categoryCustomFields } = input;
+  const { name: unitName, symbol, roundingPrecision, ...unitCustomFields } = referenceUnit;
 
-      // 1. Check if category name already exists
-      const existingCategory = await db
-        .selectFrom("UoMCategory")
-        .selectAll()
-        .where("name", "=", name)
-        .executeTakeFirst();
+  // 1. Check if category name already exists
+  const { uoMCategory: existingCategory } = await getUoMCategory(db, { name }, ctx);
 
-      if (existingCategory) {
-        throw new DuplicateCategoryNameError(name);
-      }
+  if (existingCategory) {
+    return err(new DuplicateCategoryNameError(name));
+  }
 
-      // 2. Create category without reference unit first
-      const category = await db
-        .insertInto("UoMCategory")
-        .values({
-          ...(categoryCustomFields as Record<string, unknown>),
-          name,
-          description: description ?? null,
-          referenceUnitId: null,
-          isActive: true,
-          createdAt: new Date(),
-          updatedAt: null,
-        })
-        .returningAll()
-        .executeTakeFirst();
+  // 2. Create category without reference unit first
+  const category = await db
+    .insertInto("UoMCategory")
+    .values({
+      ...(categoryCustomFields as Record<string, unknown>),
+      name,
+      description: description ?? null,
+      referenceUnitId: null,
+      isActive: true,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-      // 3. Create reference unit with conversion factor 1.0
-      const createdReferenceUnit = await db
-        .insertInto("Unit")
-        .values({
-          ...(unitCustomFields as Record<string, unknown>),
-          name: unitName,
-          symbol,
-          categoryId: category!.id,
-          conversionFactor: 1.0,
-          roundingPrecision,
-          isActive: true,
-          createdAt: new Date(),
-          updatedAt: null,
-        })
-        .returningAll()
-        .executeTakeFirst();
+  // 3. Create reference unit with conversion factor 1.0
+  const createdReferenceUnit = await db
+    .insertInto("Unit")
+    .values({
+      ...(unitCustomFields as Record<string, unknown>),
+      name: unitName,
+      symbol,
+      categoryId: category!.id,
+      conversionFactor: 1.0,
+      roundingPrecision,
+      isActive: true,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-      // 4. Update category with reference unit ID
-      const updatedCategory = await db
-        .updateTable("UoMCategory")
-        .set({
-          referenceUnitId: createdReferenceUnit!.id,
-          updatedAt: new Date(),
-        })
-        .where("id", "=", category!.id)
-        .returningAll()
-        .executeTakeFirst();
+  // 4. Update category with reference unit ID
+  const updatedCategory = await db
+    .updateTable("UoMCategory")
+    .set({
+      referenceUnitId: createdReferenceUnit!.id,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", category!.id)
+    .returningAll()
+    .executeTakeFirst();
 
-      return { category: updatedCategory!, referenceUnit: createdReferenceUnit! };
-    },
-  );
+  return ok({ uoMCategory: updatedCategory!, referenceUnit: createdReferenceUnit! });
 }

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

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

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

@@ -1,16 +1,14 @@
 import { describe, expect, it } from "vitest";
-import { InsufficientPermissionError, type CommandContext } from "../../shared/internal";
+import { type CommandContext } from "../../shared/internal";
 import { createMockDb } from "../../testing/index";
 import { DB } from "../generated/kysely-tailordb";
 import {
   DuplicateCurrencyCodeError,
   InvalidDecimalPlacesError,
-  InvalidISOCodeError,
-} from "../lib/errors";
+  InvalidIsoCodeError,
+} from "../lib/errors.generated";
 import { baseCurrencyUSD } from "../testing/fixtures";
-import { makeCreateCurrency } from "./createCurrency";
-
-const createCurrency = makeCreateCurrency();
+import { run } from "./createCurrency";
 
 describe("createCurrency", () => {
   const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:createCurrency"] };
@@ -19,72 +17,84 @@ describe("createCurrency", () => {
   it("throws when ISO code is invalid format", async () => {
     const { db } = createMockDb<DB>();
 
-    await expect(
-      createCurrency(
-        db,
-        {
-          code: "us", // Should be 3 uppercase letters
-          name: "US Dollar",
-          symbol: "$",
-          decimalPlaces: 2,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InvalidISOCodeError);
+    const result = await run(
+      db,
+      {
+        code: "us", // Should be 3 uppercase letters
+        name: "US Dollar",
+        symbol: "$",
+        decimalPlaces: 2,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidIsoCodeError);
+    }
   });
 
   it("throws when ISO code already exists", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(baseCurrencyUSD);
 
-    await expect(
-      createCurrency(
-        db,
-        {
-          code: "USD",
-          name: "US Dollar",
-          symbol: "$",
-          decimalPlaces: 2,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(DuplicateCurrencyCodeError);
+    const result = await run(
+      db,
+      {
+        code: "USD",
+        name: "US Dollar",
+        symbol: "$",
+        decimalPlaces: 2,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateCurrencyCodeError);
+    }
   });
 
   it("throws when decimal places is negative", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined); // No existing currency
 
-    await expect(
-      createCurrency(
-        db,
-        {
-          code: "XXX",
-          name: "Test Currency",
-          symbol: "X",
-          decimalPlaces: -1,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InvalidDecimalPlacesError);
+    const result = await run(
+      db,
+      {
+        code: "XXX",
+        name: "Test Currency",
+        symbol: "X",
+        decimalPlaces: -1,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidDecimalPlacesError);
+    }
   });
 
   it("throws when decimal places exceeds maximum", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined); // No existing currency
 
-    await expect(
-      createCurrency(
-        db,
-        {
-          code: "XXX",
-          name: "Test Currency",
-          symbol: "X",
-          decimalPlaces: 5,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InvalidDecimalPlacesError);
+    const result = await run(
+      db,
+      {
+        code: "XXX",
+        name: "Test Currency",
+        symbol: "X",
+        decimalPlaces: 5,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidDecimalPlacesError);
+    }
   });
 
   // Success cases
@@ -107,7 +117,7 @@ describe("createCurrency", () => {
       .mockReturnValueOnce(undefined); // No existing currencies (first currency)
     spies.insert.mockReturnValue(createdCurrency);
 
-    const result = await createCurrency(
+    const result = await run(
       db,
       {
         code: "USD",
@@ -118,9 +128,12 @@ describe("createCurrency", () => {
       ctx,
     );
 
-    expect(result.currency.code).toBe("USD");
-    expect(result.currency.isBaseCurrency).toBe(true);
-    expect(result.currency.isActive).toBe(true);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.currency.code).toBe("USD");
+      expect(result.value.currency.isBaseCurrency).toBe(true);
+      expect(result.value.currency.isActive).toBe(true);
+    }
   });
 
   it("creates subsequent currency as non-base", async () => {
@@ -142,7 +155,7 @@ describe("createCurrency", () => {
       .mockReturnValueOnce(baseCurrencyUSD); // Existing currency exists
     spies.insert.mockReturnValue(createdCurrency);
 
-    const result = await createCurrency(
+    const result = await run(
       db,
       {
         code: "EUR",
@@ -153,20 +166,14 @@ describe("createCurrency", () => {
       ctx,
     );
 
-    expect(result.currency.code).toBe("EUR");
-    expect(result.currency.isBaseCurrency).toBe(false);
-  });
-
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      createCurrency(db, { code: "USD", name: "US Dollar", symbol: "$", decimalPlaces: 2 }, denied),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.currency.code).toBe("EUR");
+      expect(result.value.currency.isBaseCurrency).toBe(false);
+    }
   });
 
   it("passes custom fields through to insert", async () => {
-    const createCurrencyWithFields = makeCreateCurrency<{ region: string }>();
     const { db, spies } = createMockDb<DB>();
     const createdCurrency = {
       ...baseCurrencyUSD,
@@ -180,7 +187,7 @@ describe("createCurrency", () => {
       .mockReturnValueOnce(undefined); // No existing currencies
     spies.insert.mockReturnValue(createdCurrency);
 
-    await createCurrencyWithFields(
+    await run(
       db,
       { code: "GBP", name: "British Pound", symbol: "£", decimalPlaces: 2, region: "Europe" },
       ctx,