@tailor-platform/erp-kit 0.2.1 → 0.3.0

package/src/modules/primitives/index.ts

@@ -1,51 +1,2 @@
 export { defineModule } from "./module";
 export { permissions, own, all } from "./lib/permissions.generated";
-
-// errors
-export {
-  UomCategoryNotFoundError,
-  UnitNotFoundError,
-  IncompatibleUnitsError,
-  InactiveUnitError,
-  CurrencyNotFoundError,
-  InactiveCurrencyError,
-  ExchangeRateNotFoundError,
-  CannotDeactivateReferenceUnitError,
-  CategoryNotActiveError,
-  DuplicateUnitSymbolError,
-  InvalidConversionFactorError,
-  InvalidRoundingPrecisionError,
-  DuplicateCategoryNameError,
-  CategoryHasActiveUnitsError,
-  UnitNotInCategoryError,
-  InvalidIsoCodeError,
-  DuplicateCurrencyCodeError,
-  InvalidDecimalPlacesError,
-  CannotDeactivateBaseCurrencyError,
-  CannotSetInactiveAsBaseCurrencyError,
-  SameCurrencyPairError,
-  InvalidExchangeRateError,
-} from "./lib/errors.generated";
-
-// queries
-export { getUnit } from "./query/getUnit.generated";
-export { getCurrency } from "./query/getCurrency.generated";
-export { getUoMCategory } from "./query/getUoMCategory.generated";
-export { getBaseCurrency } from "./query/getBaseCurrency.generated";
-export { listUnitsByCategory } from "./query/listUnitsByCategory.generated";
-
-// input types
-export { type GetUnitInput } from "./query/getUnit";
-export { type GetCurrencyInput } from "./query/getCurrency";
-export { type GetUoMCategoryInput } from "./query/getUoMCategory";
-export { type ListUnitsByCategoryInput } from "./query/listUnitsByCategory";
-export { type ConvertQuantityInput } from "./query/convertQuantity";
-export { type ActivateCategoryInput } from "./command/activateCategory";
-export { type DeactivateCategoryInput } from "./command/deactivateCategory";
-export { type SetReferenceUnitInput } from "./command/setReferenceUnit";
-export { type ActivateUnitInput } from "./command/activateUnit";
-export { type DeactivateUnitInput } from "./command/deactivateUnit";
-export { type ConvertAmountInput } from "./query/convertAmount";
-export { type ActivateCurrencyInput } from "./command/activateCurrency";
-export { type DeactivateCurrencyInput } from "./command/deactivateCurrency";
-export { type SetBaseCurrencyInput } from "./command/setBaseCurrency";

package/src/modules/primitives/lib/errors.generated.ts

@@ -1,112 +1,112 @@
 // @generated — do not edit
-import { createDomainError } from "../../shared/internal";
+import { createDomainError } from "../../../shared";
 
 export const UomCategoryNotFoundError = createDomainError(
-  "UomCategoryNotFoundError", "UOM_CATEGORY_NOT_FOUND",
+  "UomCategoryNotFoundError", "PRIMITIVES_UOM_CATEGORY_NOT_FOUND",
   (identifier: string) => `Specified category ID does not exist: ${identifier}`,
 );
 
 export const CurrencyNotFoundError = createDomainError(
-  "CurrencyNotFoundError", "CURRENCY_NOT_FOUND",
+  "CurrencyNotFoundError", "PRIMITIVES_CURRENCY_NOT_FOUND",
   (identifier: string) => `Specified currency ID does not exist: ${identifier}`,
 );
 
 export const UnitNotFoundError = createDomainError(
-  "UnitNotFoundError", "UNIT_NOT_FOUND",
+  "UnitNotFoundError", "PRIMITIVES_UNIT_NOT_FOUND",
   (identifier: string) => `Specified unit ID does not exist: ${identifier}`,
 );
 
 export const DuplicateCategoryNameError = createDomainError(
-  "DuplicateCategoryNameError", "DUPLICATE_CATEGORY_NAME",
+  "DuplicateCategoryNameError", "PRIMITIVES_DUPLICATE_CATEGORY_NAME",
   (identifier: string) => `Category with same name already exists: ${identifier}`,
 );
 
 export const InvalidIsoCodeError = createDomainError(
-  "InvalidIsoCodeError", "INVALID_ISO_CODE",
+  "InvalidIsoCodeError", "PRIMITIVES_INVALID_ISO_CODE",
   (identifier: string) => `Code is not exactly 3 uppercase letters: ${identifier}`,
 );
 
 export const DuplicateCurrencyCodeError = createDomainError(
-  "DuplicateCurrencyCodeError", "DUPLICATE_CURRENCY_CODE",
+  "DuplicateCurrencyCodeError", "PRIMITIVES_DUPLICATE_CURRENCY_CODE",
   (identifier: string) => `Currency with same code already exists: ${identifier}`,
 );
 
 export const InvalidDecimalPlacesError = createDomainError(
-  "InvalidDecimalPlacesError", "INVALID_DECIMAL_PLACES",
+  "InvalidDecimalPlacesError", "PRIMITIVES_INVALID_DECIMAL_PLACES",
   (identifier: string) => `Value is negative or exceeds maximum (typically 4): ${identifier}`,
 );
 
 export const InactiveCurrencyError = createDomainError(
-  "InactiveCurrencyError", "INACTIVE_CURRENCY",
+  "InactiveCurrencyError", "PRIMITIVES_INACTIVE_CURRENCY",
   (identifier: string) => `Source or target currency is inactive: ${identifier}`,
 );
 
 export const SameCurrencyPairError = createDomainError(
-  "SameCurrencyPairError", "SAME_CURRENCY_PAIR",
+  "SameCurrencyPairError", "PRIMITIVES_SAME_CURRENCY_PAIR",
   (identifier: string) => `Source and target currencies are the same: ${identifier}`,
 );
 
 export const InvalidExchangeRateError = createDomainError(
-  "InvalidExchangeRateError", "INVALID_EXCHANGE_RATE",
+  "InvalidExchangeRateError", "PRIMITIVES_INVALID_EXCHANGE_RATE",
   (identifier: string) => `Rate is zero, negative, or not a valid number: ${identifier}`,
 );
 
 export const CategoryNotActiveError = createDomainError(
-  "CategoryNotActiveError", "CATEGORY_NOT_ACTIVE",
+  "CategoryNotActiveError", "PRIMITIVES_CATEGORY_NOT_ACTIVE",
   (identifier: string) => `Category is inactive: ${identifier}`,
 );
 
 export const DuplicateUnitSymbolError = createDomainError(
-  "DuplicateUnitSymbolError", "DUPLICATE_UNIT_SYMBOL",
+  "DuplicateUnitSymbolError", "PRIMITIVES_DUPLICATE_UNIT_SYMBOL",
   (identifier: string) => `Unit with same symbol already exists in category: ${identifier}`,
 );
 
 export const InvalidConversionFactorError = createDomainError(
-  "InvalidConversionFactorError", "INVALID_CONVERSION_FACTOR",
+  "InvalidConversionFactorError", "PRIMITIVES_INVALID_CONVERSION_FACTOR",
   (identifier: string) => `Factor is zero, negative, or not a valid number: ${identifier}`,
 );
 
 export const InvalidRoundingPrecisionError = createDomainError(
-  "InvalidRoundingPrecisionError", "INVALID_ROUNDING_PRECISION",
+  "InvalidRoundingPrecisionError", "PRIMITIVES_INVALID_ROUNDING_PRECISION",
   (identifier: string) => `Precision is negative: ${identifier}`,
 );
 
 export const CategoryHasActiveUnitsError = createDomainError(
-  "CategoryHasActiveUnitsError", "CATEGORY_HAS_ACTIVE_UNITS",
+  "CategoryHasActiveUnitsError", "PRIMITIVES_CATEGORY_HAS_ACTIVE_UNITS",
   (identifier: string) => `Category still contains active units that must be deactivated first: ${identifier}`,
 );
 
 export const CannotDeactivateBaseCurrencyError = createDomainError(
-  "CannotDeactivateBaseCurrencyError", "CANNOT_DEACTIVATE_BASE_CURRENCY",
+  "CannotDeactivateBaseCurrencyError", "PRIMITIVES_CANNOT_DEACTIVATE_BASE_CURRENCY",
   (identifier: string) => `Attempting to deactivate the base currency, must change base currency first: ${identifier}`,
 );
 
 export const CannotDeactivateReferenceUnitError = createDomainError(
-  "CannotDeactivateReferenceUnitError", "CANNOT_DEACTIVATE_REFERENCE_UNIT",
+  "CannotDeactivateReferenceUnitError", "PRIMITIVES_CANNOT_DEACTIVATE_REFERENCE_UNIT",
   (identifier: string) => `Attempting to deactivate the category's reference unit, must change reference unit first: ${identifier}`,
 );
 
 export const CannotSetInactiveAsBaseCurrencyError = createDomainError(
-  "CannotSetInactiveAsBaseCurrencyError", "CANNOT_SET_INACTIVE_AS_BASE_CURRENCY",
+  "CannotSetInactiveAsBaseCurrencyError", "PRIMITIVES_CANNOT_SET_INACTIVE_AS_BASE_CURRENCY",
   (identifier: string) => `Target currency is not in Active status, must be activated first: ${identifier}`,
 );
 
 export const UnitNotInCategoryError = createDomainError(
-  "UnitNotInCategoryError", "UNIT_NOT_IN_CATEGORY",
+  "UnitNotInCategoryError", "PRIMITIVES_UNIT_NOT_IN_CATEGORY",
   (identifier: string) => `Unit belongs to a different category than specified: ${identifier}`,
 );
 
 export const ExchangeRateNotFoundError = createDomainError(
-  "ExchangeRateNotFoundError", "EXCHANGE_RATE_NOT_FOUND",
+  "ExchangeRateNotFoundError", "PRIMITIVES_EXCHANGE_RATE_NOT_FOUND",
   (identifier: string) => `No rate found for the currency pair on or before the specified date: ${identifier}`,
 );
 
 export const IncompatibleUnitsError = createDomainError(
-  "IncompatibleUnitsError", "INCOMPATIBLE_UNITS",
+  "IncompatibleUnitsError", "PRIMITIVES_INCOMPATIBLE_UNITS",
   (identifier: string) => `Source and target units belong to different categories: ${identifier}`,
 );
 
 export const InactiveUnitError = createDomainError(
-  "InactiveUnitError", "INACTIVE_UNIT",
+  "InactiveUnitError", "PRIMITIVES_INACTIVE_UNIT",
   (identifier: string) => `Either source or target unit is inactive: ${identifier}`,
 );

package/src/modules/primitives/lib/permissions.generated.ts

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { definePermissions } from "../../shared/internal";
+import { definePermissions } from "../../../shared";
 
 export const { permissions, own, all } = definePermissions("primitives", [
   "activateCategory",

package/src/modules/primitives/lib/types.ts

@@ -1,4 +1,4 @@
-import type { InferSchema, Selectable, Insertable, Updateable } from "../../shared/internal";
+import type { InferSchema, Selectable, Insertable, Updateable } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export type Schema = InferSchema<DB>;

package/src/modules/primitives/module.ts

@@ -1,5 +1,5 @@
 import { type TailorAnyDBField } from "@tailor-platform/sdk";
-import { type EmptyFields, type FieldsToInsertable } from "../shared/internal";
+import { type EmptyFields, type FieldsToInsertable } from "../../shared";
 import { createCategory } from "./command/createCategory.generated";
 import { createCurrency } from "./command/createCurrency.generated";
 import { createUnit } from "./command/createUnit.generated";

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

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

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);