@tailor-platform/erp-kit 0.1.1 → 0.2.0

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { InsufficientPermissionError, type CommandContext } from "../../shared/internal";
+import { type CommandContext } from "../../shared/internal";
 import { createMockDb } from "../../testing/index";
 import { DB } from "../generated/kysely-tailordb";
 import {
@@ -7,16 +7,14 @@ import {
   InactiveCurrencyError,
   InvalidExchangeRateError,
   SameCurrencyPairError,
-} from "../lib/errors";
+} from "../lib/errors.generated";
 import {
   baseCurrencyEUR,
   baseCurrencyUSD,
   baseExchangeRateUSDtoEUR,
   inactiveCurrency,
 } from "../testing/fixtures";
-import { makeCreateExchangeRate } from "./createExchangeRate";
-
-const createExchangeRate = makeCreateExchangeRate();
+import { run } from "./createExchangeRate";
 
 describe("createExchangeRate", () => {
   const ctx: CommandContext = {
@@ -29,36 +27,42 @@ describe("createExchangeRate", () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined);
 
-    await expect(
-      createExchangeRate(
-        db,
-        {
-          sourceCurrencyId: "nonexistent-currency",
-          targetCurrencyId: baseCurrencyEUR.id,
-          rate: 0.92,
-          effectiveDate: new Date("2024-01-15"),
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CurrencyNotFoundError);
+    const result = await run(
+      db,
+      {
+        sourceCurrencyId: "nonexistent-currency",
+        targetCurrencyId: baseCurrencyEUR.id,
+        rate: 0.92,
+        effectiveDate: new Date("2024-01-15"),
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
   });
 
   it("throws when source currency is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(inactiveCurrency);
 
-    await expect(
-      createExchangeRate(
-        db,
-        {
-          sourceCurrencyId: inactiveCurrency.id,
-          targetCurrencyId: baseCurrencyEUR.id,
-          rate: 0.92,
-          effectiveDate: new Date("2024-01-15"),
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InactiveCurrencyError);
+    const result = await run(
+      db,
+      {
+        sourceCurrencyId: inactiveCurrency.id,
+        targetCurrencyId: baseCurrencyEUR.id,
+        rate: 0.92,
+        effectiveDate: new Date("2024-01-15"),
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InactiveCurrencyError);
+    }
   });
 
   it("throws when target currency doesn't exist", async () => {
@@ -67,18 +71,21 @@ describe("createExchangeRate", () => {
       .mockReturnValueOnce(baseCurrencyUSD) // Source exists
       .mockReturnValueOnce(undefined); // Target doesn't exist
 
-    await expect(
-      createExchangeRate(
-        db,
-        {
-          sourceCurrencyId: baseCurrencyUSD.id,
-          targetCurrencyId: "nonexistent-currency",
-          rate: 0.92,
-          effectiveDate: new Date("2024-01-15"),
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(CurrencyNotFoundError);
+    const result = await run(
+      db,
+      {
+        sourceCurrencyId: baseCurrencyUSD.id,
+        targetCurrencyId: "nonexistent-currency",
+        rate: 0.92,
+        effectiveDate: new Date("2024-01-15"),
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(CurrencyNotFoundError);
+    }
   });
 
   it("throws when target currency is inactive", async () => {
@@ -87,54 +94,63 @@ describe("createExchangeRate", () => {
       .mockReturnValueOnce(baseCurrencyUSD) // Source exists and active
       .mockReturnValueOnce(inactiveCurrency); // Target is inactive
 
-    await expect(
-      createExchangeRate(
-        db,
-        {
-          sourceCurrencyId: baseCurrencyUSD.id,
-          targetCurrencyId: inactiveCurrency.id,
-          rate: 0.92,
-          effectiveDate: new Date("2024-01-15"),
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InactiveCurrencyError);
+    const result = await run(
+      db,
+      {
+        sourceCurrencyId: baseCurrencyUSD.id,
+        targetCurrencyId: inactiveCurrency.id,
+        rate: 0.92,
+        effectiveDate: new Date("2024-01-15"),
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InactiveCurrencyError);
+    }
   });
 
   it("throws when source and target are the same", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(baseCurrencyUSD);
 
-    await expect(
-      createExchangeRate(
-        db,
-        {
-          sourceCurrencyId: baseCurrencyUSD.id,
-          targetCurrencyId: baseCurrencyUSD.id,
-          rate: 1.0,
-          effectiveDate: new Date("2024-01-15"),
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(SameCurrencyPairError);
+    const result = await run(
+      db,
+      {
+        sourceCurrencyId: baseCurrencyUSD.id,
+        targetCurrencyId: baseCurrencyUSD.id,
+        rate: 1.0,
+        effectiveDate: new Date("2024-01-15"),
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(SameCurrencyPairError);
+    }
   });
 
   it("throws when rate is not positive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValueOnce(baseCurrencyUSD).mockReturnValueOnce(baseCurrencyEUR);
 
-    await expect(
-      createExchangeRate(
-        db,
-        {
-          sourceCurrencyId: baseCurrencyUSD.id,
-          targetCurrencyId: baseCurrencyEUR.id,
-          rate: 0,
-          effectiveDate: new Date("2024-01-15"),
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InvalidExchangeRateError);
+    const result = await run(
+      db,
+      {
+        sourceCurrencyId: baseCurrencyUSD.id,
+        targetCurrencyId: baseCurrencyEUR.id,
+        rate: 0,
+        effectiveDate: new Date("2024-01-15"),
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidExchangeRateError);
+    }
   });
 
   // Success cases
@@ -153,7 +169,7 @@ describe("createExchangeRate", () => {
     spies.select.mockReturnValueOnce(baseCurrencyUSD).mockReturnValueOnce(baseCurrencyEUR);
     spies.insert.mockReturnValue(createdRate);
 
-    const result = await createExchangeRate(
+    const result = await run(
       db,
       {
         sourceCurrencyId: baseCurrencyUSD.id,
@@ -164,31 +180,16 @@ describe("createExchangeRate", () => {
       ctx,
     );
 
-    expect(result.exchangeRate.rate).toBe(0.92);
-    expect(result.exchangeRate.sourceCurrencyId).toBe(baseCurrencyUSD.id);
-    expect(result.exchangeRate.targetCurrencyId).toBe(baseCurrencyEUR.id);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.exchangeRate.rate).toBe(0.92);
+      expect(result.value.exchangeRate.sourceCurrencyId).toBe(baseCurrencyUSD.id);
+      expect(result.value.exchangeRate.targetCurrencyId).toBe(baseCurrencyEUR.id);
+    }
     expect(spies.insert).toHaveBeenCalled();
   });
 
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      createExchangeRate(
-        db,
-        {
-          sourceCurrencyId: "cur-1",
-          targetCurrencyId: "cur-2",
-          rate: 1.5,
-          effectiveDate: new Date("2024-01-15"),
-        },
-        denied,
-      ),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
-  });
-
   it("passes custom fields through to insert", async () => {
-    const createExchangeRateWithFields = makeCreateExchangeRate<{ source: string }>();
     const { db, spies } = createMockDb<DB>();
     const createdRate = {
       ...baseExchangeRateUSDtoEUR,
@@ -199,7 +200,7 @@ describe("createExchangeRate", () => {
     spies.select.mockReturnValueOnce(baseCurrencyUSD).mockReturnValueOnce(baseCurrencyEUR);
     spies.insert.mockReturnValue(createdRate);
 
-    await createExchangeRateWithFields(
+    await run(
       db,
       {
         sourceCurrencyId: baseCurrencyUSD.id,

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

@@ -1,12 +1,12 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
 import {
   CurrencyNotFoundError,
   InactiveCurrencyError,
   InvalidExchangeRateError,
   SameCurrencyPairError,
-} from "../lib/errors";
-import { permissions } from "../permissions";
+} from "../lib/errors.generated";
+import { getCurrency } from "../query/getCurrency.generated";
 
 interface CreateExchangeRateInput {
   sourceCurrencyId: string;
@@ -22,70 +22,61 @@ interface CreateExchangeRateInput {
  * effective date. The rate specifies how many units of the target currency
  * equal one unit of the source currency.
  */
-export function makeCreateExchangeRate<CF extends Record<string, unknown>>() {
-  return defineCommand(
-    permissions.createExchangeRate,
-    async (db: DB, input: CreateExchangeRateInput & CF) => {
-      const { sourceCurrencyId, targetCurrencyId, rate, effectiveDate, ...customFields } = input;
+export async function run<CF extends Record<string, unknown>>(
+  db: DB,
+  input: CreateExchangeRateInput & CF,
+  ctx: CommandContext,
+) {
+  const { sourceCurrencyId, targetCurrencyId, rate, effectiveDate, ...customFields } = input;
 
-      // 1. Check source currency exists
-      const sourceCurrency = await db
-        .selectFrom("Currency")
-        .selectAll()
-        .where("id", "=", sourceCurrencyId)
-        .executeTakeFirst();
+  // 1. Check source currency exists
+  const { currency: sourceCurrency } = await getCurrency(db, { id: sourceCurrencyId }, ctx);
 
-      if (!sourceCurrency) {
-        throw new CurrencyNotFoundError(sourceCurrencyId);
-      }
+  if (!sourceCurrency) {
+    return err(new CurrencyNotFoundError(sourceCurrencyId));
+  }
 
-      // 2. Check source currency is active
-      if (!sourceCurrency.isActive) {
-        throw new InactiveCurrencyError(sourceCurrency.code);
-      }
+  // 2. Check source currency is active
+  if (!sourceCurrency.isActive) {
+    return err(new InactiveCurrencyError(sourceCurrency.code));
+  }
 
-      // 3. Check target currency exists
-      const targetCurrency = await db
-        .selectFrom("Currency")
-        .selectAll()
-        .where("id", "=", targetCurrencyId)
-        .executeTakeFirst();
+  // 3. Check target currency exists
+  const { currency: targetCurrency } = await getCurrency(db, { id: targetCurrencyId }, ctx);
 
-      if (!targetCurrency) {
-        throw new CurrencyNotFoundError(targetCurrencyId);
-      }
+  if (!targetCurrency) {
+    return err(new CurrencyNotFoundError(targetCurrencyId));
+  }
 
-      // 4. Check target currency is active
-      if (!targetCurrency.isActive) {
-        throw new InactiveCurrencyError(targetCurrency.code);
-      }
+  // 4. Check target currency is active
+  if (!targetCurrency.isActive) {
+    return err(new InactiveCurrencyError(targetCurrency.code));
+  }
 
-      // 5. Check source and target are different
-      if (sourceCurrencyId === targetCurrencyId) {
-        throw new SameCurrencyPairError(sourceCurrencyId);
-      }
+  // 5. Check source and target are different
+  if (sourceCurrencyId === targetCurrencyId) {
+    return err(new SameCurrencyPairError(sourceCurrencyId));
+  }
 
-      // 6. Validate rate is positive
-      if (rate <= 0) {
-        throw new InvalidExchangeRateError(rate);
-      }
+  // 6. Validate rate is positive
+  if (rate <= 0) {
+    return err(new InvalidExchangeRateError(String(rate)));
+  }
 
-      // 7. Create exchange rate
-      const exchangeRate = await db
-        .insertInto("ExchangeRate")
-        .values({
-          ...(customFields as Record<string, unknown>),
-          sourceCurrencyId,
-          targetCurrencyId,
-          rate,
-          effectiveDate,
-          createdAt: new Date(),
-          updatedAt: null,
-        })
-        .returningAll()
-        .executeTakeFirst();
+  // 7. Create exchange rate
+  const exchangeRate = await db
+    .insertInto("ExchangeRate")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      sourceCurrencyId,
+      targetCurrencyId,
+      rate,
+      effectiveDate,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-      return { exchangeRate: exchangeRate! };
-    },
-  );
+  return ok({ exchangeRate: exchangeRate! });
 }

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

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { defineCommand } from "../../shared/internal";
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./createUnit";
+
+export const createUnit = defineCommand(permissions.createUnit, run);