@tailor-platform/erp-kit 0.2.1 → 0.3.0

package/src/modules/primitives/query/convertQuantity.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import { DB } from "../generated/kysely-tailordb";
-import type { QueryContext } from "../../shared/internal";
+import type { QueryContext } from "../../../shared";
 import {
   InactiveUnitError,
   IncompatibleUnitsError,
@@ -20,97 +20,112 @@ describe("convertQuantity", () => {
   const ctx: QueryContext = { actorId: "test-actor" };
 
   // Error cases first
-  it("throws when source unit doesn't exist", async () => {
+  it("returns error when source unit doesn't exist", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined);
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: "xyz",
-          targetUnitSymbol: baseUnitGram.symbol,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(UnitNotFoundError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: "xyz",
+        targetUnitSymbol: baseUnitGram.symbol,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnitNotFoundError);
+    }
   });
 
-  it("throws when target unit doesn't exist", async () => {
+  it("returns error when target unit doesn't exist", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseUnitKg) // source unit exists
       .mockReturnValueOnce(undefined); // target unit doesn't exist
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: baseUnitKg.symbol,
-          targetUnitSymbol: "xyz",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(UnitNotFoundError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: baseUnitKg.symbol,
+        targetUnitSymbol: "xyz",
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UnitNotFoundError);
+    }
   });
 
-  it("throws when source unit is inactive", async () => {
+  it("returns error when source unit is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(inactiveUnit) // source unit inactive
       .mockReturnValueOnce(baseUnitGram); // target unit exists
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: inactiveUnit.symbol,
-          targetUnitSymbol: baseUnitGram.symbol,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InactiveUnitError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: inactiveUnit.symbol,
+        targetUnitSymbol: baseUnitGram.symbol,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InactiveUnitError);
+    }
   });
 
-  it("throws when target unit is inactive", async () => {
+  it("returns error when target unit is inactive", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseUnitKg) // source unit exists
       .mockReturnValueOnce(inactiveUnit); // target unit inactive
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: baseUnitKg.symbol,
-          targetUnitSymbol: inactiveUnit.symbol,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(InactiveUnitError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: baseUnitKg.symbol,
+        targetUnitSymbol: inactiveUnit.symbol,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InactiveUnitError);
+    }
   });
 
-  it("throws when units belong to different categories", async () => {
+  it("returns error when units belong to different categories", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select
       .mockReturnValueOnce(baseUnitKg) // Weight category
       .mockReturnValueOnce(baseUnitLiter); // Volume category
 
-    await expect(
-      convertQuantity(
-        db,
-        {
-          quantity: 10,
-          sourceUnitSymbol: baseUnitKg.symbol,
-          targetUnitSymbol: baseUnitLiter.symbol,
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(IncompatibleUnitsError);
+    const result = await convertQuantity(
+      db,
+      {
+        quantity: 10,
+        sourceUnitSymbol: baseUnitKg.symbol,
+        targetUnitSymbol: baseUnitLiter.symbol,
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(IncompatibleUnitsError);
+    }
   });
 
   // Success cases
@@ -128,9 +143,12 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(10);
-    expect(result.sourceUnit).toEqual(baseUnitKg);
-    expect(result.targetUnit).toEqual(baseUnitKg);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(10);
+      expect(result.value.sourceUnit).toEqual(baseUnitKg);
+      expect(result.value.targetUnit).toEqual(baseUnitKg);
+    }
   });
 
   it("converts kg to grams correctly", async () => {
@@ -150,7 +168,10 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(5000); // rounded to 0 decimal places (gram precision)
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(5000); // rounded to 0 decimal places (gram precision)
+    }
   });
 
   it("converts grams to kg correctly", async () => {
@@ -170,7 +191,10 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(2.5); // rounded to 2 decimal places (kg precision)
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(2.5); // rounded to 2 decimal places (kg precision)
+    }
   });
 
   it("converts pounds to kg correctly", async () => {
@@ -190,7 +214,10 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(4.54);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(4.54);
+    }
   });
 
   it("handles zero quantity correctly", async () => {
@@ -207,6 +234,9 @@ describe("convertQuantity", () => {
       ctx,
     );
 
-    expect(result.convertedQuantity).toBe(0);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.convertedQuantity).toBe(0);
+    }
   });
 });

package/src/modules/primitives/query/convertQuantity.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB, QueryContext } from "../../shared/internal";
+import { ok, err, type ReadonlyDB, type QueryContext } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 import {
   InactiveUnitError,
@@ -21,31 +21,33 @@ export interface ConvertQuantityInput {
  */
 export async function run(db: ReadonlyDB<DB>, input: ConvertQuantityInput, ctx: QueryContext) {
   // Validate source unit exists
-  const { unit: sourceUnit } = await getUnit(db, { symbol: input.sourceUnitSymbol }, ctx);
+  const { unit: sourceUnit } = (await getUnit(db, { symbol: input.sourceUnitSymbol }, ctx)).value;
 
   if (!sourceUnit) {
-    throw new UnitNotFoundError(input.sourceUnitSymbol);
+    return err(new UnitNotFoundError(input.sourceUnitSymbol));
   }
 
   // Validate target unit exists
-  const { unit: targetUnit } = await getUnit(db, { symbol: input.targetUnitSymbol }, ctx);
+  const { unit: targetUnit } = (await getUnit(db, { symbol: input.targetUnitSymbol }, ctx)).value;
 
   if (!targetUnit) {
-    throw new UnitNotFoundError(input.targetUnitSymbol);
+    return err(new UnitNotFoundError(input.targetUnitSymbol));
   }
 
   // Validate both units are active
   if (!sourceUnit.isActive) {
-    throw new InactiveUnitError(input.sourceUnitSymbol);
+    return err(new InactiveUnitError(input.sourceUnitSymbol));
   }
 
   if (!targetUnit.isActive) {
-    throw new InactiveUnitError(input.targetUnitSymbol);
+    return err(new InactiveUnitError(input.targetUnitSymbol));
   }
 
   // Validate units belong to the same category
   if (sourceUnit.categoryId !== targetUnit.categoryId) {
-    throw new IncompatibleUnitsError(`${input.sourceUnitSymbol} and ${input.targetUnitSymbol}`);
+    return err(
+      new IncompatibleUnitsError(`${input.sourceUnitSymbol} and ${input.targetUnitSymbol}`),
+    );
   }
 
   // Perform conversion: result = quantity * sourceConversionFactor / targetConversionFactor
@@ -55,9 +57,9 @@ export async function run(db: ReadonlyDB<DB>, input: ConvertQuantityInput, ctx:
   const roundingFactor = Math.pow(10, targetUnit.roundingPrecision);
   const convertedQuantity = Math.round(rawResult * roundingFactor) / roundingFactor;
 
-  return {
+  return ok({
     convertedQuantity,
     sourceUnit,
     targetUnit,
-  };
+  });
 }

package/src/modules/primitives/query/getBaseCurrency.generated.ts

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

package/src/modules/primitives/query/getBaseCurrency.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb } from "../../testing/index";
+import { createMockDb } from "../../../testing/index";
 import type { DB } from "../generated/kysely-tailordb";
-import type { QueryContext } from "../../shared/internal";
+import type { QueryContext } from "../../../shared";
 import { baseCurrencyUSD } from "../testing/fixtures";
 import { getBaseCurrency } from "./getBaseCurrency.generated";
 
@@ -14,7 +14,10 @@ describe("getBaseCurrency", () => {
 
     const result = await getBaseCurrency(db, undefined, ctx);
 
-    expect(result.currency).toEqual(baseCurrencyUSD);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.currency).toEqual(baseCurrencyUSD);
+    }
   });
 
   it("returns null when no base currency is set", async () => {
@@ -23,6 +26,9 @@ describe("getBaseCurrency", () => {
 
     const result = await getBaseCurrency(db, undefined, ctx);
 
-    expect(result.currency).toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.currency).toBeNull();
+    }
   });
 });

package/src/modules/primitives/query/getBaseCurrency.ts

@@ -1,4 +1,4 @@
-import type { ReadonlyDB } from "../../shared/internal";
+import { ok, type ReadonlyDB } from "../../../shared";
 import type { DB } from "../generated/kysely-tailordb";
 
 /**
@@ -12,5 +12,5 @@ export async function run(db: ReadonlyDB<DB>) {
     .where("isBaseCurrency", "=", true)
     .executeTakeFirst();
 
-  return { currency: currency ?? null };
+  return ok({ currency: currency ?? null });
 }

package/src/modules/primitives/query/getCurrency.generated.ts

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

package/src/modules/primitives/query/getCurrency.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 { baseCurrencyUSD } from "../testing/fixtures";
 import { run } from "./getCurrency";
@@ -12,7 +12,10 @@ describe("getCurrency", () => {
 
       const result = await run(db, { id: "currency-usd" });
 
-      expect(result.currency).toEqual(baseCurrencyUSD);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.currency).toEqual(baseCurrencyUSD);
+      }
     });
 
     it("returns null when currency not found", async () => {
@@ -21,7 +24,10 @@ describe("getCurrency", () => {
 
       const result = await run(db, { id: "nonexistent" });
 
-      expect(result.currency).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.currency).toBeNull();
+      }
     });
   });
 
@@ -32,7 +38,10 @@ describe("getCurrency", () => {
 
       const result = await run(db, { code: "USD" });
 
-      expect(result.currency).toEqual(baseCurrencyUSD);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.currency).toEqual(baseCurrencyUSD);
+      }
     });
 
     it("returns null when currency not found", async () => {
@@ -41,7 +50,10 @@ describe("getCurrency", () => {
 
       const result = await run(db, { code: "NONEXISTENT" });
 
-      expect(result.currency).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.currency).toBeNull();
+      }
     });
   });
 });

package/src/modules/primitives/query/getCurrency.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 GetCurrencyInput = { id: string } | { code: string };
@@ -14,5 +14,5 @@ export async function run(db: ReadonlyDB<DB>, input: GetCurrencyInput) {
 
   const currency = await query.executeTakeFirst();
 
-  return { currency: currency ?? null };
+  return ok({ currency: currency ?? null });
 }

package/src/modules/primitives/query/getUnit.generated.ts

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

package/src/modules/primitives/query/getUnit.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 { baseUnitKg } from "../testing/fixtures";
 import { run } from "./getUnit";
@@ -12,7 +12,10 @@ describe("getUnit", () => {
 
       const result = await run(db, { id: "unit-kg" });
 
-      expect(result.unit).toEqual(baseUnitKg);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.unit).toEqual(baseUnitKg);
+      }
     });
 
     it("returns null when unit not found", async () => {
@@ -21,7 +24,10 @@ describe("getUnit", () => {
 
       const result = await run(db, { id: "nonexistent" });
 
-      expect(result.unit).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.unit).toBeNull();
+      }
     });
   });
 
@@ -32,7 +38,10 @@ describe("getUnit", () => {
 
       const result = await run(db, { symbol: "kg" });
 
-      expect(result.unit).toEqual(baseUnitKg);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.unit).toEqual(baseUnitKg);
+      }
     });
 
     it("returns null when unit not found", async () => {
@@ -41,7 +50,10 @@ describe("getUnit", () => {
 
       const result = await run(db, { symbol: "nonexistent" });
 
-      expect(result.unit).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.unit).toBeNull();
+      }
     });
   });
 });

package/src/modules/primitives/query/getUnit.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 GetUnitInput = { id: string } | { symbol: string };
@@ -14,5 +14,5 @@ export async function run(db: ReadonlyDB<DB>, input: GetUnitInput) {
 
   const unit = await query.executeTakeFirst();
 
-  return { unit: unit ?? null };
+  return ok({ unit: unit ?? null });
 }

package/src/modules/primitives/query/getUoMCategory.generated.ts

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

package/src/modules/primitives/query/getUoMCategory.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 { baseUoMCategory } from "../testing/fixtures";
 import { run } from "./getUoMCategory";
@@ -12,7 +12,10 @@ describe("getUoMCategory", () => {
 
       const result = await run(db, { id: "category-1" });
 
-      expect(result.uoMCategory).toEqual(baseUoMCategory);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.uoMCategory).toEqual(baseUoMCategory);
+      }
     });
 
     it("returns null when category not found", async () => {
@@ -21,7 +24,10 @@ describe("getUoMCategory", () => {
 
       const result = await run(db, { id: "nonexistent" });
 
-      expect(result.uoMCategory).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.uoMCategory).toBeNull();
+      }
     });
   });
 
@@ -32,7 +38,10 @@ describe("getUoMCategory", () => {
 
       const result = await run(db, { name: "Weight" });
 
-      expect(result.uoMCategory).toEqual(baseUoMCategory);
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.uoMCategory).toEqual(baseUoMCategory);
+      }
     });
 
     it("returns null when category not found", async () => {
@@ -41,7 +50,10 @@ describe("getUoMCategory", () => {
 
       const result = await run(db, { name: "Nonexistent" });
 
-      expect(result.uoMCategory).toBeNull();
+      expect(result.ok).toBe(true);
+      if (result.ok) {
+        expect(result.value.uoMCategory).toBeNull();
+      }
     });
   });
 });

package/src/modules/primitives/query/getUoMCategory.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 GetUoMCategoryInput = { id: string } | { name: string };
@@ -14,5 +14,5 @@ export async function run(db: ReadonlyDB<DB>, input: GetUoMCategoryInput) {
 
   const uoMCategory = await query.executeTakeFirst();
 
-  return { uoMCategory: uoMCategory ?? null };
+  return ok({ uoMCategory: uoMCategory ?? null });
 }

package/src/modules/primitives/query/listUnitsByCategory.generated.ts

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