@tailor-platform/erp-kit 0.2.0 → 0.2.2

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

@@ -1,11 +1,10 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   DuplicateCurrencyCodeError,
   InvalidDecimalPlacesError,
   InvalidIsoCodeError,
 } from "../lib/errors.generated";
-import { getCurrency } from "../query/getCurrency.generated";
 
 interface CreateCurrencyInput {
   code: string;
@@ -23,9 +22,8 @@ const ISO_CODE_PATTERN = /^[A-Z]{3}$/;
  * name, and decimal precision. The first currency becomes the base currency.
  */
 export async function run<CF extends Record<string, unknown>>(
-  db: DB,
+  db: Transaction,
   input: CreateCurrencyInput & CF,
-  ctx: CommandContext,
 ) {
   const { code, name, symbol, decimalPlaces, ...customFields } = input;
 
@@ -35,7 +33,12 @@ export async function run<CF extends Record<string, unknown>>(
   }
 
   // 2. Check code uniqueness
-  const { currency: existingCurrency } = await getCurrency(db, { code }, ctx);
+  const existingCurrency = await db
+    .selectFrom("Currency")
+    .selectAll()
+    .where("code", "=", code)
+    .forUpdate()
+    .executeTakeFirst();
 
   if (existingCurrency) {
     return err(new DuplicateCurrencyCodeError(code));

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./createExchangeRate";
 

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

@@ -1,7 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { type CommandContext } from "../../shared/internal";
-import { createMockDb } from "../../testing/index";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   CurrencyNotFoundError,
   InactiveCurrencyError,
@@ -17,26 +16,17 @@ import {
 import { run } from "./createExchangeRate";
 
 describe("createExchangeRate", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["primitives:createExchangeRate"],
-  };
-
   // Error cases
   it("throws when source currency doesn't exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(
-      db,
-      {
-        sourceCurrencyId: "nonexistent-currency",
-        targetCurrencyId: baseCurrencyEUR.id,
-        rate: 0.92,
-        effectiveDate: new Date("2024-01-15"),
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      sourceCurrencyId: "nonexistent-currency",
+      targetCurrencyId: baseCurrencyEUR.id,
+      rate: 0.92,
+      effectiveDate: new Date("2024-01-15"),
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -45,19 +35,15 @@ describe("createExchangeRate", () => {
   });
 
   it("throws when source currency is inactive", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(inactiveCurrency);
 
-    const result = await run(
-      db,
-      {
-        sourceCurrencyId: inactiveCurrency.id,
-        targetCurrencyId: baseCurrencyEUR.id,
-        rate: 0.92,
-        effectiveDate: new Date("2024-01-15"),
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      sourceCurrencyId: inactiveCurrency.id,
+      targetCurrencyId: baseCurrencyEUR.id,
+      rate: 0.92,
+      effectiveDate: new Date("2024-01-15"),
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -66,21 +52,17 @@ describe("createExchangeRate", () => {
   });
 
   it("throws when target currency doesn't exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseCurrencyUSD) // Source exists
       .mockReturnValueOnce(undefined); // Target doesn't exist
 
-    const result = await run(
-      db,
-      {
-        sourceCurrencyId: baseCurrencyUSD.id,
-        targetCurrencyId: "nonexistent-currency",
-        rate: 0.92,
-        effectiveDate: new Date("2024-01-15"),
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      sourceCurrencyId: baseCurrencyUSD.id,
+      targetCurrencyId: "nonexistent-currency",
+      rate: 0.92,
+      effectiveDate: new Date("2024-01-15"),
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -89,21 +71,17 @@ describe("createExchangeRate", () => {
   });
 
   it("throws when target currency is inactive", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseCurrencyUSD) // Source exists and active
       .mockReturnValueOnce(inactiveCurrency); // Target is inactive
 
-    const result = await run(
-      db,
-      {
-        sourceCurrencyId: baseCurrencyUSD.id,
-        targetCurrencyId: inactiveCurrency.id,
-        rate: 0.92,
-        effectiveDate: new Date("2024-01-15"),
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      sourceCurrencyId: baseCurrencyUSD.id,
+      targetCurrencyId: inactiveCurrency.id,
+      rate: 0.92,
+      effectiveDate: new Date("2024-01-15"),
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -112,19 +90,15 @@ describe("createExchangeRate", () => {
   });
 
   it("throws when source and target are the same", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(baseCurrencyUSD);
 
-    const result = await run(
-      db,
-      {
-        sourceCurrencyId: baseCurrencyUSD.id,
-        targetCurrencyId: baseCurrencyUSD.id,
-        rate: 1.0,
-        effectiveDate: new Date("2024-01-15"),
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      sourceCurrencyId: baseCurrencyUSD.id,
+      targetCurrencyId: baseCurrencyUSD.id,
+      rate: 1.0,
+      effectiveDate: new Date("2024-01-15"),
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -133,19 +107,15 @@ describe("createExchangeRate", () => {
   });
 
   it("throws when rate is not positive", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseCurrencyUSD).mockReturnValueOnce(baseCurrencyEUR);
 
-    const result = await run(
-      db,
-      {
-        sourceCurrencyId: baseCurrencyUSD.id,
-        targetCurrencyId: baseCurrencyEUR.id,
-        rate: 0,
-        effectiveDate: new Date("2024-01-15"),
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      sourceCurrencyId: baseCurrencyUSD.id,
+      targetCurrencyId: baseCurrencyEUR.id,
+      rate: 0,
+      effectiveDate: new Date("2024-01-15"),
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -155,7 +125,7 @@ describe("createExchangeRate", () => {
 
   // Success cases
   it("creates exchange rate successfully", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdRate = {
       id: "new-rate-id",
       sourceCurrencyId: baseCurrencyUSD.id,
@@ -169,16 +139,12 @@ describe("createExchangeRate", () => {
     spies.select.mockReturnValueOnce(baseCurrencyUSD).mockReturnValueOnce(baseCurrencyEUR);
     spies.insert.mockReturnValue(createdRate);
 
-    const result = await run(
-      db,
-      {
-        sourceCurrencyId: baseCurrencyUSD.id,
-        targetCurrencyId: baseCurrencyEUR.id,
-        rate: 0.92,
-        effectiveDate: new Date("2024-01-15"),
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      sourceCurrencyId: baseCurrencyUSD.id,
+      targetCurrencyId: baseCurrencyEUR.id,
+      rate: 0.92,
+      effectiveDate: new Date("2024-01-15"),
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -190,7 +156,7 @@ describe("createExchangeRate", () => {
   });
 
   it("passes custom fields through to insert", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdRate = {
       ...baseExchangeRateUSDtoEUR,
       id: "new-rate-id",
@@ -200,17 +166,13 @@ describe("createExchangeRate", () => {
     spies.select.mockReturnValueOnce(baseCurrencyUSD).mockReturnValueOnce(baseCurrencyEUR);
     spies.insert.mockReturnValue(createdRate);
 
-    await run(
-      db,
-      {
-        sourceCurrencyId: baseCurrencyUSD.id,
-        targetCurrencyId: baseCurrencyEUR.id,
-        rate: 0.92,
-        effectiveDate: new Date("2024-01-15"),
-        source: "ECB",
-      },
-      ctx,
-    );
+    await run(db, {
+      sourceCurrencyId: baseCurrencyUSD.id,
+      targetCurrencyId: baseCurrencyEUR.id,
+      rate: 0.92,
+      effectiveDate: new Date("2024-01-15"),
+      source: "ECB",
+    });
 
     expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ source: "ECB" }));
   });

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

@@ -1,12 +1,11 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   CurrencyNotFoundError,
   InactiveCurrencyError,
   InvalidExchangeRateError,
   SameCurrencyPairError,
 } from "../lib/errors.generated";
-import { getCurrency } from "../query/getCurrency.generated";
 
 interface CreateExchangeRateInput {
   sourceCurrencyId: string;
@@ -23,14 +22,17 @@ interface CreateExchangeRateInput {
  * equal one unit of the source currency.
  */
 export async function run<CF extends Record<string, unknown>>(
-  db: DB,
+  db: Transaction,
   input: CreateExchangeRateInput & CF,
-  ctx: CommandContext,
 ) {
   const { sourceCurrencyId, targetCurrencyId, rate, effectiveDate, ...customFields } = input;
 
   // 1. Check source currency exists
-  const { currency: sourceCurrency } = await getCurrency(db, { id: sourceCurrencyId }, ctx);
+  const sourceCurrency = await db
+    .selectFrom("Currency")
+    .selectAll()
+    .where("id", "=", sourceCurrencyId)
+    .executeTakeFirst();
 
   if (!sourceCurrency) {
     return err(new CurrencyNotFoundError(sourceCurrencyId));
@@ -42,7 +44,11 @@ export async function run<CF extends Record<string, unknown>>(
   }
 
   // 3. Check target currency exists
-  const { currency: targetCurrency } = await getCurrency(db, { id: targetCurrencyId }, ctx);
+  const targetCurrency = await db
+    .selectFrom("Currency")
+    .selectAll()
+    .where("id", "=", targetCurrencyId)
+    .executeTakeFirst();
 
   if (!targetCurrency) {
     return err(new CurrencyNotFoundError(targetCurrencyId));

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./createUnit";
 

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

@@ -1,7 +1,6 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   CategoryNotActiveError,
   DuplicateUnitSymbolError,
@@ -13,8 +12,6 @@ import { baseUoMCategory, baseUnitKg } from "../testing/fixtures";
 import { run } from "./createUnit";
 
 describe("createUnit", () => {
-  const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:createUnit"] };
-
   const inactiveCategory = {
     ...baseUoMCategory,
     isActive: false,
@@ -22,20 +19,16 @@ describe("createUnit", () => {
 
   // Error cases
   it("throws when category doesn't exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(
-      db,
-      {
-        categoryId: "nonexistent-category",
-        name: "Ounce",
-        symbol: "oz",
-        conversionFactor: 0.0283495,
-        roundingPrecision: 2,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: "nonexistent-category",
+      name: "Ounce",
+      symbol: "oz",
+      conversionFactor: 0.0283495,
+      roundingPrecision: 2,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -44,20 +37,16 @@ describe("createUnit", () => {
   });
 
   it("throws when category is inactive", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(inactiveCategory);
 
-    const result = await run(
-      db,
-      {
-        categoryId: inactiveCategory.id,
-        name: "Ounce",
-        symbol: "oz",
-        conversionFactor: 0.0283495,
-        roundingPrecision: 2,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: inactiveCategory.id,
+      name: "Ounce",
+      symbol: "oz",
+      conversionFactor: 0.0283495,
+      roundingPrecision: 2,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -66,22 +55,18 @@ describe("createUnit", () => {
   });
 
   it("throws when symbol already exists in category", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseUoMCategory) // Category lookup
       .mockReturnValueOnce(baseUnitKg); // Existing unit with same symbol
 
-    const result = await run(
-      db,
-      {
-        categoryId: baseUoMCategory.id,
-        name: "Kilogram Duplicate",
-        symbol: "kg",
-        conversionFactor: 1.0,
-        roundingPrecision: 2,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: baseUoMCategory.id,
+      name: "Kilogram Duplicate",
+      symbol: "kg",
+      conversionFactor: 1.0,
+      roundingPrecision: 2,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -90,22 +75,18 @@ describe("createUnit", () => {
   });
 
   it("throws when conversion factor is not positive", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseUoMCategory) // Category lookup
       .mockReturnValueOnce(undefined); // No duplicate symbol
 
-    const result = await run(
-      db,
-      {
-        categoryId: baseUoMCategory.id,
-        name: "Invalid Unit",
-        symbol: "inv",
-        conversionFactor: 0,
-        roundingPrecision: 2,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: baseUoMCategory.id,
+      name: "Invalid Unit",
+      symbol: "inv",
+      conversionFactor: 0,
+      roundingPrecision: 2,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -114,22 +95,18 @@ describe("createUnit", () => {
   });
 
   it("throws when rounding precision is negative", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseUoMCategory) // Category lookup
       .mockReturnValueOnce(undefined); // No duplicate symbol
 
-    const result = await run(
-      db,
-      {
-        categoryId: baseUoMCategory.id,
-        name: "Invalid Unit",
-        symbol: "inv",
-        conversionFactor: 1.0,
-        roundingPrecision: -1,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: baseUoMCategory.id,
+      name: "Invalid Unit",
+      symbol: "inv",
+      conversionFactor: 1.0,
+      roundingPrecision: -1,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -139,7 +116,7 @@ describe("createUnit", () => {
 
   // Success cases
   it("creates unit successfully", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdUnit = {
       id: "new-unit-id",
       name: "Ounce",
@@ -157,17 +134,13 @@ describe("createUnit", () => {
       .mockReturnValueOnce(undefined); // No duplicate symbol
     spies.insert.mockReturnValue(createdUnit);
 
-    const result = await run(
-      db,
-      {
-        categoryId: baseUoMCategory.id,
-        name: "Ounce",
-        symbol: "oz",
-        conversionFactor: 0.0283495,
-        roundingPrecision: 2,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: baseUoMCategory.id,
+      name: "Ounce",
+      symbol: "oz",
+      conversionFactor: 0.0283495,
+      roundingPrecision: 2,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -179,7 +152,7 @@ describe("createUnit", () => {
   });
 
   it("passes custom fields through to insert", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdUnit = {
       ...baseUnitKg,
       id: "new-unit-id",
@@ -193,18 +166,14 @@ describe("createUnit", () => {
       .mockReturnValueOnce(undefined); // No duplicate symbol
     spies.insert.mockReturnValue(createdUnit);
 
-    await run(
-      db,
-      {
-        categoryId: baseUoMCategory.id,
-        name: "Ounce",
-        symbol: "oz",
-        conversionFactor: 0.0283495,
-        roundingPrecision: 2,
-        displayOrder: 5,
-      },
-      ctx,
-    );
+    await run(db, {
+      categoryId: baseUoMCategory.id,
+      name: "Ounce",
+      symbol: "oz",
+      conversionFactor: 0.0283495,
+      roundingPrecision: 2,
+      displayOrder: 5,
+    });
 
     expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ displayOrder: 5 }));
   });

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

@@ -1,5 +1,5 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   CategoryNotActiveError,
   DuplicateUnitSymbolError,
@@ -7,7 +7,6 @@ import {
   InvalidRoundingPrecisionError,
   UomCategoryNotFoundError,
 } from "../lib/errors.generated";
-import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 interface CreateUnitInput {
   categoryId: string;
@@ -24,14 +23,17 @@ interface CreateUnitInput {
  * display name, and conversion factor relative to the reference unit.
  */
 export async function run<CF extends Record<string, unknown>>(
-  db: DB,
+  db: Transaction,
   input: CreateUnitInput & CF,
-  ctx: CommandContext,
 ) {
   const { categoryId, name, symbol, conversionFactor, roundingPrecision, ...customFields } = input;
 
   // 1. Check category exists
-  const { uoMCategory } = await getUoMCategory(db, { id: categoryId }, ctx);
+  const uoMCategory = await db
+    .selectFrom("UoMCategory")
+    .selectAll()
+    .where("id", "=", categoryId)
+    .executeTakeFirst();
 
   if (!uoMCategory) {
     return err(new UomCategoryNotFoundError(categoryId));
@@ -48,6 +50,7 @@ export async function run<CF extends Record<string, unknown>>(
     .selectAll()
     .where("categoryId", "=", categoryId)
     .where("symbol", "=", symbol)
+    .forUpdate()
     .executeTakeFirst();
 
   if (existingUnit) {

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./deactivateCategory";