@tailor-platform/erp-kit 0.1.2 → 0.2.0

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

@@ -1,15 +1,10 @@
 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 { CannotDeactivateBaseCurrencyError, CurrencyNotFoundError } from "../lib/errors";
+import { CannotDeactivateBaseCurrencyError, CurrencyNotFoundError } from "../lib/errors.generated";
 import { baseCurrencyEUR, baseCurrencyUSD, inactiveCurrency } from "../testing/fixtures";
-import { deactivateCurrency } from "./deactivateCurrency";
+import { run } from "./deactivateCurrency";
 
 describe("deactivateCurrency", () => {
   const ctx: CommandContext = {
@@ -19,38 +14,30 @@ describe("deactivateCurrency", () => {
 
   it(
     "throws when currency doesn't exist",
-    testNotFound(
-      deactivateCurrency,
-      { currencyId: "nonexistent-currency" },
-      ctx,
-      CurrencyNotFoundError,
-    ),
+    testNotFound(run, { currencyId: "nonexistent-currency" }, ctx, CurrencyNotFoundError),
   );
 
   it("throws when attempting to deactivate base currency", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(baseCurrencyUSD); // USD is base currency
 
-    await expect(
-      deactivateCurrency(
-        db,
-        {
-          currencyId: baseCurrencyUSD.id,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CannotDeactivateBaseCurrencyError);
+    const result = await run(
+      db,
+      {
+        currencyId: baseCurrencyUSD.id,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CannotDeactivateBaseCurrencyError);
+    }
   });
 
   it(
     "returns currency unchanged when already inactive",
-    testIdempotent(
-      deactivateCurrency,
-      { currencyId: inactiveCurrency.id },
-      ctx,
-      inactiveCurrency,
-      "currency",
-    ),
+    testIdempotent(run, { currencyId: inactiveCurrency.id }, ctx, inactiveCurrency, "currency"),
   );
 
   // Success cases
@@ -65,7 +52,7 @@ describe("deactivateCurrency", () => {
     spies.select.mockReturnValue(baseCurrencyEUR); // EUR is not base currency
     spies.update.mockReturnValue(deactivatedCurrency);
 
-    const result = await deactivateCurrency(
+    const result = await run(
       db,
       {
         currencyId: baseCurrencyEUR.id,
@@ -73,13 +60,11 @@ describe("deactivateCurrency", () => {
       ctx,
     );
 
-    expect(result.currency.isActive).toBe(false);
-    expect(result.currency.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.currency.isActive).toBe(false);
+      expect(result.value.currency.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it(
-    "throws when permission is missing",
-    testPermissionDenied(deactivateCurrency, { currencyId: "cur-1" }),
-  );
 });

package/src/modules/primitives/command/deactivateCurrency.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 { CannotDeactivateBaseCurrencyError, CurrencyNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { CannotDeactivateBaseCurrencyError, CurrencyNotFoundError } from "../lib/errors.generated";
+import { getCurrency } from "../query/getCurrency.generated";
 
 export interface DeactivateCurrencyInput {
   currencyId: string;
@@ -13,43 +13,36 @@ export interface DeactivateCurrencyInput {
  * Disables a currency from being used in new transactions while preserving
  * historical data. Base currency cannot be deactivated.
  */
-export const deactivateCurrency = defineCommand(
-  permissions.deactivateCurrency,
-  async (db: DB, input: DeactivateCurrencyInput) => {
-    // 1. Find currency by ID
-    const currency = await db
-      .selectFrom("Currency")
-      .selectAll()
-      .where("id", "=", input.currencyId)
-      .executeTakeFirst();
+export async function run(db: DB, input: DeactivateCurrencyInput, ctx: CommandContext) {
+  // 1. Find currency by ID
+  const { currency } = await getCurrency(db, { id: input.currencyId }, ctx);
 
-    // 2. If not found, throw error
-    if (!currency) {
-      throw new CurrencyNotFoundError(input.currencyId);
-    }
+  // 2. If not found, throw error
+  if (!currency) {
+    return err(new CurrencyNotFoundError(input.currencyId));
+  }
 
-    // 3. Check if base currency
-    if (currency.isBaseCurrency) {
-      throw new CannotDeactivateBaseCurrencyError(input.currencyId);
-    }
+  // 3. Check if base currency
+  if (currency.isBaseCurrency) {
+    return err(new CannotDeactivateBaseCurrencyError(input.currencyId));
+  }
 
-    // 4. If already inactive, return currency (idempotent)
-    if (!currency.isActive) {
-      return { currency };
-    }
+  // 4. If already inactive, return currency (idempotent)
+  if (!currency.isActive) {
+    return ok({ currency });
+  }
 
-    // 5. Update isActive = false
-    const updatedCurrency = await db
-      .updateTable("Currency")
-      .set({
-        isActive: false,
-        updatedAt: new Date(),
-      })
-      .where("id", "=", input.currencyId)
-      .returningAll()
-      .executeTakeFirst();
+  // 5. Update isActive = false
+  const updatedCurrency = await db
+    .updateTable("Currency")
+    .set({
+      isActive: false,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.currencyId)
+    .returningAll()
+    .executeTakeFirst();
 
-    // 6. Return updated currency
-    return { currency: updatedCurrency! };
-  },
-);
+  // 6. Return updated currency
+  return ok({ currency: updatedCurrency! });
+}

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

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

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

@@ -1,32 +1,35 @@
 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 { CannotDeactivateReferenceUnitError, UnitNotFoundError } from "../lib/errors";
+import { CannotDeactivateReferenceUnitError, UnitNotFoundError } from "../lib/errors.generated";
 import { baseUnitKg, baseUnitGram, baseUoMCategory, inactiveUnit } from "../testing/fixtures";
-import { deactivateUnit } from "./deactivateUnit";
+import { run } from "./deactivateUnit";
 
 describe("deactivateUnit", () => {
   const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:deactivateUnit"] };
 
   it(
     "throws when unit doesn't exist",
-    testNotFound(deactivateUnit, { unitId: "nonexistent-unit" }, ctx, UnitNotFoundError),
+    testNotFound(run, { unitId: "nonexistent-unit" }, ctx, UnitNotFoundError),
   );
 
   it("throws when attempting to deactivate reference unit", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValueOnce(baseUnitKg).mockReturnValueOnce(baseUoMCategory);
 
-    await expect(
-      deactivateUnit(
-        db,
-        {
-          unitId: baseUnitKg.id,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CannotDeactivateReferenceUnitError);
+    const result = await run(
+      db,
+      {
+        unitId: baseUnitKg.id,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CannotDeactivateReferenceUnitError);
+    }
   });
 
   // Idempotent case needs multi-mock setup, kept inline
@@ -34,7 +37,7 @@ describe("deactivateUnit", () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValueOnce(inactiveUnit).mockReturnValueOnce(baseUoMCategory);
 
-    const result = await deactivateUnit(
+    const result = await run(
       db,
       {
         unitId: inactiveUnit.id,
@@ -42,7 +45,10 @@ describe("deactivateUnit", () => {
       ctx,
     );
 
-    expect(result.unit).toEqual(inactiveUnit);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.unit).toEqual(inactiveUnit);
+    }
     expect(spies.update).not.toHaveBeenCalled();
   });
 
@@ -58,7 +64,7 @@ describe("deactivateUnit", () => {
     spies.select.mockReturnValueOnce(baseUnitGram).mockReturnValueOnce(baseUoMCategory);
     spies.update.mockReturnValue(deactivatedUnit);
 
-    const result = await deactivateUnit(
+    const result = await run(
       db,
       {
         unitId: baseUnitGram.id,
@@ -66,13 +72,11 @@ describe("deactivateUnit", () => {
       ctx,
     );
 
-    expect(result.unit.isActive).toBe(false);
-    expect(result.unit.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.unit.isActive).toBe(false);
+      expect(result.value.unit.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it(
-    "throws when permission is missing",
-    testPermissionDenied(deactivateUnit, { unitId: "unit-1" }),
-  );
 });

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

@@ -1,7 +1,8 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { CannotDeactivateReferenceUnitError, UnitNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { CannotDeactivateReferenceUnitError, UnitNotFoundError } from "../lib/errors.generated";
+import { getUnit } from "../query/getUnit.generated";
+import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 export interface DeactivateUnitInput {
   unitId: string;
@@ -14,49 +15,38 @@ export interface DeactivateUnitInput {
  * and quantity conversions while preserving all historical data.
  * Reference units cannot be deactivated.
  */
-export const deactivateUnit = defineCommand(
-  permissions.deactivateUnit,
-  async (db: DB, input: DeactivateUnitInput) => {
-    // 1. Find unit by ID
-    const unit = await db
-      .selectFrom("Unit")
-      .selectAll()
-      .where("id", "=", input.unitId)
-      .executeTakeFirst();
-
-    // 2. If not found, throw error
-    if (!unit) {
-      throw new UnitNotFoundError(input.unitId);
-    }
-
-    // 3. Check if unit is reference unit for its category
-    const category = await db
-      .selectFrom("UoMCategory")
-      .selectAll()
-      .where("id", "=", unit.categoryId)
-      .executeTakeFirst();
-
-    if (category?.referenceUnitId === unit.id) {
-      throw new CannotDeactivateReferenceUnitError(input.unitId);
-    }
-
-    // 4. If already inactive, return unit (idempotent)
-    if (!unit.isActive) {
-      return { unit };
-    }
-
-    // 5. Update isActive = false
-    const updatedUnit = await db
-      .updateTable("Unit")
-      .set({
-        isActive: false,
-        updatedAt: new Date(),
-      })
-      .where("id", "=", input.unitId)
-      .returningAll()
-      .executeTakeFirst();
-
-    // 6. Return updated unit
-    return { unit: updatedUnit! };
-  },
-);
+export async function run(db: DB, input: DeactivateUnitInput, ctx: CommandContext) {
+  // 1. Find unit by ID
+  const { unit } = await getUnit(db, { id: input.unitId }, ctx);
+
+  // 2. If not found, throw error
+  if (!unit) {
+    return err(new UnitNotFoundError(input.unitId));
+  }
+
+  // 3. Check if unit is reference unit for its category
+  const { uoMCategory } = await getUoMCategory(db, { id: unit.categoryId }, ctx);
+
+  if (uoMCategory?.referenceUnitId === unit.id) {
+    return err(new CannotDeactivateReferenceUnitError(input.unitId));
+  }
+
+  // 4. If already inactive, return unit (idempotent)
+  if (!unit.isActive) {
+    return ok({ unit });
+  }
+
+  // 5. Update isActive = false
+  const updatedUnit = await db
+    .updateTable("Unit")
+    .set({
+      isActive: false,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.unitId)
+    .returningAll()
+    .executeTakeFirst();
+
+  // 6. Return updated unit
+  return ok({ unit: updatedUnit! });
+}

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

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

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

@@ -1,10 +1,13 @@
 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 { CannotSetInactiveAsBaseCurrencyError, CurrencyNotFoundError } from "../lib/errors";
+import {
+  CannotSetInactiveAsBaseCurrencyError,
+  CurrencyNotFoundError,
+} from "../lib/errors.generated";
 import { baseCurrencyEUR, baseCurrencyUSD, inactiveCurrency } from "../testing/fixtures";
-import { setBaseCurrency } from "./setBaseCurrency";
+import { run } from "./setBaseCurrency";
 
 describe("setBaseCurrency", () => {
   const ctx: CommandContext = {
@@ -17,30 +20,36 @@ describe("setBaseCurrency", () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined);
 
-    await expect(
-      setBaseCurrency(
-        db,
-        {
-          currencyId: "nonexistent-currency",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CurrencyNotFoundError);
+    const result = await run(
+      db,
+      {
+        currencyId: "nonexistent-currency",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
   });
 
   it("throws when currency is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(inactiveCurrency);
 
-    await expect(
-      setBaseCurrency(
-        db,
-        {
-          currencyId: inactiveCurrency.id,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CannotSetInactiveAsBaseCurrencyError);
+    const result = await run(
+      db,
+      {
+        currencyId: inactiveCurrency.id,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CannotSetInactiveAsBaseCurrencyError);
+    }
   });
 
   // Idempotent cases
@@ -48,7 +57,7 @@ describe("setBaseCurrency", () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(baseCurrencyUSD); // Already base currency
 
-    const result = await setBaseCurrency(
+    const result = await run(
       db,
       {
         currencyId: baseCurrencyUSD.id,
@@ -56,7 +65,10 @@ describe("setBaseCurrency", () => {
       ctx,
     );
 
-    expect(result.currency).toEqual(baseCurrencyUSD);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.currency).toEqual(baseCurrencyUSD);
+    }
     expect(spies.update).not.toHaveBeenCalled();
   });
 
@@ -76,7 +88,7 @@ describe("setBaseCurrency", () => {
       .mockReturnValueOnce({ ...baseCurrencyUSD, isBaseCurrency: false }) // Remove base from old
       .mockReturnValueOnce(newBaseCurrency); // Set base on new
 
-    const result = await setBaseCurrency(
+    const result = await run(
       db,
       {
         currencyId: baseCurrencyEUR.id,
@@ -84,15 +96,10 @@ describe("setBaseCurrency", () => {
       ctx,
     );
 
-    expect(result.currency.isBaseCurrency).toBe(true);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.currency.isBaseCurrency).toBe(true);
+    }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(setBaseCurrency(db, { currencyId: "cur-1" }, denied)).rejects.toBeInstanceOf(
-      InsufficientPermissionError,
-    );
-  });
 });

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

@@ -1,7 +1,11 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { CannotSetInactiveAsBaseCurrencyError, CurrencyNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import {
+  CannotSetInactiveAsBaseCurrencyError,
+  CurrencyNotFoundError,
+} from "../lib/errors.generated";
+import { getCurrency } from "../query/getCurrency.generated";
+import { getBaseCurrency } from "../query/getBaseCurrency.generated";
 
 export interface SetBaseCurrencyInput {
   currencyId: string;
@@ -13,62 +17,51 @@ export interface SetBaseCurrencyInput {
  * Changes the organization's base currency to a different active currency.
  * The base currency serves as the default for financial reporting.
  */
-export const setBaseCurrency = defineCommand(
-  permissions.setBaseCurrency,
-  async (db: DB, input: SetBaseCurrencyInput) => {
-    // 1. Find currency by ID
-    const currency = await db
-      .selectFrom("Currency")
-      .selectAll()
-      .where("id", "=", input.currencyId)
-      .executeTakeFirst();
-
-    // 2. If not found, throw error
-    if (!currency) {
-      throw new CurrencyNotFoundError(input.currencyId);
-    }
+export async function run(db: DB, input: SetBaseCurrencyInput, ctx: CommandContext) {
+  // 1. Find currency by ID
+  const { currency } = await getCurrency(db, { id: input.currencyId }, ctx);
 
-    // 3. Check if currency is active
-    if (!currency.isActive) {
-      throw new CannotSetInactiveAsBaseCurrencyError(input.currencyId);
-    }
+  // 2. If not found, throw error
+  if (!currency) {
+    return err(new CurrencyNotFoundError(input.currencyId));
+  }
 
-    // 4. If already base currency, return (idempotent)
-    if (currency.isBaseCurrency) {
-      return { currency };
-    }
+  // 3. Check if currency is active
+  if (!currency.isActive) {
+    return err(new CannotSetInactiveAsBaseCurrencyError(input.currencyId));
+  }
 
-    // 5. Find current base currency
-    const currentBase = await db
-      .selectFrom("Currency")
-      .selectAll()
-      .where("isBaseCurrency", "=", true)
-      .executeTakeFirst();
+  // 4. If already base currency, return (idempotent)
+  if (currency.isBaseCurrency) {
+    return ok({ currency });
+  }
 
-    // 6. Remove base flag from current base
-    if (currentBase) {
-      await db
-        .updateTable("Currency")
-        .set({
-          isBaseCurrency: false,
-          updatedAt: new Date(),
-        })
-        .where("id", "=", currentBase.id)
-        .returningAll()
-        .executeTakeFirst();
-    }
+  // 5. Find current base currency
+  const { currency: currentBase } = await getBaseCurrency(db, undefined, ctx);
 
-    // 7. Set base flag on target currency
-    const updatedCurrency = await db
+  // 6. Remove base flag from current base
+  if (currentBase) {
+    await db
       .updateTable("Currency")
       .set({
-        isBaseCurrency: true,
+        isBaseCurrency: false,
         updatedAt: new Date(),
       })
-      .where("id", "=", input.currencyId)
+      .where("id", "=", currentBase.id)
       .returningAll()
       .executeTakeFirst();
+  }
 
-    return { currency: updatedCurrency! };
-  },
-);
+  // 7. Set base flag on target currency
+  const updatedCurrency = await db
+    .updateTable("Currency")
+    .set({
+      isBaseCurrency: true,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.currencyId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ currency: updatedCurrency! });
+}

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

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