@tailor-platform/erp-kit 0.7.0 → 0.9.0

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/sales/module.ts

@@ -176,6 +176,7 @@ export interface DefineModuleParams<
   };
 }
 
+/* @__NO_SIDE_EFFECTS__ */
 export const defineModule = <
   const ChF extends Record<string, TailorAnyDBField> = EmptyFields,
   const LiF extends Record<string, TailorAnyDBField> = EmptyFields,

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

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

@@ -0,0 +1,82 @@
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidEmailError,
+  InvalidNameError,
+  InvalidStatusTransitionError,
+  MissingRequiredFieldError,
+  UserAlreadyExistsError,
+  UserNotFoundError,
+} from "../lib/errors.generated";
+import { ok, err, type CommandContext } from "@tailor-platform/erp-kit/module";
+
+export type UpdateOwnProfileInput = {
+  name?: string;
+  email?: string;
+};
+
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateOwnProfileInput & Omit<Partial<CF>, "status">,
+  ctx: CommandContext,
+) {
+  const { name, email, ...customFields } = input;
+
+  const user = await db
+    .selectFrom("User")
+    .selectAll()
+    .where("id", "=", ctx.actorId)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!user) {
+    return err(new UserNotFoundError(ctx.actorId));
+  }
+
+  if (user.status !== "ACTIVE") {
+    return err(new InvalidStatusTransitionError(`${user.status} to UPDATE_OWN_PROFILE`));
+  }
+
+  if (name === undefined && email === undefined) {
+    return err(new MissingRequiredFieldError("name or email"));
+  }
+
+  if (name?.trim() === "") {
+    return err(new InvalidNameError(name));
+  }
+
+  if (email !== undefined) {
+    if (!EMAIL_PATTERN.test(email)) {
+      return err(new InvalidEmailError(email));
+    }
+
+    // Skip uniqueness check if email is unchanged
+    if (email !== user.email) {
+      const existingUser = await db
+        .selectFrom("User")
+        .selectAll()
+        .where("email", "=", email)
+        .forUpdate()
+        .executeTakeFirst();
+
+      if (existingUser) {
+        return err(new UserAlreadyExistsError(email));
+      }
+    }
+  }
+
+  const updatedUser = await db
+    .updateTable("User")
+    .set({
+      ...(customFields as Record<string, unknown>),
+      ...(name !== undefined ? { name } : {}),
+      ...(email !== undefined ? { email } : {}),
+      updatedAt: new Date(),
+    })
+    .where("id", "=", ctx.actorId)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ user: updatedUser! });
+}

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

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