@tailor-platform/erp-kit 0.6.0 → 0.8.0

package/src/modules/sales/command/updateSalesCreditNote.test.ts

@@ -37,7 +37,7 @@ describe("updateSalesCreditNote", () => {
     expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ reason: "Updated" }));
   });
 
-  it("throws when updating an issued credit note", async () => {
+  it("returns error when updating an issued credit note", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(issuedCreditNote);
 
@@ -50,7 +50,7 @@ describe("updateSalesCreditNote", () => {
     expectErr(result, CreditNoteNotEditableError);
   });
 
-  it("throws when correction content is invalid", async () => {
+  it("returns error when correction content is invalid", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseCreditNote);
 

package/src/modules/sales/command/updateSalesCreditNote.ts

@@ -7,12 +7,11 @@ import {
 import { type SalesCreditNoteLineInput } from "../lib/domain";
 import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateSalesCreditNoteInput {
+export type UpdateSalesCreditNoteInput = {
   salesCreditNoteId: string;
   reason?: string | null;
   lines?: SalesCreditNoteLineInput[];
-}
-
+};
 export async function run(db: Transaction, input: UpdateSalesCreditNoteInput, ctx: CommandContext) {
   void ctx;
   const salesCreditNote = await db

package/src/modules/sales/command/updateSalesInvoice.test.ts

@@ -42,7 +42,7 @@ describe("updateSalesInvoice", () => {
     expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ notes: "Updated" }));
   });
 
-  it("throws when updating an issued invoice", async () => {
+  it("returns error when updating an issued invoice", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(issuedSalesInvoice);
 
@@ -55,7 +55,7 @@ describe("updateSalesInvoice", () => {
     expectErr(result, InvoiceNotEditableError);
   });
 
-  it("throws when updated line content is invalid", async () => {
+  it("returns error when updated line content is invalid", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseSalesInvoice);
 

package/src/modules/sales/command/updateSalesInvoice.ts

@@ -7,13 +7,12 @@ import {
 import { encodeJson, type SalesInvoiceLineInput } from "../lib/domain";
 import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateSalesInvoiceInput {
+export type UpdateSalesInvoiceInput = {
   salesInvoiceId: string;
   invoiceDate?: Date;
   notes?: string | null;
   lines?: SalesInvoiceLineInput[];
-}
-
+};
 export async function run(db: Transaction, input: UpdateSalesInvoiceInput, ctx: CommandContext) {
   void ctx;
   const salesInvoice = await db

package/src/modules/sales/command/updateSalesOrder.test.ts

@@ -64,7 +64,7 @@ describe("updateSalesOrder", () => {
     );
   });
 
-  it("throws when the order does not exist", async () => {
+  it("returns error when the order does not exist", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(undefined);
 
@@ -73,7 +73,7 @@ describe("updateSalesOrder", () => {
     expectErr(result, SalesOrderNotFoundError);
   });
 
-  it("throws when updating a non-draft order", async () => {
+  it("returns error when updating a non-draft order", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce({ ...baseSalesOrder, status: "SUBMITTED" });
 
@@ -82,7 +82,7 @@ describe("updateSalesOrder", () => {
     expectErr(result, OrderNotEditableError);
   });
 
-  it("throws when the update would remove all lines", async () => {
+  it("returns error when the update would remove all lines", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseSalesOrder);
 

package/src/modules/sales/command/updateSalesOrder.ts

@@ -11,7 +11,7 @@ import {
 import { encodeJson, type SalesOrderLineInput } from "../lib/domain";
 import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateSalesOrderInput {
+export type UpdateSalesOrderInput = {
   salesOrderId: string;
   customerId?: string;
   paymentTermId?: string | null;
@@ -20,8 +20,7 @@ export interface UpdateSalesOrderInput {
   shippingAddressSnapshot?: Record<string, unknown> | null;
   billingAddressSnapshot?: Record<string, unknown> | null;
   lines?: SalesOrderLineInput[];
-}
-
+};
 export async function run(db: Transaction, input: UpdateSalesOrderInput, ctx: CommandContext) {
   void ctx;
   const salesOrder = await db

package/src/modules/sales/command/updateSalesPaymentTerm.test.ts

@@ -38,7 +38,7 @@ describe("updateSalesPaymentTerm", () => {
     expect(spies.set).toHaveBeenCalledWith(expect.objectContaining({ name: "Installments" }));
   });
 
-  it("throws when SalesPaymentTerm does not exist", async () => {
+  it("returns error when SalesPaymentTerm does not exist", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(undefined);
 
@@ -51,7 +51,7 @@ describe("updateSalesPaymentTerm", () => {
     expectErr(result, SalespaymenttermNotFoundError);
   });
 
-  it("throws when SalesPaymentTerm is not editable", async () => {
+  it("returns error when SalesPaymentTerm is not editable", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(inactivePaymentTerm);
 

package/src/modules/sales/command/updateSalesPaymentTerm.ts

@@ -11,14 +11,13 @@ import {
 } from "../lib/domain";
 import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateSalesPaymentTermInput {
+export type UpdateSalesPaymentTermInput = {
   salesPaymentTermId: string;
   name?: string;
   code?: string | null;
   scheduleLines?: PaymentTermScheduleLineInput[];
   notes?: string | null;
-}
-
+};
 export async function run(
   db: Transaction,
   input: UpdateSalesPaymentTermInput,

package/src/modules/sales/command/updateSalesPriceList.test.ts

@@ -30,7 +30,7 @@ describe("updateSalesPriceList", () => {
     expectOk(result);
   });
 
-  it("throws when SalesPriceList does not exist", async () => {
+  it("returns error when SalesPriceList does not exist", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(undefined);
 
@@ -43,7 +43,7 @@ describe("updateSalesPriceList", () => {
     expectErr(result, SalespricelistNotFoundError);
   });
 
-  it("throws when SalesPriceList is not editable", async () => {
+  it("returns error when SalesPriceList is not editable", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce({ ...basePriceList, status: "INACTIVE" });
 
@@ -56,7 +56,7 @@ describe("updateSalesPriceList", () => {
     expectErr(result, SalespricelistNotEditableError);
   });
 
-  it("throws when the company backing the price list does not exist", async () => {
+  it("returns error when the company backing the price list does not exist", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(draftPriceList).mockReturnValueOnce(undefined);
 

package/src/modules/sales/command/updateSalesPriceList.ts

@@ -6,14 +6,13 @@ import {
 } from "../lib/errors.generated";
 import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateSalesPriceListInput {
+export type UpdateSalesPriceListInput = {
   salesPriceListId: string;
   name?: string;
   code?: string | null;
   priority?: number;
   notes?: string | null;
-}
-
+};
 export async function run(db: Transaction, input: UpdateSalesPriceListInput, ctx: CommandContext) {
   void ctx;
   const salesPriceList = await db

package/src/modules/sales/command/updateSalesPriceRule.test.ts

@@ -32,7 +32,7 @@ describe("updateSalesPriceRule", () => {
     expectOk(result);
   });
 
-  it("throws when SalesPriceRule does not exist", async () => {
+  it("returns error when SalesPriceRule does not exist", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(undefined);
 
@@ -45,7 +45,7 @@ describe("updateSalesPriceRule", () => {
     expectErr(result, SalespriceruleNotFoundError);
   });
 
-  it("throws when SalesPriceRule is not editable", async () => {
+  it("returns error when SalesPriceRule is not editable", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce({ ...basePriceRule, status: "INACTIVE" });
 
@@ -58,7 +58,7 @@ describe("updateSalesPriceRule", () => {
     expectErr(result, SalespriceruleNotEditableError);
   });
 
-  it("throws when the parent price list does not exist", async () => {
+  it("returns error when the parent price list does not exist", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(draftPriceRule).mockReturnValueOnce(undefined);
 

package/src/modules/sales/command/updateSalesPriceRule.ts

@@ -8,7 +8,7 @@ import {
 } from "../lib/errors.generated";
 import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateSalesPriceRuleInput {
+export type UpdateSalesPriceRuleInput = {
   salesPriceRuleId: string;
   salesPriceListId?: string;
   customerId?: string | null;
@@ -21,8 +21,7 @@ export interface UpdateSalesPriceRuleInput {
   effectiveTo?: Date | null;
   priority?: number;
   notes?: string | null;
-}
-
+};
 export async function run(db: Transaction, input: UpdateSalesPriceRuleInput, ctx: CommandContext) {
   void ctx;
   const salesPriceRule = await db

package/src/modules/sales/command/updateShipment.test.ts

@@ -41,7 +41,7 @@ describe("updateShipment", () => {
     );
   });
 
-  it("throws when updating a posted shipment", async () => {
+  it("returns error when updating a posted shipment", async () => {
     const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(postedShipment);
 
@@ -54,7 +54,7 @@ describe("updateShipment", () => {
     expectErr(result, ShipmentNotEditableError);
   });
 
-  it("throws when updated quantity exceeds remaining order quantity", async () => {
+  it("returns error when updated quantity exceeds remaining order quantity", async () => {
     const { db, spies } = createMockDb<Transaction>();
     const orderLine = {
       ...baseSalesOrderLine,

package/src/modules/sales/command/updateShipment.ts

@@ -7,14 +7,13 @@ import {
 import { encodeJson, type ShipmentLineInput } from "../lib/domain";
 import { err, ok, type CommandContext } from "@tailor-platform/erp-kit/module";
 
-export interface UpdateShipmentInput {
+export type UpdateShipmentInput = {
   shipmentId: string;
   shipFromSiteId?: string | null;
   trackingNumber?: string | null;
   shippingAddressSnapshot?: Record<string, unknown> | null;
   lines?: ShipmentLineInput[];
-}
-
+};
 export async function run(db: Transaction, input: UpdateShipmentInput, ctx: CommandContext) {
   void ctx;
   const shipment = await db

package/src/modules/sales/docs/commands/UpdateChannel.md

@@ -37,7 +37,7 @@ flowchart TD
 ## Test Cases
 
 - updates mutable Channel fields
-- throws when Channel does not exist
-- throws when Channel is not editable
-- throws when the resulting channel type is empty
-- throws when the updated channel name conflicts within the company
+- returns error when Channel does not exist
+- returns error when Channel is not editable
+- returns error when the resulting channel type is empty
+- returns error when the updated channel name conflicts within the company

package/src/modules/sales/docs/commands/UpdateListing.md

@@ -34,5 +34,5 @@ flowchart TD
 ## Test Cases
 
 - updates listing metadata while listing remains active or paused
-- throws when listing is retired
-- throws when updated external identifier conflicts with another listing
+- returns error when listing is retired
+- returns error when updated external identifier conflicts with another listing

package/src/modules/sales/docs/commands/UpdateSalesCreditNote.md

@@ -34,5 +34,5 @@ flowchart TD
 ## Test Cases
 
 - updates draft credit-note lines
-- throws when updating an issued credit note
-- throws when correction content is invalid
+- returns error when updating an issued credit note
+- returns error when correction content is invalid

package/src/modules/sales/docs/commands/UpdateSalesInvoice.md

@@ -34,5 +34,5 @@ flowchart TD
 ## Test Cases
 
 - updates draft invoice metadata
-- throws when updating an issued invoice
-- throws when updated line content is invalid
+- returns error when updating an issued invoice
+- returns error when updated line content is invalid

package/src/modules/sales/docs/commands/UpdateSalesOrder.md

@@ -40,6 +40,6 @@ flowchart TD
 
 - updates mutable draft order header fields
 - updates draft order lines and preserves line integrity
-- throws when the order does not exist
-- throws when updating a non-draft order
-- throws when the update would remove all lines
+- returns error when the order does not exist
+- returns error when updating a non-draft order
+- returns error when the update would remove all lines

package/src/modules/sales/docs/commands/UpdateSalesPaymentTerm.md

@@ -37,5 +37,5 @@ flowchart TD
 ## Test Cases
 
 - updates mutable SalesPaymentTerm fields
-- throws when SalesPaymentTerm does not exist
-- throws when SalesPaymentTerm is not editable
+- returns error when SalesPaymentTerm does not exist
+- returns error when SalesPaymentTerm is not editable

package/src/modules/sales/docs/commands/UpdateSalesPriceList.md

@@ -35,6 +35,6 @@ flowchart TD
 ## Test Cases
 
 - updates mutable SalesPriceList fields
-- throws when SalesPriceList does not exist
-- throws when SalesPriceList is not editable
-- throws when the company backing the price list does not exist
+- returns error when SalesPriceList does not exist
+- returns error when SalesPriceList is not editable
+- returns error when the company backing the price list does not exist

package/src/modules/sales/docs/commands/UpdateSalesPriceRule.md

@@ -42,8 +42,8 @@ flowchart TD
 ## Test Cases
 
 - updates mutable SalesPriceRule fields
-- throws when SalesPriceRule does not exist
-- throws when SalesPriceRule is not editable
-- throws when the parent price list does not exist
+- returns error when SalesPriceRule does not exist
+- returns error when SalesPriceRule is not editable
+- returns error when the parent price list does not exist
 - throws on invalid unit price
 - throws on invalid effective date range

package/src/modules/sales/docs/commands/UpdateShipment.md

@@ -34,5 +34,5 @@ flowchart TD
 ## Test Cases
 
 - updates draft shipment metadata
-- throws when updating a posted shipment
-- throws when updated quantity exceeds remaining order quantity
+- returns error when updating a posted shipment
+- returns error when updated quantity exceeds remaining order quantity

package/src/modules/user-management/README.md

@@ -8,7 +8,8 @@ This module serves as a foundational component that other modules depend on for
 
 ## Key Features
 
-- **User Account Lifecycle**: Create, activate, deactivate, and reactivate user accounts with clear status transitions (PENDING, ACTIVE, INACTIVE)
+- **User Account Lifecycle**: Create, update, activate, deactivate, and reactivate user accounts with clear status transitions (PENDING, ACTIVE, INACTIVE)
+- **Self-Service Profile Update**: Users can update their own profile (name, email) via a dedicated command that implicitly targets the calling user
 - **Email Uniqueness**: Enforce unique email addresses across all user accounts
 - **Role-Based Access Control**: Define roles that bundle permissions, and assign roles to users for scalable authorization
 - **Permission Management**: Define granular permissions using a `resource:action` format (e.g., `orders:read`, `inventory:write`)

package/src/modules/user-management/command/updateOwnProfile.generated.ts

@@ -0,0 +1,6 @@
+// @generated — do not edit
+import { permissions } from "../lib/permissions.generated";
+import { run } from "./updateOwnProfile";
+import { defineCommand } from "@tailor-platform/erp-kit/module";
+
+export const updateOwnProfile = defineCommand(permissions.updateOwnProfile, run);

package/src/modules/user-management/command/updateOwnProfile.test.ts

@@ -0,0 +1,191 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import type { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidEmailError,
+  InvalidNameError,
+  InvalidStatusTransitionError,
+  MissingRequiredFieldError,
+  UserAlreadyExistsError,
+  UserNotFoundError,
+} from "../lib/errors.generated";
+import { activeUser, inactiveUser, pendingUser } from "../testing/fixtures";
+import { run } from "./updateOwnProfile";
+import type { CommandContext } from "@tailor-platform/erp-kit/module";
+
+describe("updateOwnProfile", () => {
+  const ctx = { actorId: activeUser.id } as CommandContext;
+
+  // Success cases
+  it("updates own name", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...activeUser, name: "New Name" };
+
+    spies.select.mockReturnValue(activeUser);
+    spies.update.mockReturnValue(updatedUser);
+
+    const result = await run(db, { name: "New Name" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.name).toBe("New Name");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates own email", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...activeUser, email: "newemail@example.com" };
+
+    spies.select.mockReturnValue(activeUser);
+    // Email uniqueness check returns no existing user
+    spies.select.mockReturnValueOnce(activeUser).mockReturnValueOnce(undefined);
+    spies.update.mockReturnValue(updatedUser);
+
+    const result = await run(db, { email: "newemail@example.com" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.email).toBe("newemail@example.com");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates both own name and email", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...activeUser, name: "New Name", email: "newemail@example.com" };
+
+    spies.select.mockReturnValueOnce(activeUser).mockReturnValueOnce(undefined);
+    spies.update.mockReturnValue(updatedUser);
+
+    const result = await run(db, { name: "New Name", email: "newemail@example.com" }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.name).toBe("New Name");
+      expect(result.value.user.email).toBe("newemail@example.com");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("succeeds when email is unchanged (same as current)", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...activeUser };
+
+    spies.select.mockReturnValue(activeUser);
+    spies.update.mockReturnValue(updatedUser);
+
+    // Using the same email as the active user — no uniqueness check needed
+    const result = await run(db, { email: activeUser.email }, ctx);
+
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.email).toBe(activeUser.email);
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  // Error cases
+  it("returns error when caller user does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { name: "New Name" }, {
+      actorId: "nonexistent",
+    } as CommandContext);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UserNotFoundError);
+    }
+  });
+
+  it("returns error when caller is in PENDING status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(pendingUser);
+
+    const pendingCtx = { actorId: pendingUser.id } as CommandContext;
+    const result = await run(db, { name: "New Name" }, pendingCtx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
+    }
+  });
+
+  it("returns error when caller is in INACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(inactiveUser);
+
+    const inactiveCtx = { actorId: inactiveUser.id } as CommandContext;
+    const result = await run(db, { name: "New Name" }, inactiveCtx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
+    }
+  });
+
+  it("returns error when no fields are provided", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(activeUser);
+
+    const result = await run(db, {}, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
+  });
+
+  it("returns error when name is empty", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(activeUser);
+
+    const result = await run(db, { name: "" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("returns error when name is whitespace only", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(activeUser);
+
+    const result = await run(db, { name: "   " }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("returns error when email format is invalid", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(activeUser);
+
+    const result = await run(db, { email: "invalidemail" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidEmailError);
+    }
+  });
+
+  it("returns error when email is already used by another user", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const otherUser = { ...activeUser, id: "other-user", email: "taken@example.com" };
+
+    // First select: find the caller user; second select: email uniqueness check finds another user
+    spies.select.mockReturnValueOnce(activeUser).mockReturnValueOnce(otherUser);
+
+    const result = await run(db, { email: "taken@example.com" }, ctx);
+
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UserAlreadyExistsError);
+    }
+  });
+});