@tailor-platform/erp-kit 0.2.1 → 0.3.0

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

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

@@ -1,17 +1,11 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb, testNotFound } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb, testNotFound } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import { CategoryHasActiveUnitsError, UomCategoryNotFoundError } from "../lib/errors.generated";
 import { baseUoMCategory, baseUnitKg } from "../testing/fixtures";
 import { run } from "./deactivateCategory";
 
 describe("deactivateCategory", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["primitives:deactivateCategory"],
-  };
-
   const inactiveCategory = {
     ...baseUoMCategory,
     isActive: false,
@@ -19,22 +13,18 @@ describe("deactivateCategory", () => {
 
   it(
     "throws when category doesn't exist",
-    testNotFound(run, { categoryId: "nonexistent-category" }, ctx, UomCategoryNotFoundError),
+    testNotFound(run, { categoryId: "nonexistent-category" }, UomCategoryNotFoundError),
   );
 
   it("throws when category has active units", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseUoMCategory) // Category lookup
       .mockReturnValueOnce([baseUnitKg]); // Active units check
 
-    const result = await run(
-      db,
-      {
-        categoryId: baseUoMCategory.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: baseUoMCategory.id,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -44,18 +34,14 @@ describe("deactivateCategory", () => {
 
   // Idempotent case needs multi-mock setup, kept inline
   it("returns category unchanged when already inactive", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(inactiveCategory) // Category lookup
       .mockReturnValueOnce([]); // No active units
 
-    const result = await run(
-      db,
-      {
-        categoryId: inactiveCategory.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: inactiveCategory.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -66,7 +52,7 @@ describe("deactivateCategory", () => {
 
   // Success cases
   it("deactivates active category with no active units", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const deactivatedCategory = {
       ...baseUoMCategory,
       isActive: false,
@@ -78,13 +64,9 @@ describe("deactivateCategory", () => {
       .mockReturnValueOnce([]); // No active units
     spies.update.mockReturnValue(deactivatedCategory);
 
-    const result = await run(
-      db,
-      {
-        categoryId: baseUoMCategory.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      categoryId: baseUoMCategory.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {

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

@@ -1,7 +1,6 @@
-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 { CategoryHasActiveUnitsError, UomCategoryNotFoundError } from "../lib/errors.generated";
-import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 export interface DeactivateCategoryInput {
   categoryId: string;
@@ -13,9 +12,14 @@ export interface DeactivateCategoryInput {
  * Disables a UoM category from being used in new product assignments
  * while preserving historical data. All units must be deactivated first.
  */
-export async function run(db: DB, input: DeactivateCategoryInput, ctx: CommandContext) {
+export async function run(db: Transaction, input: DeactivateCategoryInput) {
   // 1. Find category by ID
-  const { uoMCategory } = await getUoMCategory(db, { id: input.categoryId }, ctx);
+  const uoMCategory = await db
+    .selectFrom("UoMCategory")
+    .selectAll()
+    .where("id", "=", input.categoryId)
+    .forUpdate()
+    .executeTakeFirst();
 
   // 2. If not found, throw error
   if (!uoMCategory) {

package/src/modules/primitives/command/deactivateCurrency.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 "./deactivateCurrency";
 

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

@@ -1,33 +1,23 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb, testNotFound, testIdempotent } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb, testNotFound, testIdempotent } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import { CannotDeactivateBaseCurrencyError, CurrencyNotFoundError } from "../lib/errors.generated";
 import { baseCurrencyEUR, baseCurrencyUSD, inactiveCurrency } from "../testing/fixtures";
 import { run } from "./deactivateCurrency";
 
 describe("deactivateCurrency", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["primitives:deactivateCurrency"],
-  };
-
   it(
     "throws when currency doesn't exist",
-    testNotFound(run, { currencyId: "nonexistent-currency" }, ctx, CurrencyNotFoundError),
+    testNotFound(run, { currencyId: "nonexistent-currency" }, CurrencyNotFoundError),
   );
 
   it("throws when attempting to deactivate base currency", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(baseCurrencyUSD); // USD is base currency
 
-    const result = await run(
-      db,
-      {
-        currencyId: baseCurrencyUSD.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      currencyId: baseCurrencyUSD.id,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -37,12 +27,12 @@ describe("deactivateCurrency", () => {
 
   it(
     "returns currency unchanged when already inactive",
-    testIdempotent(run, { currencyId: inactiveCurrency.id }, ctx, inactiveCurrency, "currency"),
+    testIdempotent(run, { currencyId: inactiveCurrency.id }, inactiveCurrency, "currency"),
   );
 
   // Success cases
   it("deactivates active non-base currency", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const deactivatedCurrency = {
       ...baseCurrencyEUR,
       isActive: false,
@@ -52,13 +42,9 @@ describe("deactivateCurrency", () => {
     spies.select.mockReturnValue(baseCurrencyEUR); // EUR is not base currency
     spies.update.mockReturnValue(deactivatedCurrency);
 
-    const result = await run(
-      db,
-      {
-        currencyId: baseCurrencyEUR.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      currencyId: baseCurrencyEUR.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {

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

@@ -1,7 +1,6 @@
-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 { CannotDeactivateBaseCurrencyError, CurrencyNotFoundError } from "../lib/errors.generated";
-import { getCurrency } from "../query/getCurrency.generated";
 
 export interface DeactivateCurrencyInput {
   currencyId: string;
@@ -13,9 +12,14 @@ export interface DeactivateCurrencyInput {
  * Disables a currency from being used in new transactions while preserving
  * historical data. Base currency cannot be deactivated.
  */
-export async function run(db: DB, input: DeactivateCurrencyInput, ctx: CommandContext) {
+export async function run(db: Transaction, input: DeactivateCurrencyInput) {
   // 1. Find currency by ID
-  const { currency } = await getCurrency(db, { id: input.currencyId }, ctx);
+  const currency = await db
+    .selectFrom("Currency")
+    .selectAll()
+    .where("id", "=", input.currencyId)
+    .forUpdate()
+    .executeTakeFirst();
 
   // 2. If not found, throw error
   if (!currency) {

package/src/modules/primitives/command/deactivateUnit.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 "./deactivateUnit";
 

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

@@ -1,30 +1,23 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb, testNotFound } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb, testNotFound } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import { CannotDeactivateReferenceUnitError, UnitNotFoundError } from "../lib/errors.generated";
 import { baseUnitKg, baseUnitGram, baseUoMCategory, inactiveUnit } from "../testing/fixtures";
 import { run } from "./deactivateUnit";
 
 describe("deactivateUnit", () => {
-  const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:deactivateUnit"] };
-
   it(
     "throws when unit doesn't exist",
-    testNotFound(run, { unitId: "nonexistent-unit" }, ctx, UnitNotFoundError),
+    testNotFound(run, { unitId: "nonexistent-unit" }, UnitNotFoundError),
   );
 
   it("throws when attempting to deactivate reference unit", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseUnitKg).mockReturnValueOnce(baseUoMCategory);
 
-    const result = await run(
-      db,
-      {
-        unitId: baseUnitKg.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      unitId: baseUnitKg.id,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -34,16 +27,12 @@ describe("deactivateUnit", () => {
 
   // Idempotent case needs multi-mock setup, kept inline
   it("returns unit unchanged when already inactive", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(inactiveUnit).mockReturnValueOnce(baseUoMCategory);
 
-    const result = await run(
-      db,
-      {
-        unitId: inactiveUnit.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      unitId: inactiveUnit.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -54,7 +43,7 @@ describe("deactivateUnit", () => {
 
   // Success cases
   it("deactivates active non-reference unit", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const deactivatedUnit = {
       ...baseUnitGram,
       isActive: false,
@@ -64,13 +53,9 @@ describe("deactivateUnit", () => {
     spies.select.mockReturnValueOnce(baseUnitGram).mockReturnValueOnce(baseUoMCategory);
     spies.update.mockReturnValue(deactivatedUnit);
 
-    const result = await run(
-      db,
-      {
-        unitId: baseUnitGram.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      unitId: baseUnitGram.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {