@tailor-platform/erp-kit 0.2.1 → 0.3.0

package/src/modules/item-management/query/getItem.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { baseActiveItem, baseDraftItem } from "../testing/fixtures";
 import { run } from "./getItem";
@@ -12,7 +12,10 @@ describe("getItem", () => {
 
       const result = await run(db, { id: "item-1" });
 
-      expect(result.item).toEqual(baseDraftItem);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.item).toEqual(baseDraftItem);
+      }
     });
 
     it("returns null when item not found", async () => {
@@ -21,7 +24,10 @@ describe("getItem", () => {
 
       const result = await run(db, { id: "nonexistent" });
 
-      expect(result.item).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.item).toBeNull();
+      }
     });
   });
 
@@ -32,7 +38,10 @@ describe("getItem", () => {
 
       const result = await run(db, { sku: "SKU-001" });
 
-      expect(result.item).toEqual(baseDraftItem);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.item).toEqual(baseDraftItem);
+      }
     });
 
     it("returns null when item not found", async () => {
@@ -41,7 +50,10 @@ describe("getItem", () => {
 
       const result = await run(db, { sku: "NONEXISTENT" });
 
-      expect(result.item).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.item).toBeNull();
+      }
     });
   });
 
@@ -52,7 +64,10 @@ describe("getItem", () => {
 
       const result = await run(db, { barcode: "BAR-002" });
 
-      expect(result.item).toEqual(baseActiveItem);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.item).toEqual(baseActiveItem);
+      }
     });
 
     it("returns null when item not found", async () => {
@@ -61,7 +76,10 @@ describe("getItem", () => {
 
       const result = await run(db, { barcode: "NONEXISTENT" });
 
-      expect(result.item).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.item).toBeNull();
+      }
     });
   });
 });

package/src/modules/item-management/query/getItem.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export type GetItemInput = { id: string } | { sku: string } | { barcode: string };
@@ -16,5 +16,5 @@ export async function run(db: ReadonlyDB<DB>, input: GetItemInput) {
 
   const item = await query.executeTakeFirst();
 
-  return { item: item ?? null };
+  return ok({ item: item ?? null });
 }

package/src/modules/item-management/query/getItemTaxonomyAssignment.generated.ts

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

package/src/modules/item-management/query/getItemTaxonomyAssignment.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { baseAssignment } from "../testing/fixtures";
 import { run } from "./getItemTaxonomyAssignment";
@@ -11,7 +11,10 @@ describe("getItemTaxonomyAssignment", () => {
 
     const result = await run(db, { itemId: "item-2", taxonomyNodeId: "node-2" });
 
-    expect(result.assignment).toEqual(baseAssignment);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment).toEqual(baseAssignment);
+    }
   });
 
   it("returns null when assignment not found", async () => {
@@ -20,6 +23,9 @@ describe("getItemTaxonomyAssignment", () => {
 
     const result = await run(db, { itemId: "item-1", taxonomyNodeId: "node-1" });
 
-    expect(result.assignment).toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignment).toBeNull();
+    }
   });
 });

package/src/modules/item-management/query/getItemTaxonomyAssignment.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export interface GetItemTaxonomyAssignmentInput {
@@ -14,5 +14,5 @@ export async function run(db: ReadonlyDB<DB>, input: GetItemTaxonomyAssignmentIn
     .where("taxonomyNodeId", "=", input.taxonomyNodeId)
     .executeTakeFirst();
 
-  return { assignment: assignment ?? null };
+  return ok({ assignment: assignment ?? null });
 }

package/src/modules/item-management/query/getTaxonomyNode.generated.ts

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

package/src/modules/item-management/query/getTaxonomyNode.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { baseRootNode } from "../testing/fixtures";
 import { run } from "./getTaxonomyNode";
@@ -12,7 +12,10 @@ describe("getTaxonomyNode", () => {
 
       const result = await run(db, { id: "node-1" });
 
-      expect(result.node).toEqual(baseRootNode);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.node).toEqual(baseRootNode);
+      }
     });
 
     it("returns null when node not found", async () => {
@@ -21,7 +24,10 @@ describe("getTaxonomyNode", () => {
 
       const result = await run(db, { id: "nonexistent" });
 
-      expect(result.node).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.node).toBeNull();
+      }
     });
   });
 
@@ -32,7 +38,10 @@ describe("getTaxonomyNode", () => {
 
       const result = await run(db, { code: "ELECTRONICS" });
 
-      expect(result.node).toEqual(baseRootNode);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.node).toEqual(baseRootNode);
+      }
     });
 
     it("returns null when node not found", async () => {
@@ -41,7 +50,10 @@ describe("getTaxonomyNode", () => {
 
       const result = await run(db, { code: "NONEXISTENT" });
 
-      expect(result.node).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.node).toBeNull();
+      }
     });
   });
 });

package/src/modules/item-management/query/getTaxonomyNode.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export type GetTaxonomyNodeInput = { id: string } | { code: string };
@@ -14,5 +14,5 @@ export async function run(db: ReadonlyDB<DB>, input: GetTaxonomyNodeInput) {
 
   const node = await query.executeTakeFirst();
 
-  return { node: node ?? null };
+  return ok({ node: node ?? null });
 }

package/src/modules/item-management/query/getTaxonomyNodeAssignments.generated.ts

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

package/src/modules/item-management/query/getTaxonomyNodeAssignments.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { baseAssignment } from "../testing/fixtures";
 import { run } from "./getTaxonomyNodeAssignments";
@@ -11,7 +11,10 @@ describe("getTaxonomyNodeAssignments", () => {
 
     const result = await run(db, { taxonomyNodeId: "node-2" });
 
-    expect(result.assignments).toEqual([baseAssignment]);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignments).toEqual([baseAssignment]);
+    }
   });
 
   it("returns empty array when no assignments", async () => {
@@ -20,6 +23,9 @@ describe("getTaxonomyNodeAssignments", () => {
 
     const result = await run(db, { taxonomyNodeId: "node-1" });
 
-    expect(result.assignments).toEqual([]);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.assignments).toEqual([]);
+    }
   });
 });

package/src/modules/item-management/query/getTaxonomyNodeAssignments.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export interface GetTaxonomyNodeAssignmentsInput {
@@ -12,5 +12,5 @@ export async function run(db: ReadonlyDB<DB>, input: GetTaxonomyNodeAssignmentsI
     .where("taxonomyNodeId", "=", input.taxonomyNodeId)
     .execute();
 
-  return { assignments };
+  return ok({ assignments });
 }

package/src/modules/item-management/query/getTaxonomyNodeChildren.generated.ts

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

package/src/modules/item-management/query/getTaxonomyNodeChildren.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
 import { baseChildNode, baseLeafNode } from "../testing/fixtures";
 import { run } from "./getTaxonomyNodeChildren";
@@ -11,7 +11,10 @@ describe("getTaxonomyNodeChildren", () => {
 
     const result = await run(db, { parentId: "node-1" });
 
-    expect(result.children).toEqual([baseChildNode]);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.children).toEqual([baseChildNode]);
+    }
   });
 
   it("returns multiple children", async () => {
@@ -20,7 +23,10 @@ describe("getTaxonomyNodeChildren", () => {
 
     const result = await run(db, { parentId: "node-1" });
 
-    expect(result.children).toHaveLength(2);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.children).toHaveLength(2);
+    }
   });
 
   it("returns empty array when no children", async () => {
@@ -29,6 +35,9 @@ describe("getTaxonomyNodeChildren", () => {
 
     const result = await run(db, { parentId: "node-3" });
 
-    expect(result.children).toEqual([]);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.children).toEqual([]);
+    }
   });
 });

package/src/modules/item-management/query/getTaxonomyNodeChildren.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 export interface GetTaxonomyNodeChildrenInput {
@@ -12,5 +12,5 @@ export async function run(db: ReadonlyDB<DB>, input: GetTaxonomyNodeChildrenInpu
     .where("parentId", "=", input.parentId)
     .execute();
 
-  return { children };
+  return ok({ children });
 }

package/src/modules/item-management/tailor.config.ts

@@ -1,11 +1,13 @@
-import { defineConfig, defineGenerators } from "@tailor-platform/sdk";
+import { defineConfig, definePlugins } from "@tailor-platform/sdk";
+import { kyselyTypePlugin } from "@tailor-platform/sdk/plugin/kysely-type";
+import { enumConstantsPlugin } from "@tailor-platform/sdk/plugin/enum-constants";
 
 export default defineConfig({
   name: "item-management",
   db: { "main-db": { files: [`./db/*.ts`, `./lib/_db_deps.ts`] } },
 });
 
-export const generators = defineGenerators(
-  ["@tailor-platform/kysely-type", { distPath: `./generated/kysely-tailordb.ts` }],
-  ["@tailor-platform/enum-constants", { distPath: "./generated/enums.ts" }],
+export const plugins = definePlugins(
+  kyselyTypePlugin({ distPath: `./generated/kysely-tailordb.ts` }),
+  enumConstantsPlugin({ distPath: "./generated/enums.ts" }),
 );

package/src/modules/item-management/tailor.d.ts

@@ -0,0 +1,13 @@
+// This file is auto-generated by @tailor-platform/sdk
+// Do not edit this file manually
+// Regenerated automatically when running 'tailor-sdk apply' or 'tailor-sdk generate'
+
+declare module "@tailor-platform/sdk" {
+  interface AttributeMap {}
+  interface AttributeList {
+    __tuple?: [];
+  }
+  interface Env {}
+}
+
+export {};

package/src/modules/primitives/README.md

@@ -34,6 +34,14 @@ This module combines related configuration primitives to simplify dependency man
 - Transaction recording (sales, purchase, accounting modules)
 - Automatic exchange rate fetching from external APIs
 
+### Scope Decision Rationale
+
+Primitives bundles UoM and currency together because both are **foundational reference data** — stable, rarely-changing definitions that many modules depend on. Combining them in one module simplifies dependency management: downstream modules need only one dependency for measurement and monetary foundations rather than two separate ones.
+
+Tax configuration is excluded despite being "configuration-like" because tax rules are regulatory, jurisdiction-specific, and change frequently. They also require complex logic (tax cascading, fiscal positions) that would bloat a module intended to be simple and stable.
+
+External API integration for exchange rates is excluded to keep this module free of external dependencies and side effects. Rate fetching involves scheduling, error handling, and provider-specific logic that belongs in an integration layer.
+
 ## Module Dependencies
 
 - None (this is a foundational module)

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

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

@@ -1,17 +1,11 @@
 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 { UomCategoryNotFoundError } from "../lib/errors.generated";
 import { baseUoMCategory } from "../testing/fixtures";
 import { run } from "./activateCategory";
 
 describe("activateCategory", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["primitives:activateCategory"],
-  };
-
   const inactiveCategory = {
     ...baseUoMCategory,
     isActive: false,
@@ -19,17 +13,17 @@ describe("activateCategory", () => {
 
   it(
     "throws when category doesn't exist",
-    testNotFound(run, { categoryId: "nonexistent-category" }, ctx, UomCategoryNotFoundError),
+    testNotFound(run, { categoryId: "nonexistent-category" }, UomCategoryNotFoundError),
   );
 
   it(
     "returns category unchanged when already active",
-    testIdempotent(run, { categoryId: baseUoMCategory.id }, ctx, baseUoMCategory, "uoMCategory"),
+    testIdempotent(run, { categoryId: baseUoMCategory.id }, baseUoMCategory, "uoMCategory"),
   );
 
   // Success cases
   it("activates inactive category", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const activatedCategory = {
       ...inactiveCategory,
       isActive: true,
@@ -39,13 +33,9 @@ describe("activateCategory", () => {
     spies.select.mockReturnValue(inactiveCategory);
     spies.update.mockReturnValue(activatedCategory);
 
-    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) {

package/src/modules/primitives/command/activateCategory.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 { UomCategoryNotFoundError } from "../lib/errors.generated";
-import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 export interface ActivateCategoryInput {
   categoryId: string;
@@ -13,9 +12,14 @@ export interface ActivateCategoryInput {
  * Re-enables a previously deactivated UoM category, making it and its units
  * available for new product assignments and transactions.
  */
-export async function run(db: DB, input: ActivateCategoryInput, ctx: CommandContext) {
+export async function run(db: Transaction, input: ActivateCategoryInput) {
   // 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/activateCurrency.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 "./activateCurrency";
 

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

@@ -1,30 +1,24 @@
 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 { CurrencyNotFoundError } from "../lib/errors.generated";
 import { baseCurrencyUSD, inactiveCurrency } from "../testing/fixtures";
 import { run } from "./activateCurrency";
 
 describe("activateCurrency", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["primitives:activateCurrency"],
-  };
-
   it(
     "throws when currency doesn't exist",
-    testNotFound(run, { currencyId: "nonexistent-currency" }, ctx, CurrencyNotFoundError),
+    testNotFound(run, { currencyId: "nonexistent-currency" }, CurrencyNotFoundError),
   );
 
   it(
     "returns currency unchanged when already active",
-    testIdempotent(run, { currencyId: baseCurrencyUSD.id }, ctx, baseCurrencyUSD, "currency"),
+    testIdempotent(run, { currencyId: baseCurrencyUSD.id }, baseCurrencyUSD, "currency"),
   );
 
   // Success cases
   it("activates inactive currency", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const activatedCurrency = {
       ...inactiveCurrency,
       isActive: true,
@@ -34,13 +28,9 @@ describe("activateCurrency", () => {
     spies.select.mockReturnValue(inactiveCurrency);
     spies.update.mockReturnValue(activatedCurrency);
 
-    const result = await run(
-      db,
-      {
-        currencyId: inactiveCurrency.id,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      currencyId: inactiveCurrency.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {

package/src/modules/primitives/command/activateCurrency.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 { CurrencyNotFoundError } from "../lib/errors.generated";
-import { getCurrency } from "../query/getCurrency.generated";
 
 export interface ActivateCurrencyInput {
   currencyId: string;
@@ -13,9 +12,14 @@ export interface ActivateCurrencyInput {
  * Re-enables a previously deactivated currency, making it available
  * for new transactions.
  */
-export async function run(db: DB, input: ActivateCurrencyInput, ctx: CommandContext) {
+export async function run(db: Transaction, input: ActivateCurrencyInput) {
   // 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/activateUnit.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 "./activateUnit";
 

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

@@ -1,27 +1,24 @@
 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 { UnitNotFoundError } from "../lib/errors.generated";
 import { baseUnitKg, inactiveUnit } from "../testing/fixtures";
 import { run } from "./activateUnit";
 
 describe("activateUnit", () => {
-  const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:activateUnit"] };
-
   it(
     "throws when unit doesn't exist",
-    testNotFound(run, { unitId: "nonexistent-unit" }, ctx, UnitNotFoundError),
+    testNotFound(run, { unitId: "nonexistent-unit" }, UnitNotFoundError),
   );
 
   it(
     "returns unit unchanged when already active",
-    testIdempotent(run, { unitId: baseUnitKg.id }, ctx, baseUnitKg, "unit"),
+    testIdempotent(run, { unitId: baseUnitKg.id }, baseUnitKg, "unit"),
   );
 
   // Success cases
   it("activates inactive unit", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const activatedUnit = {
       ...inactiveUnit,
       isActive: true,
@@ -31,13 +28,9 @@ describe("activateUnit", () => {
     spies.select.mockReturnValue(inactiveUnit);
     spies.update.mockReturnValue(activatedUnit);
 
-    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) {

package/src/modules/primitives/command/activateUnit.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 { UnitNotFoundError } from "../lib/errors.generated";
-import { getUnit } from "../query/getUnit.generated";
 
 export interface ActivateUnitInput {
   unitId: string;
@@ -13,9 +12,14 @@ export interface ActivateUnitInput {
  * Re-enables a previously deactivated unit of measure, making it available
  * for new product assignments and quantity conversions.
  */
-export async function run(db: DB, input: ActivateUnitInput, ctx: CommandContext) {
+export async function run(db: Transaction, input: ActivateUnitInput) {
   // 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) {