@tailor-platform/erp-kit 0.1.2 → 0.2.1

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,16 +18,27 @@ 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 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";

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,16 +1,17 @@
-import { definePermissions } from "../shared/internal";
+// @generated — do not edit
+import { definePermissions } from "../../shared/internal";
 
 export const { permissions, own, all } = definePermissions("primitives", [
-  "createCategory",
   "activateCategory",
-  "deactivateCategory",
-  "setReferenceUnit",
-  "createUnit",
+  "activateCurrency",
   "activateUnit",
-  "deactivateUnit",
+  "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 "./query/convertQuantity";
-import { activateCurrency } from "./command/activateCurrency";
-import { deactivateCurrency } from "./command/deactivateCurrency";
-import { setBaseCurrency } from "./command/setBaseCurrency";
-import { convertAmount } from "./query/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,27 +45,32 @@ 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,
-      activateCurrency,
-      deactivateCurrency,
-      setBaseCurrency,
+      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,
       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/query/convertAmount.test.ts

@@ -6,7 +6,7 @@ import {
   CurrencyNotFoundError,
   ExchangeRateNotFoundError,
   InactiveCurrencyError,
-} from "../lib/errors";
+} from "../lib/errors.generated";
 import {
   baseCurrencyEUR,
   baseCurrencyJPY,
@@ -16,7 +16,7 @@ import {
   inactiveCurrency,
   olderExchangeRateUSDtoEUR,
 } from "../testing/fixtures";
-import { convertAmount } from "./convertAmount";
+import { convertAmount } from "./convertAmount.generated";
 
 describe("convertAmount", () => {
   const ctx: QueryContext = { actorId: "test-actor" };

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

@@ -1,10 +1,11 @@
-import { defineQuery, type ReadonlyDB } from "../../shared/internal";
+import type { ReadonlyDB, QueryContext } from "../../shared/internal";
 import type { DB } from "../generated/kysely-tailordb";
 import {
   CurrencyNotFoundError,
   ExchangeRateNotFoundError,
   InactiveCurrencyError,
-} from "../lib/errors";
+} from "../lib/errors.generated";
+import { getCurrency } from "./getCurrency.generated";
 
 export interface ConvertAmountInput {
   amount: number;
@@ -14,38 +15,40 @@ export interface ConvertAmountInput {
 }
 
 /**
- * Function: convertAmount
- *
  * 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 const convertAmount = defineQuery(async (db: ReadonlyDB<DB>, input: ConvertAmountInput) => {
-  // 1. Validate source currency exists
-  const sourceCurrency = await db
-    .selectFrom("Currency")
-    .selectAll()
-    .where("code", "=", input.sourceCurrencyCode)
-    .executeTakeFirst();
+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);
   }
 
-  // 2. Validate target currency exists
-  const targetCurrency = await db
-    .selectFrom("Currency")
-    .selectAll()
-    .where("code", "=", input.targetCurrencyCode)
-    .executeTakeFirst();
+  // Validate target currency exists
+  const { currency: targetCurrency } = await getCurrency(
+    db,
+    {
+      code: input.targetCurrencyCode,
+    },
+    ctx,
+  );
 
   if (!targetCurrency) {
     throw new CurrencyNotFoundError(input.targetCurrencyCode);
   }
 
-  // 3. Validate both currencies are active
+  // Validate both currencies are active
   if (!sourceCurrency.isActive) {
     throw new InactiveCurrencyError(input.sourceCurrencyCode);
   }
@@ -54,7 +57,7 @@ export const convertAmount = defineQuery(async (db: ReadonlyDB<DB>, input: Conve
     throw new InactiveCurrencyError(input.targetCurrencyCode);
   }
 
-  // 4. Same currency - return original amount
+  // Same currency - return original amount
   if (sourceCurrency.id === targetCurrency.id) {
     return {
       convertedAmount: input.amount,
@@ -65,7 +68,7 @@ export const convertAmount = defineQuery(async (db: ReadonlyDB<DB>, input: Conve
     };
   }
 
-  // 5. Find direct exchange rate (most recent on or before conversion date)
+  // Find direct exchange rate (most recent on or before conversion date)
   const conversionDate = new Date(input.conversionDate);
   const directRate = await db
     .selectFrom("ExchangeRate")
@@ -83,7 +86,7 @@ export const convertAmount = defineQuery(async (db: ReadonlyDB<DB>, input: Conve
     exchangeRate = directRate.rate;
     exchangeRateRecord = directRate;
   } else {
-    // 6. Try inverse rate
+    // Try inverse rate
     const inverseRate = await db
       .selectFrom("ExchangeRate")
       .selectAll()
@@ -95,9 +98,7 @@ export const convertAmount = defineQuery(async (db: ReadonlyDB<DB>, input: Conve
 
     if (!inverseRate) {
       throw new ExchangeRateNotFoundError(
-        input.sourceCurrencyCode,
-        input.targetCurrencyCode,
-        input.conversionDate,
+        `${input.sourceCurrencyCode} to ${input.targetCurrencyCode} on ${input.conversionDate}`,
       );
     }
 
@@ -105,10 +106,8 @@ export const convertAmount = defineQuery(async (db: ReadonlyDB<DB>, input: Conve
     exchangeRateRecord = inverseRate;
   }
 
-  // 7. Calculate converted amount
+  // Calculate converted amount, rounded to target currency's decimal places
   const rawResult = input.amount * exchangeRate;
-
-  // 8. Round to target currency's decimal places
   const roundingFactor = Math.pow(10, targetCurrency.decimalPlaces);
   const convertedAmount = Math.round(rawResult * roundingFactor) / roundingFactor;
 
@@ -119,4 +118,4 @@ export const convertAmount = defineQuery(async (db: ReadonlyDB<DB>, input: Conve
     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/query/convertQuantity.test.ts

@@ -2,7 +2,11 @@ import { describe, expect, it } from "vitest";
 import { createMockDb } from "../../testing/index";
 import { DB } from "../generated/kysely-tailordb";
 import type { QueryContext } from "../../shared/internal";
-import { InactiveUnitError, IncompatibleUnitsError, UnitNotFoundError } from "../lib/errors";
+import {
+  InactiveUnitError,
+  IncompatibleUnitsError,
+  UnitNotFoundError,
+} from "../lib/errors.generated";
 import {
   baseUnitGram,
   baseUnitKg,
@@ -10,7 +14,7 @@ import {
   baseUnitPound,
   inactiveUnit,
 } from "../testing/fixtures";
-import { convertQuantity } from "./convertQuantity";
+import { convertQuantity } from "./convertQuantity.generated";
 
 describe("convertQuantity", () => {
   const ctx: QueryContext = { actorId: "test-actor" };