@tailor-platform/erp-kit 0.1.1 → 0.2.0

package/src/modules/item-management/testing/fixtures.ts

@@ -0,0 +1,81 @@
+import type { Item, ItemTaxonomyAssignment, Schema, TaxonomyNode } from "../lib/types";
+
+// Item fixtures
+export const baseDraftItem = {
+  id: "item-1",
+  sku: "SKU-001",
+  name: "Draft Widget",
+  barcode: null,
+  unitId: "unit-kg",
+  status: "DRAFT",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies Item<Schema>;
+
+export const baseActiveItem = {
+  id: "item-2",
+  sku: "SKU-002",
+  name: "Active Widget",
+  barcode: "BAR-002",
+  unitId: "unit-kg",
+  status: "ACTIVE",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies Item<Schema>;
+
+export const baseInactiveItem = {
+  id: "item-3",
+  sku: "SKU-003",
+  name: "Inactive Widget",
+  barcode: "BAR-003",
+  unitId: "unit-kg",
+  status: "INACTIVE",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies Item<Schema>;
+
+// TaxonomyNode fixtures
+export const baseRootNode = {
+  id: "node-1",
+  code: "ELECTRONICS",
+  name: "Electronics",
+  parentId: null,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies TaxonomyNode<Schema>;
+
+export const baseChildNode = {
+  id: "node-2",
+  code: "SMARTPHONES",
+  name: "Smartphones",
+  parentId: "node-1",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies TaxonomyNode<Schema>;
+
+export const baseLeafNode = {
+  id: "node-3",
+  code: "ANDROID",
+  name: "Android Phones",
+  parentId: "node-2",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies TaxonomyNode<Schema>;
+
+export const secondRootNode = {
+  id: "node-4",
+  code: "GIFTS",
+  name: "Gift Ideas",
+  parentId: null,
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies TaxonomyNode<Schema>;
+
+// ItemTaxonomyAssignment fixtures
+export const baseAssignment = {
+  id: "assignment-1",
+  itemId: "item-2",
+  taxonomyNodeId: "node-2",
+  createdAt: new Date("2024-01-01T00:00:00.000Z"),
+  updatedAt: null,
+} as const satisfies ItemTaxonomyAssignment<Schema>;

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

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

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

@@ -1,15 +1,10 @@
 import { describe, expect, it } from "vitest";
-import {
-  createMockDb,
-  testNotFound,
-  testPermissionDenied,
-  testIdempotent,
-} from "../../testing/index";
+import { createMockDb, testNotFound, testIdempotent } from "../../testing/index";
 import { type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { UoMCategoryNotFoundError } from "../lib/errors";
+import { UomCategoryNotFoundError } from "../lib/errors.generated";
 import { baseUoMCategory } from "../testing/fixtures";
-import { activateCategory } from "./activateCategory";
+import { run } from "./activateCategory";
 
 describe("activateCategory", () => {
   const ctx: CommandContext = {
@@ -24,23 +19,12 @@ describe("activateCategory", () => {
 
   it(
     "throws when category doesn't exist",
-    testNotFound(
-      activateCategory,
-      { categoryId: "nonexistent-category" },
-      ctx,
-      UoMCategoryNotFoundError,
-    ),
+    testNotFound(run, { categoryId: "nonexistent-category" }, ctx, UomCategoryNotFoundError),
   );
 
   it(
     "returns category unchanged when already active",
-    testIdempotent(
-      activateCategory,
-      { categoryId: baseUoMCategory.id },
-      ctx,
-      baseUoMCategory,
-      "category",
-    ),
+    testIdempotent(run, { categoryId: baseUoMCategory.id }, ctx, baseUoMCategory, "uoMCategory"),
   );
 
   // Success cases
@@ -55,7 +39,7 @@ describe("activateCategory", () => {
     spies.select.mockReturnValue(inactiveCategory);
     spies.update.mockReturnValue(activatedCategory);
 
-    const result = await activateCategory(
+    const result = await run(
       db,
       {
         categoryId: inactiveCategory.id,
@@ -63,13 +47,11 @@ describe("activateCategory", () => {
       ctx,
     );
 
-    expect(result.category.isActive).toBe(true);
-    expect(result.category.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.uoMCategory.isActive).toBe(true);
+      expect(result.value.uoMCategory.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it(
-    "throws when permission is missing",
-    testPermissionDenied(activateCategory, { categoryId: "cat-1" }),
-  );
 });

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

@@ -1,7 +1,7 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { UoMCategoryNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { UomCategoryNotFoundError } from "../lib/errors.generated";
+import { getUoMCategory } from "../query/getUoMCategory.generated";
 
 export interface ActivateCategoryInput {
   categoryId: string;
@@ -13,38 +13,31 @@ export interface ActivateCategoryInput {
  * Re-enables a previously deactivated UoM category, making it and its units
  * available for new product assignments and transactions.
  */
-export const activateCategory = defineCommand(
-  permissions.activateCategory,
-  async (db: DB, input: ActivateCategoryInput) => {
-    // 1. Find category by ID
-    const category = await db
-      .selectFrom("UoMCategory")
-      .selectAll()
-      .where("id", "=", input.categoryId)
-      .executeTakeFirst();
+export async function run(db: DB, input: ActivateCategoryInput, ctx: CommandContext) {
+  // 1. Find category by ID
+  const { uoMCategory } = await getUoMCategory(db, { id: input.categoryId }, ctx);
 
-    // 2. If not found, throw error
-    if (!category) {
-      throw new UoMCategoryNotFoundError(input.categoryId);
-    }
+  // 2. If not found, throw error
+  if (!uoMCategory) {
+    return err(new UomCategoryNotFoundError(input.categoryId));
+  }
 
-    // 3. If already active, return category (idempotent)
-    if (category.isActive) {
-      return { category };
-    }
+  // 3. If already active, return category (idempotent)
+  if (uoMCategory.isActive) {
+    return ok({ uoMCategory });
+  }
 
-    // 4. Update isActive = true
-    const updatedCategory = await db
-      .updateTable("UoMCategory")
-      .set({
-        isActive: true,
-        updatedAt: new Date(),
-      })
-      .where("id", "=", input.categoryId)
-      .returningAll()
-      .executeTakeFirst();
+  // 4. Update isActive = true
+  const updatedCategory = await db
+    .updateTable("UoMCategory")
+    .set({
+      isActive: true,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.categoryId)
+    .returningAll()
+    .executeTakeFirst();
 
-    // 5. Return updated category
-    return { category: updatedCategory! };
-  },
-);
+  // 5. Return updated category
+  return ok({ uoMCategory: updatedCategory! });
+}

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

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

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

@@ -1,15 +1,10 @@
 import { describe, expect, it } from "vitest";
-import {
-  createMockDb,
-  testNotFound,
-  testPermissionDenied,
-  testIdempotent,
-} from "../../testing/index";
+import { createMockDb, testNotFound, testIdempotent } from "../../testing/index";
 import { type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { CurrencyNotFoundError } from "../lib/errors";
+import { CurrencyNotFoundError } from "../lib/errors.generated";
 import { baseCurrencyUSD, inactiveCurrency } from "../testing/fixtures";
-import { activateCurrency } from "./activateCurrency";
+import { run } from "./activateCurrency";
 
 describe("activateCurrency", () => {
   const ctx: CommandContext = {
@@ -19,23 +14,12 @@ describe("activateCurrency", () => {
 
   it(
     "throws when currency doesn't exist",
-    testNotFound(
-      activateCurrency,
-      { currencyId: "nonexistent-currency" },
-      ctx,
-      CurrencyNotFoundError,
-    ),
+    testNotFound(run, { currencyId: "nonexistent-currency" }, ctx, CurrencyNotFoundError),
   );
 
   it(
     "returns currency unchanged when already active",
-    testIdempotent(
-      activateCurrency,
-      { currencyId: baseCurrencyUSD.id },
-      ctx,
-      baseCurrencyUSD,
-      "currency",
-    ),
+    testIdempotent(run, { currencyId: baseCurrencyUSD.id }, ctx, baseCurrencyUSD, "currency"),
   );
 
   // Success cases
@@ -50,7 +34,7 @@ describe("activateCurrency", () => {
     spies.select.mockReturnValue(inactiveCurrency);
     spies.update.mockReturnValue(activatedCurrency);
 
-    const result = await activateCurrency(
+    const result = await run(
       db,
       {
         currencyId: inactiveCurrency.id,
@@ -58,13 +42,11 @@ describe("activateCurrency", () => {
       ctx,
     );
 
-    expect(result.currency.isActive).toBe(true);
-    expect(result.currency.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.currency.isActive).toBe(true);
+      expect(result.value.currency.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it(
-    "throws when permission is missing",
-    testPermissionDenied(activateCurrency, { currencyId: "cur-1" }),
-  );
 });

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

@@ -1,7 +1,7 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { CurrencyNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { CurrencyNotFoundError } from "../lib/errors.generated";
+import { getCurrency } from "../query/getCurrency.generated";
 
 export interface ActivateCurrencyInput {
   currencyId: string;
@@ -13,38 +13,31 @@ export interface ActivateCurrencyInput {
  * Re-enables a previously deactivated currency, making it available
  * for new transactions.
  */
-export const activateCurrency = defineCommand(
-  permissions.activateCurrency,
-  async (db: DB, input: ActivateCurrencyInput) => {
-    // 1. Find currency by ID
-    const currency = await db
-      .selectFrom("Currency")
-      .selectAll()
-      .where("id", "=", input.currencyId)
-      .executeTakeFirst();
+export async function run(db: DB, input: ActivateCurrencyInput, ctx: CommandContext) {
+  // 1. Find currency by ID
+  const { currency } = await getCurrency(db, { id: input.currencyId }, ctx);
 
-    // 2. If not found, throw error
-    if (!currency) {
-      throw new CurrencyNotFoundError(input.currencyId);
-    }
+  // 2. If not found, throw error
+  if (!currency) {
+    return err(new CurrencyNotFoundError(input.currencyId));
+  }
 
-    // 3. If already active, return currency (idempotent)
-    if (currency.isActive) {
-      return { currency };
-    }
+  // 3. If already active, return currency (idempotent)
+  if (currency.isActive) {
+    return ok({ currency });
+  }
 
-    // 4. Update isActive = true
-    const updatedCurrency = await db
-      .updateTable("Currency")
-      .set({
-        isActive: true,
-        updatedAt: new Date(),
-      })
-      .where("id", "=", input.currencyId)
-      .returningAll()
-      .executeTakeFirst();
+  // 4. Update isActive = true
+  const updatedCurrency = await db
+    .updateTable("Currency")
+    .set({
+      isActive: true,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.currencyId)
+    .returningAll()
+    .executeTakeFirst();
 
-    // 5. Return updated currency
-    return { currency: updatedCurrency! };
-  },
-);
+  // 5. Return updated currency
+  return ok({ currency: updatedCurrency! });
+}

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

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

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

@@ -1,27 +1,22 @@
 import { describe, expect, it } from "vitest";
-import {
-  createMockDb,
-  testNotFound,
-  testPermissionDenied,
-  testIdempotent,
-} from "../../testing/index";
+import { createMockDb, testNotFound, testIdempotent } from "../../testing/index";
 import { type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { UnitNotFoundError } from "../lib/errors";
+import { UnitNotFoundError } from "../lib/errors.generated";
 import { baseUnitKg, inactiveUnit } from "../testing/fixtures";
-import { activateUnit } from "./activateUnit";
+import { run } from "./activateUnit";
 
 describe("activateUnit", () => {
   const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:activateUnit"] };
 
   it(
     "throws when unit doesn't exist",
-    testNotFound(activateUnit, { unitId: "nonexistent-unit" }, ctx, UnitNotFoundError),
+    testNotFound(run, { unitId: "nonexistent-unit" }, ctx, UnitNotFoundError),
   );
 
   it(
     "returns unit unchanged when already active",
-    testIdempotent(activateUnit, { unitId: baseUnitKg.id }, ctx, baseUnitKg, "unit"),
+    testIdempotent(run, { unitId: baseUnitKg.id }, ctx, baseUnitKg, "unit"),
   );
 
   // Success cases
@@ -36,7 +31,7 @@ describe("activateUnit", () => {
     spies.select.mockReturnValue(inactiveUnit);
     spies.update.mockReturnValue(activatedUnit);
 
-    const result = await activateUnit(
+    const result = await run(
       db,
       {
         unitId: inactiveUnit.id,
@@ -44,10 +39,11 @@ describe("activateUnit", () => {
       ctx,
     );
 
-    expect(result.unit.isActive).toBe(true);
-    expect(result.unit.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.unit.isActive).toBe(true);
+      expect(result.value.unit.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it("throws when permission is missing", testPermissionDenied(activateUnit, { unitId: "unit-1" }));
 });

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

@@ -1,7 +1,7 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { UnitNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { UnitNotFoundError } from "../lib/errors.generated";
+import { getUnit } from "../query/getUnit.generated";
 
 export interface ActivateUnitInput {
   unitId: string;
@@ -13,38 +13,31 @@ export interface ActivateUnitInput {
  * Re-enables a previously deactivated unit of measure, making it available
  * for new product assignments and quantity conversions.
  */
-export const activateUnit = defineCommand(
-  permissions.activateUnit,
-  async (db: DB, input: ActivateUnitInput) => {
-    // 1. Find unit by ID
-    const unit = await db
-      .selectFrom("Unit")
-      .selectAll()
-      .where("id", "=", input.unitId)
-      .executeTakeFirst();
+export async function run(db: DB, input: ActivateUnitInput, ctx: CommandContext) {
+  // 1. Find unit by ID
+  const { unit } = await getUnit(db, { id: input.unitId }, ctx);
 
-    // 2. If not found, throw error
-    if (!unit) {
-      throw new UnitNotFoundError(input.unitId);
-    }
+  // 2. If not found, throw error
+  if (!unit) {
+    return err(new UnitNotFoundError(input.unitId));
+  }
 
-    // 3. If already active, return unit (idempotent)
-    if (unit.isActive) {
-      return { unit };
-    }
+  // 3. If already active, return unit (idempotent)
+  if (unit.isActive) {
+    return ok({ unit });
+  }
 
-    // 4. Update isActive = true
-    const updatedUnit = await db
-      .updateTable("Unit")
-      .set({
-        isActive: true,
-        updatedAt: new Date(),
-      })
-      .where("id", "=", input.unitId)
-      .returningAll()
-      .executeTakeFirst();
+  // 4. Update isActive = true
+  const updatedUnit = await db
+    .updateTable("Unit")
+    .set({
+      isActive: true,
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.unitId)
+    .returningAll()
+    .executeTakeFirst();
 
-    // 5. Return updated unit
-    return { unit: updatedUnit! };
-  },
-);
+  // 5. Return updated unit
+  return ok({ unit: updatedUnit! });
+}

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

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

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

@@ -1,12 +1,10 @@
 import { describe, expect, it } from "vitest";
 import { createMockDb } from "../../testing/index";
-import { InsufficientPermissionError, type CommandContext } from "../../shared/internal";
+import { type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { DuplicateCategoryNameError } from "../lib/errors";
+import { DuplicateCategoryNameError } from "../lib/errors.generated";
 import { baseUoMCategory, baseUnitKg } from "../testing/fixtures";
-import { makeCreateCategory } from "./createCategory";
-
-const createCategory = makeCreateCategory();
+import { run } from "./createCategory";
 
 describe("createCategory", () => {
   const ctx: CommandContext = { actorId: "test-actor", permissions: ["primitives:createCategory"] };
@@ -16,20 +14,23 @@ describe("createCategory", () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(baseUoMCategory);
 
-    await expect(
-      createCategory(
-        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,
-      ),
-    ).rejects.toBeInstanceOf(DuplicateCategoryNameError);
+      },
+      ctx,
+    );
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateCategoryNameError);
+    }
   });
 
   // Success cases
@@ -50,7 +51,7 @@ describe("createCategory", () => {
     spies.insert.mockReturnValueOnce(createdCategory).mockReturnValueOnce(createdUnit);
     spies.update.mockReturnValue({ ...createdCategory, referenceUnitId: "new-unit-id" });
 
-    const result = await createCategory(
+    const result = await run(
       db,
       {
         name: "Weight",
@@ -64,29 +65,16 @@ describe("createCategory", () => {
       ctx,
     );
 
-    expect(result.category.name).toBe("Weight");
-    expect(result.category.isActive).toBe(true);
-    expect(result.referenceUnit.conversionFactor).toBe(1.0);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.uoMCategory.name).toBe("Weight");
+      expect(result.value.uoMCategory.isActive).toBe(true);
+      expect(result.value.referenceUnit.conversionFactor).toBe(1.0);
+    }
     expect(spies.insert).toHaveBeenCalled();
   });
 
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      createCategory(
-        db,
-        { name: "Test", referenceUnit: { name: "Unit", symbol: "u", roundingPrecision: 2 } },
-        denied,
-      ),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
-  });
-
   it("passes custom fields through to insert", async () => {
-    const createCategoryWithFields = makeCreateCategory<
-      { priority: number },
-      { tolerance: number }
-    >();
     const { db, spies } = createMockDb<DB>();
     const createdCategory = {
       ...baseUoMCategory,
@@ -103,7 +91,7 @@ describe("createCategory", () => {
     spies.insert.mockReturnValueOnce(createdCategory).mockReturnValueOnce(createdUnit);
     spies.update.mockReturnValue({ ...createdCategory, referenceUnitId: "new-unit-id" });
 
-    await createCategoryWithFields(
+    await run(
       db,
       {
         name: "Weight",