@tailor-platform/erp-kit 0.2.0 → 0.2.2

package/src/modules/primitives/query/convertAmount.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import { DB } from "../generated/kysely-tailordb";
-import type { QueryContext } from "../../shared/internal";
+import type { QueryContext } from "../../../shared";
 import {
   CurrencyNotFoundError,
   ExchangeRateNotFoundError,
@@ -22,85 +22,97 @@ describe("convertAmount", () => {
   const ctx: QueryContext = { actorId: "test-actor" };
 
   // Error cases first
-  it("throws when source currency doesn't exist", async () => {
+  it("returns error when source currency doesn't exist", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined);
 
-    await expect(
-      convertAmount(
-        db,
-        {
-          amount: 100,
-          sourceCurrencyCode: "XYZ",
-          targetCurrencyCode: baseCurrencyEUR.code,
-          conversionDate: "2024-01-20",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CurrencyNotFoundError);
+    const result = await convertAmount(
+      db,
+      {
+        amount: 100,
+        sourceCurrencyCode: "XYZ",
+        targetCurrencyCode: baseCurrencyEUR.code,
+        conversionDate: "2024-01-20",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
   });
 
-  it("throws when target currency doesn't exist", async () => {
+  it("returns error when target currency doesn't exist", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseCurrencyUSD) // source exists
       .mockReturnValueOnce(undefined); // target doesn't exist
 
-    await expect(
-      convertAmount(
-        db,
-        {
-          amount: 100,
-          sourceCurrencyCode: baseCurrencyUSD.code,
-          targetCurrencyCode: "XYZ",
-          conversionDate: "2024-01-20",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CurrencyNotFoundError);
+    const result = await convertAmount(
+      db,
+      {
+        amount: 100,
+        sourceCurrencyCode: baseCurrencyUSD.code,
+        targetCurrencyCode: "XYZ",
+        conversionDate: "2024-01-20",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
   });
 
-  it("throws when source currency is inactive", async () => {
+  it("returns error when source currency is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(inactiveCurrency) // source inactive
       .mockReturnValueOnce(baseCurrencyEUR); // target exists
 
-    await expect(
-      convertAmount(
-        db,
-        {
-          amount: 100,
-          sourceCurrencyCode: inactiveCurrency.code,
-          targetCurrencyCode: baseCurrencyEUR.code,
-          conversionDate: "2024-01-20",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InactiveCurrencyError);
+    const result = await convertAmount(
+      db,
+      {
+        amount: 100,
+        sourceCurrencyCode: inactiveCurrency.code,
+        targetCurrencyCode: baseCurrencyEUR.code,
+        conversionDate: "2024-01-20",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InactiveCurrencyError);
+    }
   });
 
-  it("throws when target currency is inactive", async () => {
+  it("returns error when target currency is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseCurrencyUSD) // source exists
       .mockReturnValueOnce(inactiveCurrency); // target inactive
 
-    await expect(
-      convertAmount(
-        db,
-        {
-          amount: 100,
-          sourceCurrencyCode: baseCurrencyUSD.code,
-          targetCurrencyCode: inactiveCurrency.code,
-          conversionDate: "2024-01-20",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InactiveCurrencyError);
+    const result = await convertAmount(
+      db,
+      {
+        amount: 100,
+        sourceCurrencyCode: baseCurrencyUSD.code,
+        targetCurrencyCode: inactiveCurrency.code,
+        conversionDate: "2024-01-20",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InactiveCurrencyError);
+    }
   });
 
-  it("throws when no exchange rate exists for the currency pair", async () => {
+  it("returns error when no exchange rate exists for the currency pair", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseCurrencyUSD) // source exists
@@ -108,18 +120,21 @@ describe("convertAmount", () => {
       .mockReturnValueOnce(undefined) // no direct rate
       .mockReturnValueOnce(undefined); // no inverse rate
 
-    await expect(
-      convertAmount(
-        db,
-        {
-          amount: 100,
-          sourceCurrencyCode: baseCurrencyUSD.code,
-          targetCurrencyCode: baseCurrencyEUR.code,
-          conversionDate: "2024-01-20",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(ExchangeRateNotFoundError);
+    const result = await convertAmount(
+      db,
+      {
+        amount: 100,
+        sourceCurrencyCode: baseCurrencyUSD.code,
+        targetCurrencyCode: baseCurrencyEUR.code,
+        conversionDate: "2024-01-20",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(ExchangeRateNotFoundError);
+    }
   });
 
   // Success cases
@@ -138,8 +153,11 @@ describe("convertAmount", () => {
       ctx,
     );
 
-    expect(result.convertedAmount).toBe(100);
-    expect(result.exchangeRate).toBe(1);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedAmount).toBe(100);
+      expect(result.value.exchangeRate).toBe(1);
+    }
   });
 
   it("converts USD to EUR using direct rate", async () => {
@@ -161,8 +179,11 @@ describe("convertAmount", () => {
       ctx,
     );
 
-    expect(result.convertedAmount).toBe(92);
-    expect(result.exchangeRate).toBe(0.92);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedAmount).toBe(92);
+      expect(result.value.exchangeRate).toBe(0.92);
+    }
   });
 
   it("uses inverse rate when no direct rate exists", async () => {
@@ -185,8 +206,11 @@ describe("convertAmount", () => {
       ctx,
     );
 
-    expect(result.convertedAmount).toBe(108.7);
-    expect(result.exchangeRate).toBeCloseTo(1 / 0.92, 5);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedAmount).toBe(108.7);
+      expect(result.value.exchangeRate).toBeCloseTo(1 / 0.92, 5);
+    }
   });
 
   it("uses most recent rate on or before the conversion date", async () => {
@@ -209,8 +233,11 @@ describe("convertAmount", () => {
       ctx,
     );
 
-    expect(result.convertedAmount).toBe(85);
-    expect(result.exchangeRate).toBe(0.85);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedAmount).toBe(85);
+      expect(result.value.exchangeRate).toBe(0.85);
+    }
   });
 
   it("rounds to target currency decimal places (JPY has 0)", async () => {
@@ -232,7 +259,10 @@ describe("convertAmount", () => {
       ctx,
     );
 
-    expect(result.convertedAmount).toBe(14924);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedAmount).toBe(14924);
+    }
   });
 
   it("handles zero amount correctly", async () => {
@@ -253,6 +283,9 @@ describe("convertAmount", () => {
       ctx,
     );
 
-    expect(result.convertedAmount).toBe(0);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedAmount).toBe(0);
+    }
   });
 });

package/src/modules/primitives/query/convertAmount.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB, QueryContext } from "../../shared/internal";
+import { ok, err, type ReadonlyDB, type QueryContext } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 import {
   CurrencyNotFoundError,
@@ -23,49 +23,53 @@ export interface ConvertAmountInput {
  */
 export async function run(db: ReadonlyDB<DB>, input: ConvertAmountInput, ctx: QueryContext) {
   // Validate source currency exists
-  const { currency: sourceCurrency } = await getCurrency(
-    db,
-    {
-      code: input.sourceCurrencyCode,
-    },
-    ctx,
-  );
+  const { currency: sourceCurrency } = (
+    await getCurrency(
+      db,
+      {
+        code: input.sourceCurrencyCode,
+      },
+      ctx,
+    )
+  ).value;
 
   if (!sourceCurrency) {
-    throw new CurrencyNotFoundError(input.sourceCurrencyCode);
+    return err(new CurrencyNotFoundError(input.sourceCurrencyCode));
   }
 
   // Validate target currency exists
-  const { currency: targetCurrency } = await getCurrency(
-    db,
-    {
-      code: input.targetCurrencyCode,
-    },
-    ctx,
-  );
+  const { currency: targetCurrency } = (
+    await getCurrency(
+      db,
+      {
+        code: input.targetCurrencyCode,
+      },
+      ctx,
+    )
+  ).value;
 
   if (!targetCurrency) {
-    throw new CurrencyNotFoundError(input.targetCurrencyCode);
+    return err(new CurrencyNotFoundError(input.targetCurrencyCode));
   }
 
   // Validate both currencies are active
   if (!sourceCurrency.isActive) {
-    throw new InactiveCurrencyError(input.sourceCurrencyCode);
+    return err(new InactiveCurrencyError(input.sourceCurrencyCode));
   }
 
   if (!targetCurrency.isActive) {
-    throw new InactiveCurrencyError(input.targetCurrencyCode);
+    return err(new InactiveCurrencyError(input.targetCurrencyCode));
   }
 
   // Same currency - return original amount
   if (sourceCurrency.id === targetCurrency.id) {
-    return {
+    return ok({
       convertedAmount: input.amount,
       exchangeRate: 1,
       sourceCurrency,
       targetCurrency,
       exchangeRateRecord: null,
-    };
+    });
   }
 
   // Find direct exchange rate (most recent on or before conversion date)
@@ -79,43 +83,53 @@ export async function run(db: ReadonlyDB<DB>, input: ConvertAmountInput, ctx: Qu
     .orderBy("effectiveDate", "desc")
     .executeTakeFirst();
 
-  let exchangeRate: number;
-  let exchangeRateRecord = null;
-
   if (directRate) {
-    exchangeRate = directRate.rate;
-    exchangeRateRecord = directRate;
-  } else {
-    // Try inverse rate
-    const inverseRate = await db
-      .selectFrom("ExchangeRate")
-      .selectAll()
-      .where("sourceCurrencyId", "=", targetCurrency.id)
-      .where("targetCurrencyId", "=", sourceCurrency.id)
-      .where("effectiveDate", "<=", conversionDate)
-      .orderBy("effectiveDate", "desc")
-      .executeTakeFirst();
-
-    if (!inverseRate) {
-      throw new ExchangeRateNotFoundError(
-        `${input.sourceCurrencyCode} to ${input.targetCurrencyCode} on ${input.conversionDate}`,
-      );
-    }
+    const exchangeRate = directRate.rate;
+    const exchangeRateRecord = directRate;
 
-    exchangeRate = 1 / inverseRate.rate;
-    exchangeRateRecord = inverseRate;
+    const rawResult = input.amount * exchangeRate;
+    const roundingFactor = Math.pow(10, targetCurrency.decimalPlaces);
+    const convertedAmount = Math.round(rawResult * roundingFactor) / roundingFactor;
+
+    return ok({
+      convertedAmount,
+      exchangeRate,
+      sourceCurrency,
+      targetCurrency,
+      exchangeRateRecord,
+    });
   }
 
-  // Calculate converted amount, rounded to target currency's decimal places
+  // Try inverse rate
+  const inverseRate = await db
+    .selectFrom("ExchangeRate")
+    .selectAll()
+    .where("sourceCurrencyId", "=", targetCurrency.id)
+    .where("targetCurrencyId", "=", sourceCurrency.id)
+    .where("effectiveDate", "<=", conversionDate)
+    .orderBy("effectiveDate", "desc")
+    .executeTakeFirst();
+
+  if (!inverseRate) {
+    return err(
+      new ExchangeRateNotFoundError(
+        `${input.sourceCurrencyCode} to ${input.targetCurrencyCode} on ${input.conversionDate}`,
+      ),
+    );
+  }
+
+  const exchangeRate = 1 / inverseRate.rate;
+  const exchangeRateRecord = inverseRate;
+
   const rawResult = input.amount * exchangeRate;
   const roundingFactor = Math.pow(10, targetCurrency.decimalPlaces);
   const convertedAmount = Math.round(rawResult * roundingFactor) / roundingFactor;
 
-  return {
+  return ok({
     convertedAmount,
     exchangeRate,
     sourceCurrency,
     targetCurrency,
     exchangeRateRecord,
-  };
+  });
 }

package/src/modules/primitives/query/convertQuantity.generated.ts

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineQuery } from "../../shared/internal";
+import { defineQuery } from "../../../shared";
 import { run } from "./convertQuantity";
 
 export const convertQuantity = defineQuery(run);

package/src/modules/primitives/query/convertQuantity.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import { DB } from "../generated/kysely-tailordb";
-import type { QueryContext } from "../../shared/internal";
+import type { QueryContext } from "../../../shared";
 import {
   InactiveUnitError,
   IncompatibleUnitsError,
@@ -20,97 +20,112 @@ describe("convertQuantity", () => {
   const ctx: QueryContext = { actorId: "test-actor" };
 
   // Error cases first
-  it("throws when source unit doesn't exist", async () => {
+  it("returns error when source unit doesn't exist", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined);
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: "xyz",
-          targetUnitSymbol: baseUnitGram.symbol,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(UnitNotFoundError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: "xyz",
+        targetUnitSymbol: baseUnitGram.symbol,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnitNotFoundError);
+    }
   });
 
-  it("throws when target unit doesn't exist", async () => {
+  it("returns error when target unit doesn't exist", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseUnitKg) // source unit exists
       .mockReturnValueOnce(undefined); // target unit doesn't exist
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: baseUnitKg.symbol,
-          targetUnitSymbol: "xyz",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(UnitNotFoundError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: baseUnitKg.symbol,
+        targetUnitSymbol: "xyz",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnitNotFoundError);
+    }
   });
 
-  it("throws when source unit is inactive", async () => {
+  it("returns error when source unit is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(inactiveUnit) // source unit inactive
       .mockReturnValueOnce(baseUnitGram); // target unit exists
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: inactiveUnit.symbol,
-          targetUnitSymbol: baseUnitGram.symbol,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InactiveUnitError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: inactiveUnit.symbol,
+        targetUnitSymbol: baseUnitGram.symbol,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InactiveUnitError);
+    }
   });
 
-  it("throws when target unit is inactive", async () => {
+  it("returns error when target unit is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseUnitKg) // source unit exists
       .mockReturnValueOnce(inactiveUnit); // target unit inactive
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: baseUnitKg.symbol,
-          targetUnitSymbol: inactiveUnit.symbol,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InactiveUnitError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: baseUnitKg.symbol,
+        targetUnitSymbol: inactiveUnit.symbol,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InactiveUnitError);
+    }
   });
 
-  it("throws when units belong to different categories", async () => {
+  it("returns error when units belong to different categories", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseUnitKg) // Weight category
       .mockReturnValueOnce(baseUnitLiter); // Volume category
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: baseUnitKg.symbol,
-          targetUnitSymbol: baseUnitLiter.symbol,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(IncompatibleUnitsError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: baseUnitKg.symbol,
+        targetUnitSymbol: baseUnitLiter.symbol,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(IncompatibleUnitsError);
+    }
   });
 
   // Success cases
@@ -128,9 +143,12 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(10);
-    expect(result.sourceUnit).toEqual(baseUnitKg);
-    expect(result.targetUnit).toEqual(baseUnitKg);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(10);
+      expect(result.value.sourceUnit).toEqual(baseUnitKg);
+      expect(result.value.targetUnit).toEqual(baseUnitKg);
+    }
   });
 
   it("converts kg to grams correctly", async () => {
@@ -150,7 +168,10 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(5000); // rounded to 0 decimal places (gram precision)
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(5000); // rounded to 0 decimal places (gram precision)
+    }
   });
 
   it("converts grams to kg correctly", async () => {
@@ -170,7 +191,10 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(2.5); // rounded to 2 decimal places (kg precision)
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(2.5); // rounded to 2 decimal places (kg precision)
+    }
   });
 
   it("converts pounds to kg correctly", async () => {
@@ -190,7 +214,10 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(4.54);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(4.54);
+    }
   });
 
   it("handles zero quantity correctly", async () => {
@@ -207,6 +234,9 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(0);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(0);
+    }
   });
 });