@tailor-platform/erp-kit 0.2.1 → 0.2.2

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

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

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

@@ -1,31 +1,24 @@
 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 { DuplicateCategoryNameError } from "../lib/errors.generated";
 import { baseUoMCategory, baseUnitKg } from "../testing/fixtures";
 import { run } from "./createCategory";
 
 describe("createCategory", () => {
-  const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:createCategory"] };
-
   // Error cases
   it("throws when category name already exists", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(baseUoMCategory);
 
-    const result = await run(
-      db,
-      {
-        name: baseUoMCategory.name,
-        referenceUnit: {
-          name: "Kilogram",
-          symbol: "kg",
-          roundingPrecision: 2,
-        },
+    const result = await run(db, {
+      name: baseUoMCategory.name,
+      referenceUnit: {
+        name: "Kilogram",
+        symbol: "kg",
+        roundingPrecision: 2,
       },
-      ctx,
-    );
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -35,7 +28,7 @@ describe("createCategory", () => {
 
   // Success cases
   it("creates category with reference unit", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdCategory = {
       ...baseUoMCategory,
       id: "new-category-id",
@@ -51,19 +44,15 @@ describe("createCategory", () => {
     spies.insert.mockReturnValueOnce(createdCategory).mockReturnValueOnce(createdUnit);
     spies.update.mockReturnValue({ ...createdCategory, referenceUnitId: "new-unit-id" });
 
-    const result = await run(
-      db,
-      {
-        name: "Weight",
-        description: "Weight units",
-        referenceUnit: {
-          name: "Kilogram",
-          symbol: "kg",
-          roundingPrecision: 2,
-        },
+    const result = await run(db, {
+      name: "Weight",
+      description: "Weight units",
+      referenceUnit: {
+        name: "Kilogram",
+        symbol: "kg",
+        roundingPrecision: 2,
       },
-      ctx,
-    );
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -75,7 +64,7 @@ describe("createCategory", () => {
   });
 
   it("passes custom fields through to insert", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdCategory = {
       ...baseUoMCategory,
       id: "new-category-id",
@@ -91,20 +80,16 @@ describe("createCategory", () => {
     spies.insert.mockReturnValueOnce(createdCategory).mockReturnValueOnce(createdUnit);
     spies.update.mockReturnValue({ ...createdCategory, referenceUnitId: "new-unit-id" });
 
-    await run(
-      db,
-      {
-        name: "Weight",
-        priority: 1,
-        referenceUnit: {
-          name: "Kilogram",
-          symbol: "kg",
-          roundingPrecision: 2,
-          tolerance: 0.01,
-        },
+    await run(db, {
+      name: "Weight",
+      priority: 1,
+      referenceUnit: {
+        name: "Kilogram",
+        symbol: "kg",
+        roundingPrecision: 2,
+        tolerance: 0.01,
       },
-      ctx,
-    );
+    });
 
     // Category insert includes category custom field
     expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ priority: 1 }));

package/src/modules/primitives/command/createCategory.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 { DuplicateCategoryNameError } from "../lib/errors.generated";
-import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 interface CreateCategoryInput<UnitCF extends Record<string, unknown>> {
   name: string;
@@ -22,12 +21,17 @@ interface CreateCategoryInput<UnitCF extends Record<string, unknown>> {
 export async function run<
   CatCF extends Record<string, unknown>,
   UnitCF extends Record<string, unknown>,
->(db: DB, input: CreateCategoryInput<UnitCF> & CatCF, ctx: CommandContext) {
+>(db: Transaction, input: CreateCategoryInput<UnitCF> & CatCF) {
   const { name, description, referenceUnit, ...categoryCustomFields } = input;
   const { name: unitName, symbol, roundingPrecision, ...unitCustomFields } = referenceUnit;
 
   // 1. Check if category name already exists
-  const { uoMCategory: existingCategory } = await getUoMCategory(db, { name }, ctx);
+  const existingCategory = await db
+    .selectFrom("UoMCategory")
+    .selectAll()
+    .where("name", "=", name)
+    .forUpdate()
+    .executeTakeFirst();
 
   if (existingCategory) {
     return err(new DuplicateCategoryNameError(name));

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

package/src/modules/primitives/command/createCurrency.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 {
   DuplicateCurrencyCodeError,
   InvalidDecimalPlacesError,
@@ -11,22 +10,16 @@ import { baseCurrencyUSD } from "../testing/fixtures";
 import { run } from "./createCurrency";
 
 describe("createCurrency", () => {
-  const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:createCurrency"] };
-
   // Error cases
   it("throws when ISO code is invalid format", async () => {
-    const { db } = createMockDb<DB>();
-
-    const result = await run(
-      db,
-      {
-        code: "us", // Should be 3 uppercase letters
-        name: "US Dollar",
-        symbol: "$",
-        decimalPlaces: 2,
-      },
-      ctx,
-    );
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, {
+      code: "us", // Should be 3 uppercase letters
+      name: "US Dollar",
+      symbol: "$",
+      decimalPlaces: 2,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -35,19 +28,15 @@ describe("createCurrency", () => {
   });
 
   it("throws when ISO code already exists", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(baseCurrencyUSD);
 
-    const result = await run(
-      db,
-      {
-        code: "USD",
-        name: "US Dollar",
-        symbol: "$",
-        decimalPlaces: 2,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      code: "USD",
+      name: "US Dollar",
+      symbol: "$",
+      decimalPlaces: 2,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -56,19 +45,15 @@ describe("createCurrency", () => {
   });
 
   it("throws when decimal places is negative", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined); // No existing currency
 
-    const result = await run(
-      db,
-      {
-        code: "XXX",
-        name: "Test Currency",
-        symbol: "X",
-        decimalPlaces: -1,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      code: "XXX",
+      name: "Test Currency",
+      symbol: "X",
+      decimalPlaces: -1,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -77,19 +62,15 @@ describe("createCurrency", () => {
   });
 
   it("throws when decimal places exceeds maximum", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined); // No existing currency
 
-    const result = await run(
-      db,
-      {
-        code: "XXX",
-        name: "Test Currency",
-        symbol: "X",
-        decimalPlaces: 5,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      code: "XXX",
+      name: "Test Currency",
+      symbol: "X",
+      decimalPlaces: 5,
+    });
 
     expect(result.ok).toBe(false);
     if (!result.ok) {
@@ -99,7 +80,7 @@ describe("createCurrency", () => {
 
   // Success cases
   it("creates first currency as base currency", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdCurrency = {
       id: "new-currency-id",
       code: "USD",
@@ -117,16 +98,12 @@ describe("createCurrency", () => {
       .mockReturnValueOnce(undefined); // No existing currencies (first currency)
     spies.insert.mockReturnValue(createdCurrency);
 
-    const result = await run(
-      db,
-      {
-        code: "USD",
-        name: "US Dollar",
-        symbol: "$",
-        decimalPlaces: 2,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      code: "USD",
+      name: "US Dollar",
+      symbol: "$",
+      decimalPlaces: 2,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -137,7 +114,7 @@ describe("createCurrency", () => {
   });
 
   it("creates subsequent currency as non-base", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdCurrency = {
       id: "new-currency-id",
       code: "EUR",
@@ -155,16 +132,12 @@ describe("createCurrency", () => {
       .mockReturnValueOnce(baseCurrencyUSD); // Existing currency exists
     spies.insert.mockReturnValue(createdCurrency);
 
-    const result = await run(
-      db,
-      {
-        code: "EUR",
-        name: "Euro",
-        symbol: "€",
-        decimalPlaces: 2,
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      code: "EUR",
+      name: "Euro",
+      symbol: "€",
+      decimalPlaces: 2,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -174,7 +147,7 @@ describe("createCurrency", () => {
   });
 
   it("passes custom fields through to insert", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const createdCurrency = {
       ...baseCurrencyUSD,
       id: "new-currency-id",
@@ -187,11 +160,13 @@ describe("createCurrency", () => {
       .mockReturnValueOnce(undefined); // No existing currencies
     spies.insert.mockReturnValue(createdCurrency);
 
-    await run(
-      db,
-      { code: "GBP", name: "British Pound", symbol: "£", decimalPlaces: 2, region: "Europe" },
-      ctx,
-    );
+    await run(db, {
+      code: "GBP",
+      name: "British Pound",
+      symbol: "£",
+      decimalPlaces: 2,
+      region: "Europe",
+    });
 
     expect(spies.values).toHaveBeenNthCalledWith(1, expect.objectContaining({ region: "Europe" }));
   });