@tailor-platform/erp-kit 0.2.0 → 0.2.2

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

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

@@ -1,8 +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 { CannotDeactivateReferenceUnitError, UnitNotFoundError } from "../lib/errors.generated";
-import { getUnit } from "../query/getUnit.generated";
-import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 export interface DeactivateUnitInput {
   unitId: string;
@@ -15,9 +13,14 @@ export interface DeactivateUnitInput {
  * and quantity conversions while preserving all historical data.
  * Reference units cannot be deactivated.
  */
-export async function run(db: DB, input: DeactivateUnitInput, ctx: CommandContext) {
+export async function run(db: Transaction, input: DeactivateUnitInput) {
   // 1. Find unit by ID
-  const { unit } = await getUnit(db, { id: input.unitId }, ctx);
+  const unit = await db
+    .selectFrom("Unit")
+    .selectAll()
+    .where("id", "=", input.unitId)
+    .forUpdate()
+    .executeTakeFirst();
 
   // 2. If not found, throw error
   if (!unit) {
@@ -25,7 +28,11 @@ export async function run(db: DB, input: DeactivateUnitInput, ctx: CommandContex
   }
 
   // 3. Check if unit is reference unit for its category
-  const { uoMCategory } = await getUoMCategory(db, { id: unit.categoryId }, ctx);
+  const uoMCategory = await db
+    .selectFrom("UoMCategory")
+    .selectAll()
+    .where("id", "=", unit.categoryId)
+    .executeTakeFirst();
 
   if (uoMCategory?.referenceUnitId === unit.id) {
     return err(new CannotDeactivateReferenceUnitError(input.unitId));

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

package/src/modules/primitives/command/setBaseCurrency.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 {
   CannotSetInactiveAsBaseCurrencyError,
   CurrencyNotFoundError,
@@ -10,23 +9,14 @@ import { baseCurrencyEUR, baseCurrencyUSD, inactiveCurrency } from "../testing/f
 import { run } from "./setBaseCurrency";
 
 describe("setBaseCurrency", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["primitives:setBaseCurrency"],
-  };
-
   // Error cases
   it("throws when currency doesn't exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(
-      db,
-      {
-        currencyId: "nonexistent-currency",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      currencyId: "nonexistent-currency",
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -35,16 +25,12 @@ describe("setBaseCurrency", () => {
   });
 
   it("throws when currency is inactive", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(inactiveCurrency);
 
-    const result = await run(
-      db,
-      {
-        currencyId: inactiveCurrency.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      currencyId: inactiveCurrency.id,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -54,16 +40,12 @@ describe("setBaseCurrency", () => {
 
   // Idempotent cases
   it("returns currency unchanged when already base", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(baseCurrencyUSD); // Already base currency
 
-    const result = await run(
-      db,
-      {
-        currencyId: baseCurrencyUSD.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      currencyId: baseCurrencyUSD.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -74,7 +56,7 @@ describe("setBaseCurrency", () => {
 
   // Success cases
   it("changes base currency", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const newBaseCurrency = {
       ...baseCurrencyEUR,
       isBaseCurrency: true,
@@ -88,13 +70,9 @@ describe("setBaseCurrency", () => {
       .mockReturnValueOnce({ ...baseCurrencyUSD, isBaseCurrency: false }) // Remove base from old
       .mockReturnValueOnce(newBaseCurrency); // Set base on new
 
-    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/setBaseCurrency.ts

@@ -1,11 +1,9 @@
-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 {
   CannotSetInactiveAsBaseCurrencyError,
   CurrencyNotFoundError,
 } from "../lib/errors.generated";
-import { getCurrency } from "../query/getCurrency.generated";
-import { getBaseCurrency } from "../query/getBaseCurrency.generated";
 
 export interface SetBaseCurrencyInput {
   currencyId: string;
@@ -17,9 +15,14 @@ export interface SetBaseCurrencyInput {
  * Changes the organization's base currency to a different active currency.
  * The base currency serves as the default for financial reporting.
  */
-export async function run(db: DB, input: SetBaseCurrencyInput, ctx: CommandContext) {
+export async function run(db: Transaction, input: SetBaseCurrencyInput) {
   // 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) {
@@ -37,7 +40,12 @@ export async function run(db: DB, input: SetBaseCurrencyInput, ctx: CommandConte
   }
 
   // 5. Find current base currency
-  const { currency: currentBase } = await getBaseCurrency(db, undefined, ctx);
+  const currentBase = await db
+    .selectFrom("Currency")
+    .selectAll()
+    .where("isBaseCurrency", "=", true)
+    .forUpdate()
+    .executeTakeFirst();
 
   // 6. Remove base flag from current base
   if (currentBase) {

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

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

@@ -1,30 +1,20 @@
 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 { UnitNotFoundError, UnitNotInCategoryError } from "../lib/errors.generated";
 import { baseUoMCategory, baseUnitGram, baseUnitKg, baseUnitLiter } from "../testing/fixtures";
 import { run } from "./setReferenceUnit";
 
 describe("setReferenceUnit", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["primitives:setReferenceUnit"],
-  };
-
   // Error cases
   it("throws when unit doesn't exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(
-      db,
-      {
-        unitId: "nonexistent-unit",
-        categoryId: baseUoMCategory.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      unitId: "nonexistent-unit",
+      categoryId: baseUoMCategory.id,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -33,17 +23,13 @@ describe("setReferenceUnit", () => {
   });
 
   it("throws when unit is not in specified category", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(baseUnitLiter); // Unit is in category-2, not category-1
 
-    const result = await run(
-      db,
-      {
-        unitId: baseUnitLiter.id,
-        categoryId: baseUoMCategory.id, // category-1
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      unitId: baseUnitLiter.id,
+      categoryId: baseUoMCategory.id, // category-1
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -53,19 +39,15 @@ describe("setReferenceUnit", () => {
 
   // Idempotent cases
   it("returns category unchanged when unit is already reference", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseUnitKg) // Unit lookup
       .mockReturnValueOnce(baseUoMCategory); // Category lookup
 
-    const result = await run(
-      db,
-      {
-        unitId: baseUnitKg.id,
-        categoryId: baseUoMCategory.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      unitId: baseUnitKg.id,
+      categoryId: baseUoMCategory.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -76,7 +58,7 @@ describe("setReferenceUnit", () => {
 
   // Success cases
   it("changes reference unit and recalculates conversion factors", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     // gram has conversion factor 0.001 (1g = 0.001kg)
     // When gram becomes reference, kg should become 1000 (1kg = 1000g)
     const updatedCategory = {
@@ -94,14 +76,10 @@ describe("setReferenceUnit", () => {
       .mockReturnValueOnce({ ...baseUnitGram, conversionFactor: 1.0 }) // Update gram factor
       .mockReturnValueOnce(updatedCategory); // Update category
 
-    const result = await run(
-      db,
-      {
-        unitId: baseUnitGram.id,
-        categoryId: baseUoMCategory.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      unitId: baseUnitGram.id,
+      categoryId: baseUoMCategory.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {