@tailor-platform/erp-kit 0.2.1 → 0.3.0

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

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

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

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

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

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

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