@tailor-platform/erp-kit 0.1.1 → 0.2.0

package/src/modules/primitives/docs/queries/ListUnitsByCategory.md

@@ -0,0 +1,26 @@
+# ListUnitsByCategory
+
+## Overview
+
+ListUnitsByCategory retrieves all units belonging to a specific UoM category. Used to find related units within a category and to validate category constraints such as ensuring a category has units before deactivation.
+
+## Business Rules
+
+- Returns all units with the matching categoryId
+- Returns empty array if no units match
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive categoryId] --> B[SELECT from Unit where categoryId = input]
+    B --> C[Return units array]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- None

package/src/modules/primitives/generated/kysely-tailordb.ts

@@ -1,19 +1,15 @@
 import {
-  type ColumnType,
-  Kysely,
-  type KyselyConfig,
-  type Transaction as KyselyTransaction,
-  type Insertable as KyselyInsertable,
-  type Selectable as KyselySelectable,
-  type Updateable as KyselyUpdateable,
-} from "kysely";
-import { TailordbDialect } from "@tailor-platform/function-kysely-tailordb";
-
-type Timestamp = ColumnType<Date, Date | string, Date | string>;
-type Generated<T> =
-  T extends ColumnType<infer S, infer I, infer U>
-    ? ColumnType<S, I | undefined, U>
-    : ColumnType<T, T | undefined, T>;
+  createGetDB,
+  type Generated,
+  type Timestamp,
+  type NamespaceDB,
+  type NamespaceInsertable,
+  type NamespaceSelectable,
+  type NamespaceTable,
+  type NamespaceTableName,
+  type NamespaceTransaction,
+  type NamespaceUpdateable,
+} from "@tailor-platform/sdk/kysely";
 
 export interface Namespace {
   "main-db": {
@@ -27,7 +23,7 @@ export interface Namespace {
       isActive: boolean;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
+    }
 
     ExchangeRate: {
       id: Generated<string>;
@@ -37,7 +33,7 @@ export interface Namespace {
       effectiveDate: Timestamp;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
+    }
 
     Unit: {
       id: Generated<string>;
@@ -49,7 +45,7 @@ export interface Namespace {
       isActive: boolean;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
+    }
 
     UoMCategory: {
       id: Generated<string>;
@@ -59,37 +55,20 @@ export interface Namespace {
       isActive: boolean;
       createdAt: Generated<Timestamp>;
       updatedAt: Timestamp | null;
-    };
-  };
+    }
+  }
 }
 
-export function getDB<const N extends keyof Namespace>(
-  namespace: N,
-  kyselyConfig?: Omit<KyselyConfig, "dialect">,
-): Kysely<Namespace[N]> {
-  const client = new tailordb.Client({ namespace });
-  return new Kysely<Namespace[N]>({
-    dialect: new TailordbDialect(client),
-    ...kyselyConfig,
-  });
-}
+export const getDB = createGetDB<Namespace>();
 
-export type DB<N extends keyof Namespace = keyof Namespace> = ReturnType<typeof getDB<N>>;
+export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;
 
 export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =
-  K extends DB<infer N>
-    ? KyselyTransaction<Namespace[N]>
-    : K extends keyof Namespace
-      ? KyselyTransaction<Namespace[K]>
-      : never;
+  NamespaceTransaction<Namespace, K>;
 
-type TableName = {
-  [N in keyof Namespace]: keyof Namespace[N];
-}[keyof Namespace];
-export type Table<T extends TableName> = {
-  [N in keyof Namespace]: T extends keyof Namespace[N] ? Namespace[N][T] : never;
-}[keyof Namespace];
+type TableName = NamespaceTableName<Namespace>;
+export type Table<T extends TableName> = NamespaceTable<Namespace, T>;
 
-export type Insertable<T extends keyof Namespace[keyof Namespace]> = KyselyInsertable<Table<T>>;
-export type Selectable<T extends keyof Namespace[keyof Namespace]> = KyselySelectable<Table<T>>;
-export type Updateable<T extends keyof Namespace[keyof Namespace]> = KyselyUpdateable<Table<T>>;
+export type Insertable<T extends TableName> = NamespaceInsertable<Namespace, T>;
+export type Selectable<T extends TableName> = NamespaceSelectable<Namespace, T>;
+export type Updateable<T extends TableName> = NamespaceUpdateable<Namespace, T>;

package/src/modules/primitives/index.ts

@@ -1,9 +1,9 @@
 export { defineModule } from "./module";
-export { permissions, own, all } from "./permissions";
+export { permissions, own, all } from "./lib/permissions.generated";
 
 // errors
 export {
-  UoMCategoryNotFoundError,
+  UomCategoryNotFoundError,
   UnitNotFoundError,
   IncompatibleUnitsError,
   InactiveUnitError,
@@ -18,23 +18,34 @@ export {
   DuplicateCategoryNameError,
   CategoryHasActiveUnitsError,
   UnitNotInCategoryError,
-  InvalidISOCodeError,
+  InvalidIsoCodeError,
   DuplicateCurrencyCodeError,
   InvalidDecimalPlacesError,
   CannotDeactivateBaseCurrencyError,
   CannotSetInactiveAsBaseCurrencyError,
   SameCurrencyPairError,
   InvalidExchangeRateError,
-} from "./lib/errors";
+} 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 ConvertQuantityInput } from "./command/convertQuantity";
+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 "./command/convertAmount";
+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

@@ -0,0 +1,112 @@
+// @generated — do not edit
+import { createDomainError } from "../../shared/internal";
+
+export const UomCategoryNotFoundError = createDomainError(
+  "UomCategoryNotFoundError", "UOM_CATEGORY_NOT_FOUND",
+  (identifier: string) => `Specified category ID does not exist: ${identifier}`,
+);
+
+export const CurrencyNotFoundError = createDomainError(
+  "CurrencyNotFoundError", "CURRENCY_NOT_FOUND",
+  (identifier: string) => `Specified currency ID does not exist: ${identifier}`,
+);
+
+export const UnitNotFoundError = createDomainError(
+  "UnitNotFoundError", "UNIT_NOT_FOUND",
+  (identifier: string) => `Specified unit ID does not exist: ${identifier}`,
+);
+
+export const DuplicateCategoryNameError = createDomainError(
+  "DuplicateCategoryNameError", "DUPLICATE_CATEGORY_NAME",
+  (identifier: string) => `Category with same name already exists: ${identifier}`,
+);
+
+export const InvalidIsoCodeError = createDomainError(
+  "InvalidIsoCodeError", "INVALID_ISO_CODE",
+  (identifier: string) => `Code is not exactly 3 uppercase letters: ${identifier}`,
+);
+
+export const DuplicateCurrencyCodeError = createDomainError(
+  "DuplicateCurrencyCodeError", "DUPLICATE_CURRENCY_CODE",
+  (identifier: string) => `Currency with same code already exists: ${identifier}`,
+);
+
+export const InvalidDecimalPlacesError = createDomainError(
+  "InvalidDecimalPlacesError", "INVALID_DECIMAL_PLACES",
+  (identifier: string) => `Value is negative or exceeds maximum (typically 4): ${identifier}`,
+);
+
+export const InactiveCurrencyError = createDomainError(
+  "InactiveCurrencyError", "INACTIVE_CURRENCY",
+  (identifier: string) => `Source or target currency is inactive: ${identifier}`,
+);
+
+export const SameCurrencyPairError = createDomainError(
+  "SameCurrencyPairError", "SAME_CURRENCY_PAIR",
+  (identifier: string) => `Source and target currencies are the same: ${identifier}`,
+);
+
+export const InvalidExchangeRateError = createDomainError(
+  "InvalidExchangeRateError", "INVALID_EXCHANGE_RATE",
+  (identifier: string) => `Rate is zero, negative, or not a valid number: ${identifier}`,
+);
+
+export const CategoryNotActiveError = createDomainError(
+  "CategoryNotActiveError", "CATEGORY_NOT_ACTIVE",
+  (identifier: string) => `Category is inactive: ${identifier}`,
+);
+
+export const DuplicateUnitSymbolError = createDomainError(
+  "DuplicateUnitSymbolError", "DUPLICATE_UNIT_SYMBOL",
+  (identifier: string) => `Unit with same symbol already exists in category: ${identifier}`,
+);
+
+export const InvalidConversionFactorError = createDomainError(
+  "InvalidConversionFactorError", "INVALID_CONVERSION_FACTOR",
+  (identifier: string) => `Factor is zero, negative, or not a valid number: ${identifier}`,
+);
+
+export const InvalidRoundingPrecisionError = createDomainError(
+  "InvalidRoundingPrecisionError", "INVALID_ROUNDING_PRECISION",
+  (identifier: string) => `Precision is negative: ${identifier}`,
+);
+
+export const CategoryHasActiveUnitsError = createDomainError(
+  "CategoryHasActiveUnitsError", "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",
+  (identifier: string) => `Attempting to deactivate the base currency, must change base currency first: ${identifier}`,
+);
+
+export const CannotDeactivateReferenceUnitError = createDomainError(
+  "CannotDeactivateReferenceUnitError", "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",
+  (identifier: string) => `Target currency is not in Active status, must be activated first: ${identifier}`,
+);
+
+export const UnitNotInCategoryError = createDomainError(
+  "UnitNotInCategoryError", "UNIT_NOT_IN_CATEGORY",
+  (identifier: string) => `Unit belongs to a different category than specified: ${identifier}`,
+);
+
+export const ExchangeRateNotFoundError = createDomainError(
+  "ExchangeRateNotFoundError", "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",
+  (identifier: string) => `Source and target units belong to different categories: ${identifier}`,
+);
+
+export const InactiveUnitError = createDomainError(
+  "InactiveUnitError", "INACTIVE_UNIT",
+  (identifier: string) => `Either source or target unit is inactive: ${identifier}`,
+);

package/src/modules/primitives/{permissions.ts → lib/permissions.generated.ts}

@@ -1,18 +1,17 @@
-import { definePermissions } from "../shared/internal";
+// @generated — do not edit
+import { definePermissions } from "../../shared/internal";
 
 export const { permissions, own, all } = definePermissions("primitives", [
-  "convertQuantity",
-  "createCategory",
   "activateCategory",
-  "deactivateCategory",
-  "setReferenceUnit",
-  "createUnit",
+  "activateCurrency",
   "activateUnit",
-  "deactivateUnit",
-  "convertAmount",
+  "createCategory",
   "createCurrency",
-  "activateCurrency",
+  "createExchangeRate",
+  "createUnit",
+  "deactivateCategory",
   "deactivateCurrency",
+  "deactivateUnit",
   "setBaseCurrency",
-  "createExchangeRate",
+  "setReferenceUnit",
 ] as const);

package/src/modules/primitives/module.ts

@@ -1,19 +1,24 @@
 import { type TailorAnyDBField } from "@tailor-platform/sdk";
 import { type EmptyFields, type FieldsToInsertable } from "../shared/internal";
-import { makeCreateCategory } from "./command/createCategory";
-import { makeCreateCurrency } from "./command/createCurrency";
-import { makeCreateUnit } from "./command/createUnit";
-import { makeCreateExchangeRate } from "./command/createExchangeRate";
-import { activateCategory } from "./command/activateCategory";
-import { deactivateCategory } from "./command/deactivateCategory";
-import { activateUnit } from "./command/activateUnit";
-import { deactivateUnit } from "./command/deactivateUnit";
-import { setReferenceUnit } from "./command/setReferenceUnit";
-import { convertQuantity } from "./command/convertQuantity";
-import { activateCurrency } from "./command/activateCurrency";
-import { deactivateCurrency } from "./command/deactivateCurrency";
-import { setBaseCurrency } from "./command/setBaseCurrency";
-import { convertAmount } from "./command/convertAmount";
+import { createCategory } from "./command/createCategory.generated";
+import { createCurrency } from "./command/createCurrency.generated";
+import { createUnit } from "./command/createUnit.generated";
+import { createExchangeRate } from "./command/createExchangeRate.generated";
+import { activateCategory } from "./command/activateCategory.generated";
+import { deactivateCategory } from "./command/deactivateCategory.generated";
+import { activateUnit } from "./command/activateUnit.generated";
+import { deactivateUnit } from "./command/deactivateUnit.generated";
+import { setReferenceUnit } from "./command/setReferenceUnit.generated";
+import { convertQuantity } from "./query/convertQuantity.generated";
+import { getUnit } from "./query/getUnit.generated";
+import { getCurrency } from "./query/getCurrency.generated";
+import { getUoMCategory } from "./query/getUoMCategory.generated";
+import { getBaseCurrency } from "./query/getBaseCurrency.generated";
+import { listUnitsByCategory } from "./query/listUnitsByCategory.generated";
+import { activateCurrency } from "./command/activateCurrency.generated";
+import { deactivateCurrency } from "./command/deactivateCurrency.generated";
+import { setBaseCurrency } from "./command/setBaseCurrency.generated";
+import { convertAmount } from "./query/convertAmount.generated";
 import { createUoMCategoryType, CreateUoMCategoryTypeParams } from "./db/uomCategory";
 import { createUnitType, CreateUnitTypeParams } from "./db/unit";
 import { createCurrencyType, CreateCurrencyTypeParams } from "./db/currency";
@@ -40,26 +45,33 @@ export const defineModule = <
   params: DefineModuleParams<CatF, UnitF, CurF, ERF>,
 ) => {
   const uomCategory = createUoMCategoryType(params.uomCategory ?? {});
-  const unit = createUnitType(params.unit ?? {});
+  const unit = createUnitType({ ...params.unit, uomCategoryType: uomCategory });
   const currency = createCurrencyType(params.currency ?? {});
   const exchangeRate = createExchangeRateType(params.exchangeRate ?? {});
 
   return {
     db: { uomCategory, unit, currency, exchangeRate },
     commands: {
-      createCategory: makeCreateCategory<FieldsToInsertable<CatF>, FieldsToInsertable<UnitF>>(),
-      createCurrency: makeCreateCurrency<FieldsToInsertable<CurF>>(),
-      createUnit: makeCreateUnit<FieldsToInsertable<UnitF>>(),
-      createExchangeRate: makeCreateExchangeRate<FieldsToInsertable<ERF>>(),
-      activateCategory,
-      deactivateCategory,
-      activateUnit,
-      deactivateUnit,
-      setReferenceUnit,
+      createCategory: createCategory<FieldsToInsertable<CatF>, FieldsToInsertable<UnitF>>(),
+      createCurrency: createCurrency<FieldsToInsertable<CurF>>(),
+      createUnit: createUnit<FieldsToInsertable<UnitF>>(),
+      createExchangeRate: createExchangeRate<FieldsToInsertable<ERF>>(),
+      activateCategory: activateCategory(),
+      deactivateCategory: deactivateCategory(),
+      activateUnit: activateUnit(),
+      deactivateUnit: deactivateUnit(),
+      setReferenceUnit: setReferenceUnit(),
+      activateCurrency: activateCurrency(),
+      deactivateCurrency: deactivateCurrency(),
+      setBaseCurrency: setBaseCurrency(),
+    },
+    queries: {
+      getUnit,
+      getCurrency,
+      getUoMCategory,
+      getBaseCurrency,
+      listUnitsByCategory,
       convertQuantity,
-      activateCurrency,
-      deactivateCurrency,
-      setBaseCurrency,
       convertAmount,
     },
   };

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

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

package/src/modules/primitives/{command → query}/convertAmount.test.ts

@@ -1,12 +1,12 @@
 import { describe, expect, it } from "vitest";
-import { InsufficientPermissionError, type CommandContext } from "../../shared/internal";
 import { createMockDb } from "../../testing/index";
 import { DB } from "../generated/kysely-tailordb";
+import type { QueryContext } from "../../shared/internal";
 import {
   CurrencyNotFoundError,
   ExchangeRateNotFoundError,
   InactiveCurrencyError,
-} from "../lib/errors";
+} from "../lib/errors.generated";
 import {
   baseCurrencyEUR,
   baseCurrencyJPY,
@@ -16,10 +16,10 @@ import {
   inactiveCurrency,
   olderExchangeRateUSDtoEUR,
 } from "../testing/fixtures";
-import { convertAmount } from "./convertAmount";
+import { convertAmount } from "./convertAmount.generated";
 
 describe("convertAmount", () => {
-  const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:convertAmount"] };
+  const ctx: QueryContext = { actorId: "test-actor" };
 
   // Error cases first
   it("throws when source currency doesn't exist", async () => {
@@ -255,21 +255,4 @@ describe("convertAmount", () => {
 
     expect(result.convertedAmount).toBe(0);
   });
-
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      convertAmount(
-        db,
-        {
-          amount: 100,
-          sourceCurrencyCode: "USD",
-          targetCurrencyCode: "EUR",
-          conversionDate: "2024-01-15",
-        },
-        denied,
-      ),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
-  });
 });

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

@@ -0,0 +1,121 @@
+import type { ReadonlyDB, QueryContext } from "../../shared/internal";
+import type { DB } from "../generated/kysely-tailordb";
+import {
+  CurrencyNotFoundError,
+  ExchangeRateNotFoundError,
+  InactiveCurrencyError,
+} from "../lib/errors.generated";
+import { getCurrency } from "./getCurrency.generated";
+
+export interface ConvertAmountInput {
+  amount: number;
+  sourceCurrencyCode: string;
+  targetCurrencyCode: string;
+  conversionDate: string;
+}
+
+/**
+ * Converts a monetary amount from one currency to another using the applicable
+ * exchange rate for a given date. Currencies are identified by their ISO 4217
+ * code (e.g., "USD", "EUR", "JPY"). The function looks up the most recent exchange
+ * rate on or before the specified date. If no direct rate exists, it calculates
+ * the inverse rate. Result is rounded to the target currency's decimal precision.
+ */
+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,
+  );
+
+  if (!sourceCurrency) {
+    throw new CurrencyNotFoundError(input.sourceCurrencyCode);
+  }
+
+  // Validate target currency exists
+  const { currency: targetCurrency } = await getCurrency(
+    db,
+    {
+      code: input.targetCurrencyCode,
+    },
+    ctx,
+  );
+
+  if (!targetCurrency) {
+    throw new CurrencyNotFoundError(input.targetCurrencyCode);
+  }
+
+  // Validate both currencies are active
+  if (!sourceCurrency.isActive) {
+    throw new InactiveCurrencyError(input.sourceCurrencyCode);
+  }
+
+  if (!targetCurrency.isActive) {
+    throw new InactiveCurrencyError(input.targetCurrencyCode);
+  }
+
+  // Same currency - return original amount
+  if (sourceCurrency.id === targetCurrency.id) {
+    return {
+      convertedAmount: input.amount,
+      exchangeRate: 1,
+      sourceCurrency,
+      targetCurrency,
+      exchangeRateRecord: null,
+    };
+  }
+
+  // Find direct exchange rate (most recent on or before conversion date)
+  const conversionDate = new Date(input.conversionDate);
+  const directRate = await db
+    .selectFrom("ExchangeRate")
+    .selectAll()
+    .where("sourceCurrencyId", "=", sourceCurrency.id)
+    .where("targetCurrencyId", "=", targetCurrency.id)
+    .where("effectiveDate", "<=", conversionDate)
+    .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}`,
+      );
+    }
+
+    exchangeRate = 1 / inverseRate.rate;
+    exchangeRateRecord = inverseRate;
+  }
+
+  // Calculate converted amount, rounded to target currency's decimal places
+  const rawResult = input.amount * exchangeRate;
+  const roundingFactor = Math.pow(10, targetCurrency.decimalPlaces);
+  const convertedAmount = Math.round(rawResult * roundingFactor) / roundingFactor;
+
+  return {
+    convertedAmount,
+    exchangeRate,
+    sourceCurrency,
+    targetCurrency,
+    exchangeRateRecord,
+  };
+}

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

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

package/src/modules/primitives/{command → query}/convertQuantity.test.ts

@@ -1,8 +1,12 @@
 import { describe, expect, it } from "vitest";
 import { createMockDb } from "../../testing/index";
-import { InsufficientPermissionError, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { InactiveUnitError, IncompatibleUnitsError, UnitNotFoundError } from "../lib/errors";
+import type { QueryContext } from "../../shared/internal";
+import {
+  InactiveUnitError,
+  IncompatibleUnitsError,
+  UnitNotFoundError,
+} from "../lib/errors.generated";
 import {
   baseUnitGram,
   baseUnitKg,
@@ -10,13 +14,10 @@ import {
   baseUnitPound,
   inactiveUnit,
 } from "../testing/fixtures";
-import { convertQuantity } from "./convertQuantity";
+import { convertQuantity } from "./convertQuantity.generated";
 
 describe("convertQuantity", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["primitives:convertQuantity"],
-  };
+  const ctx: QueryContext = { actorId: "test-actor" };
 
   // Error cases first
   it("throws when source unit doesn't exist", async () => {
@@ -208,12 +209,4 @@ describe("convertQuantity", () => {
 
     expect(result.convertedQuantity).toBe(0);
   });
-
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      convertQuantity(db, { quantity: 1, sourceUnitSymbol: "kg", targetUnitSymbol: "g" }, denied),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
-  });
 });