@tailor-platform/erp-kit 0.7.0 → 0.8.0

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

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

@@ -0,0 +1,195 @@
+import { describe, expect, it } from "vitest";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidEmailError,
+  InvalidNameError,
+  MissingRequiredFieldError,
+  UserAlreadyExistsError,
+  UserNotFoundError,
+} from "../lib/errors.generated";
+import { activeUser, inactiveUser, pendingUser } from "../testing/fixtures";
+import { run } from "./updateUser";
+
+describe("updateUser", () => {
+  // Success cases
+  it("updates user 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, { id: activeUser.id, name: "New Name" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.name).toBe("New Name");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates user email", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...activeUser, email: "newemail@example.com" };
+
+    // First select: find the user being updated; second select: no conflicting email
+    spies.select.mockReturnValueOnce(activeUser);
+    spies.select.mockReturnValueOnce(undefined);
+    spies.update.mockReturnValue(updatedUser);
+
+    const result = await run(db, { id: activeUser.id, email: "newemail@example.com" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.email).toBe("newemail@example.com");
+    }
+    expect(spies.update).toHaveBeenCalled();
+  });
+
+  it("updates both name and email", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...activeUser, name: "New Name", email: "newemail@example.com" };
+
+    // First select: find the user being updated; second select: no conflicting email
+    spies.select.mockReturnValueOnce(activeUser);
+    spies.select.mockReturnValueOnce(undefined);
+    spies.update.mockReturnValue(updatedUser);
+
+    const result = await run(db, {
+      id: activeUser.id,
+      name: "New Name",
+      email: "newemail@example.com",
+    });
+    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("updates user in PENDING status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...pendingUser, name: "Updated Pending" };
+
+    spies.select.mockReturnValue(pendingUser);
+    spies.update.mockReturnValue(updatedUser);
+
+    const result = await run(db, { id: pendingUser.id, name: "Updated Pending" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.name).toBe("Updated Pending");
+    }
+  });
+
+  it("updates user in ACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...activeUser, name: "Updated Active" };
+
+    spies.select.mockReturnValue(activeUser);
+    spies.update.mockReturnValue(updatedUser);
+
+    const result = await run(db, { id: activeUser.id, name: "Updated Active" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.name).toBe("Updated Active");
+    }
+  });
+
+  it("updates user in INACTIVE status", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    const updatedUser = { ...inactiveUser, name: "Updated Inactive" };
+
+    spies.select.mockReturnValue(inactiveUser);
+    spies.update.mockReturnValue(updatedUser);
+
+    const result = await run(db, { id: inactiveUser.id, name: "Updated Inactive" });
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.name).toBe("Updated Inactive");
+    }
+  });
+
+  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);
+
+    // Email matches current — should skip uniqueness check
+    const result = await run(db, { id: activeUser.id, email: activeUser.email });
+    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 user does not exist", async () => {
+    const { db, spies } = createMockDb<Transaction>();
+    spies.select.mockReturnValue(undefined);
+
+    const result = await run(db, { id: "nonexistent-user", name: "Test" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UserNotFoundError);
+    }
+  });
+
+  it("returns error when no fields are provided", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { id: "user-active-1" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
+  });
+
+  it("returns error when name is empty", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { id: "user-active-1", name: "" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("returns error when name is whitespace only", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { id: "user-active-1", name: "   " });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidNameError);
+    }
+  });
+
+  it("returns error when email format is invalid", async () => {
+    const { db } = createMockDb<Transaction>();
+
+    const result = await run(db, { id: "user-active-1", email: "invalidemail" });
+    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 anotherUser = { ...activeUser, id: "other-user", email: "taken@example.com" };
+
+    // First select: find the user being updated
+    spies.select.mockReturnValueOnce(activeUser);
+    // Second select: find the conflicting user with the same email
+    spies.select.mockReturnValueOnce(anotherUser);
+
+    const result = await run(db, { id: activeUser.id, email: "taken@example.com" });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UserAlreadyExistsError);
+    }
+  });
+});

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

@@ -0,0 +1,76 @@
+import { Transaction } from "../generated/kysely-tailordb";
+import {
+  InvalidEmailError,
+  InvalidNameError,
+  MissingRequiredFieldError,
+  UserAlreadyExistsError,
+  UserNotFoundError,
+} from "../lib/errors.generated";
+import { ok, err } from "@tailor-platform/erp-kit/module";
+
+export type UpdateUserInput = { id: string } & { name?: string; email?: string };
+
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+/**
+ * Function: updateUser
+ *
+ * Updates an existing user's name or email.
+ * At least one field must be provided. Email must be unique.
+ */
+export async function run<CF extends Record<string, unknown>>(
+  db: Transaction,
+  input: UpdateUserInput & Omit<Partial<CF>, "status">,
+) {
+  const { id, name, email, ...customFields } = input;
+
+  if (name === undefined && email === undefined && Object.keys(customFields).length === 0) {
+    return err(new MissingRequiredFieldError("name or email"));
+  }
+
+  if (name?.trim() === "") {
+    return err(new InvalidNameError(name));
+  }
+
+  if (email !== undefined && !EMAIL_PATTERN.test(email)) {
+    return err(new InvalidEmailError(email));
+  }
+
+  const user = await db
+    .selectFrom("User")
+    .selectAll()
+    .where("id", "=", id)
+    .forUpdate()
+    .executeTakeFirst();
+
+  if (!user) {
+    return err(new UserNotFoundError(id));
+  }
+
+  if (email !== undefined && 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", "=", id)
+    .returningAll()
+    .executeTakeFirst();
+
+  return ok({ user: updatedUser! });
+}

package/src/modules/user-management/docs/commands/UpdateOwnProfile.md

@@ -0,0 +1,68 @@
+# UpdateOwnProfile
+
+## Overview
+
+UpdateOwnProfile allows an ACTIVE user to update their own profile fields (name, email). The command implicitly targets the calling user — no userId parameter is needed. This provides a self-service update path that is separate from the admin-only updateUser command.
+
+Only ACTIVE users can update their own profile. PENDING and INACTIVE users are rejected.
+
+## Business Rules
+
+- Caller must be an existing user (resolved from context)
+- Caller must be in ACTIVE status
+- At least one field (name or email) must be provided
+- Name, if provided, must be non-empty
+- Email, if provided, must follow valid email format
+- Email must be unique across all users (active and inactive); case-insensitive comparison
+- Generates USER_UPDATED audit event with actor ID, timestamp, and changed fields
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive update request] --> B{Caller user exists?}
+    B -->|No| C[Return error: USER_NOT_FOUND]
+    B -->|Yes| D{Caller status is ACTIVE?}
+    D -->|No| E[Return error: INVALID_STATUS_TRANSITION]
+    D -->|Yes| F{At least one field provided?}
+    F -->|No| G[Return error: MISSING_REQUIRED_FIELD]
+    F -->|Yes| H{Name provided and empty?}
+    H -->|Yes| I[Return error: INVALID_NAME]
+    H -->|No| J{Email provided?}
+    J -->|Yes| K{Valid email format?}
+    K -->|No| L[Return error: INVALID_EMAIL]
+    K -->|Yes| M{Email unique?}
+    M -->|No| N[Return error: USER_ALREADY_EXISTS]
+    M -->|Yes| O[Update user record]
+    J -->|No| O
+    O --> P[Log USER_UPDATED audit event]
+    P --> Q[Return updated user]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **USER_NOT_FOUND**: Caller's user ID does not exist in the system
+- **INVALID_STATUS_TRANSITION**: Caller is not in ACTIVE status (PENDING or INACTIVE)
+- **MISSING_REQUIRED_FIELD**: Neither name nor email was provided in the update input
+- **INVALID_NAME**: Name is empty or whitespace only
+- **INVALID_EMAIL**: Email does not follow valid email format
+- **USER_ALREADY_EXISTS**: Email address is already registered by another user
+
+## Test Cases
+
+- updates own name
+- updates own email
+- updates both own name and email
+- returns error when caller user does not exist
+- returns error when caller is in PENDING status
+- returns error when caller is in INACTIVE status
+- returns error when no fields are provided
+- returns error when name is empty
+- returns error when name is whitespace only
+- returns error when email format is invalid
+- returns error when email is already used by another user
+- succeeds when email is unchanged (same as current)

package/src/modules/user-management/docs/commands/UpdateUser.md

@@ -0,0 +1,67 @@
+# UpdateUser
+
+## Overview
+
+UpdateUser modifies the name or email of an existing user account. This command is intended for administrators who need to update any user's profile regardless of the user's current status (PENDING, ACTIVE, or INACTIVE). Email and name are optional in the update input, but at least one must be provided.
+
+This command supports profile corrections such as legal name changes and email address updates.
+
+## Business Rules
+
+- User must exist
+- At least one field (name or email) must be provided
+- Name, if provided, must be non-empty
+- Email, if provided, must follow valid email format
+- Email must be unique across all users (active and inactive); case-insensitive comparison
+- Updating is allowed on users in any status (PENDING, ACTIVE, INACTIVE)
+- Status is not part of the update input (use activateUser/deactivateUser/reactivateUser for status changes)
+- Generates USER_UPDATED audit event with actor ID, timestamp, and changed fields
+
+## Process Flow
+
+```mermaid
+flowchart TD
+    A[Receive update request] --> B{User exists?}
+    B -->|No| C[Return error: USER_NOT_FOUND]
+    B -->|Yes| D{At least one field provided?}
+    D -->|No| E[Return error: MISSING_REQUIRED_FIELD]
+    D -->|Yes| F{Name provided and empty?}
+    F -->|Yes| G[Return error: INVALID_NAME]
+    F -->|No| H{Email provided?}
+    H -->|Yes| I{Valid email format?}
+    I -->|No| J[Return error: INVALID_EMAIL]
+    I -->|Yes| K{Email unique?}
+    K -->|No| L[Return error: USER_ALREADY_EXISTS]
+    K -->|Yes| M[Update user record]
+    H -->|No| M
+    M --> N[Log USER_UPDATED audit event]
+    N --> O[Return updated user]
+```
+
+## External Dependencies
+
+- None
+
+## Error Scenarios
+
+- **USER_NOT_FOUND**: Specified user ID does not exist in the system
+- **MISSING_REQUIRED_FIELD**: Neither name nor email was provided in the update input
+- **INVALID_NAME**: Name is empty or whitespace only
+- **INVALID_EMAIL**: Email does not follow valid email format
+- **USER_ALREADY_EXISTS**: Email address is already registered by another user
+
+## Test Cases
+
+- updates user name
+- updates user email
+- updates both name and email
+- updates user in PENDING status
+- updates user in ACTIVE status
+- updates user in INACTIVE status
+- returns error when user does not exist
+- returns error when no fields are provided
+- returns error when name is empty
+- returns error when name is whitespace only
+- returns error when email format is invalid
+- returns error when email is already used by another user
+- succeeds when email is unchanged (same as current)