@tailor-platform/erp-kit 0.2.1 → 0.3.0

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

@@ -1,27 +1,21 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb, testNotFound } from "../../testing/index";
-import { type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb, testNotFound } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import { InvalidStatusTransitionError, UserNotFoundError } from "../lib/errors.generated";
-import { activeUser, baseAuditEvent, inactiveUser, pendingUser } from "../testing/fixtures";
+import { activeUser, inactiveUser, pendingUser } from "../testing/fixtures";
 import { run } from "./deactivateUser";
 
 describe("deactivateUser", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["user-management:deactivateUser"],
-  };
-
   it(
     "throws when user does not exist",
-    testNotFound(run, { userId: "nonexistent-user", actorId: "actor-1" }, ctx, UserNotFoundError),
+    testNotFound(run, { userId: "nonexistent-user" }, UserNotFoundError),
   );
 
   it("throws when user is PENDING", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(pendingUser);
 
-    const result = await run(db, { userId: pendingUser.id, actorId: "actor-1" }, ctx);
+    const result = await run(db, { userId: pendingUser.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
@@ -29,10 +23,10 @@ describe("deactivateUser", () => {
   });
 
   it("throws when user is already INACTIVE", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(inactiveUser);
 
-    const result = await run(db, { userId: inactiveUser.id, actorId: "actor-1" }, ctx);
+    const result = await run(db, { userId: inactiveUser.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
@@ -41,31 +35,19 @@ describe("deactivateUser", () => {
 
   // Success cases
   it("deactivates ACTIVE user to INACTIVE", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const deactivatedUser = {
       ...activeUser,
       status: "INACTIVE" as const,
       updatedAt: new Date("2024-01-15T00:00:00.000Z"),
     };
-    const createdAuditEvent = {
-      ...baseAuditEvent,
-      eventType: "USER_DEACTIVATED" as const,
-      actorId: "actor-1",
-      targetId: activeUser.id,
-    };
 
     spies.select.mockReturnValue(activeUser);
     spies.update.mockReturnValue(deactivatedUser);
-    spies.insert.mockReturnValue(createdAuditEvent);
 
-    const result = await run(
-      db,
-      {
-        userId: activeUser.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      userId: activeUser.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -74,39 +56,4 @@ describe("deactivateUser", () => {
     }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it("logs USER_DEACTIVATED audit event", async () => {
-    const { db, spies } = createMockDb<DB>();
-    const deactivatedUser = {
-      ...activeUser,
-      status: "INACTIVE" as const,
-      updatedAt: new Date("2024-01-15T00:00:00.000Z"),
-    };
-    const createdAuditEvent = {
-      ...baseAuditEvent,
-      eventType: "USER_DEACTIVATED" as const,
-      actorId: "actor-1",
-      targetId: activeUser.id,
-    };
-
-    spies.select.mockReturnValue(activeUser);
-    spies.update.mockReturnValue(deactivatedUser);
-    spies.insert.mockReturnValue(createdAuditEvent);
-
-    const result = await run(
-      db,
-      {
-        userId: activeUser.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
-
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.value.auditEvent.eventType).toBe("USER_DEACTIVATED");
-      expect(result.value.auditEvent.actorId).toBe("actor-1");
-      expect(result.value.auditEvent.targetId).toBe(activeUser.id);
-    }
-  });
 });

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

@@ -1,10 +1,9 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import { InvalidStatusTransitionError, UserNotFoundError } from "../lib/errors.generated";
 
 export interface DeactivateUserInput {
   userId: string;
-  actorId: string;
   from?: string[];
 }
 
@@ -12,14 +11,14 @@ export interface DeactivateUserInput {
  * Function: deactivateUser
  *
  * Transitions a user from ACTIVE to INACTIVE status.
- * Role assignments are preserved for audit purposes.
+ * Role assignments are preserved.
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function run(db: DB, input: DeactivateUserInput, _ctx: CommandContext) {
+export async function run(db: Transaction, input: DeactivateUserInput) {
   const user = await db
     .selectFrom("User")
     .selectAll()
     .where("id", "=", input.userId)
+    .forUpdate()
     .executeTakeFirst();
 
   if (!user) {
@@ -41,19 +40,5 @@ export async function run(db: DB, input: DeactivateUserInput, _ctx: CommandConte
     .returningAll()
     .executeTakeFirst();
 
-  const auditEvent = await db
-    .insertInto("AuditEvent")
-    .values({
-      eventType: "USER_DEACTIVATED",
-      actorId: input.actorId,
-      targetId: input.userId,
-      targetType: "User",
-      payload: JSON.stringify({ previousStatus: user.status }),
-      createdAt: new Date(),
-      updatedAt: null,
-    })
-    .returningAll()
-    .executeTakeFirst();
-
-  return ok({ user: updatedUser!, auditEvent: auditEvent! });
+  return ok({ user: updatedUser! });
 }

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./reactivateUser";
 

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

@@ -1,23 +1,17 @@
 import { describe, expect, it } from "vitest";
-import { type CommandContext } from "../../shared/internal";
-import { createMockDb } from "../../testing/index";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import { InvalidStatusTransitionError, UserNotFoundError } from "../lib/errors.generated";
-import { activeUser, baseAuditEvent, inactiveUser, pendingUser } from "../testing/fixtures";
+import { activeUser, inactiveUser, pendingUser } from "../testing/fixtures";
 import { run } from "./reactivateUser";
 
 describe("reactivateUser", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["user-management:reactivateUser"],
-  };
-
   // Error cases
   it("throws when user does not exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(db, { userId: "nonexistent-user", actorId: "actor-1" }, ctx);
+    const result = await run(db, { userId: "nonexistent-user" });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(UserNotFoundError);
@@ -25,10 +19,10 @@ describe("reactivateUser", () => {
   });
 
   it("throws when user is PENDING", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(pendingUser);
 
-    const result = await run(db, { userId: pendingUser.id, actorId: "actor-1" }, ctx);
+    const result = await run(db, { userId: pendingUser.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
@@ -36,10 +30,10 @@ describe("reactivateUser", () => {
   });
 
   it("throws when user is already ACTIVE", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(activeUser);
 
-    const result = await run(db, { userId: activeUser.id, actorId: "actor-1" }, ctx);
+    const result = await run(db, { userId: activeUser.id });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
@@ -48,31 +42,19 @@ describe("reactivateUser", () => {
 
   // Success cases
   it("reactivates INACTIVE user to ACTIVE", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     const reactivatedUser = {
       ...inactiveUser,
       status: "ACTIVE" as const,
       updatedAt: new Date("2024-01-15T00:00:00.000Z"),
     };
-    const createdAuditEvent = {
-      ...baseAuditEvent,
-      eventType: "USER_REACTIVATED" as const,
-      actorId: "actor-1",
-      targetId: inactiveUser.id,
-    };
 
     spies.select.mockReturnValue(inactiveUser);
     spies.update.mockReturnValue(reactivatedUser);
-    spies.insert.mockReturnValue(createdAuditEvent);
 
-    const result = await run(
-      db,
-      {
-        userId: inactiveUser.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      userId: inactiveUser.id,
+    });
 
     expect(result.ok).toBe(true);
     if (result.ok) {
@@ -81,39 +63,4 @@ describe("reactivateUser", () => {
     }
     expect(spies.update).toHaveBeenCalled();
   });
-
-  it("logs USER_REACTIVATED audit event", async () => {
-    const { db, spies } = createMockDb<DB>();
-    const reactivatedUser = {
-      ...inactiveUser,
-      status: "ACTIVE" as const,
-      updatedAt: new Date("2024-01-15T00:00:00.000Z"),
-    };
-    const createdAuditEvent = {
-      ...baseAuditEvent,
-      eventType: "USER_REACTIVATED" as const,
-      actorId: "actor-1",
-      targetId: inactiveUser.id,
-    };
-
-    spies.select.mockReturnValue(inactiveUser);
-    spies.update.mockReturnValue(reactivatedUser);
-    spies.insert.mockReturnValue(createdAuditEvent);
-
-    const result = await run(
-      db,
-      {
-        userId: inactiveUser.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
-
-    expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.value.auditEvent.eventType).toBe("USER_REACTIVATED");
-      expect(result.value.auditEvent.actorId).toBe("actor-1");
-      expect(result.value.auditEvent.targetId).toBe(inactiveUser.id);
-    }
-  });
 });

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

@@ -1,10 +1,9 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import { InvalidStatusTransitionError, UserNotFoundError } from "../lib/errors.generated";
 
 export interface ReactivateUserInput {
   userId: string;
-  actorId: string;
   from?: string[];
 }
 
@@ -14,12 +13,12 @@ export interface ReactivateUserInput {
  * Transitions a user from INACTIVE back to ACTIVE status.
  * Restores access for previously deactivated users.
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function run(db: DB, input: ReactivateUserInput, _ctx: CommandContext) {
+export async function run(db: Transaction, input: ReactivateUserInput) {
   const user = await db
     .selectFrom("User")
     .selectAll()
     .where("id", "=", input.userId)
+    .forUpdate()
     .executeTakeFirst();
 
   if (!user) {
@@ -41,19 +40,5 @@ export async function run(db: DB, input: ReactivateUserInput, _ctx: CommandConte
     .returningAll()
     .executeTakeFirst();
 
-  const auditEvent = await db
-    .insertInto("AuditEvent")
-    .values({
-      eventType: "USER_REACTIVATED",
-      actorId: input.actorId,
-      targetId: input.userId,
-      targetType: "User",
-      payload: JSON.stringify({ previousStatus: user.status }),
-      createdAt: new Date(),
-      updatedAt: null,
-    })
-    .returningAll()
-    .executeTakeFirst();
-
-  return ok({ user: updatedUser!, auditEvent: auditEvent! });
+  return ok({ user: updatedUser! });
 }

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./revokePermissionFromRole";
 

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

@@ -1,34 +1,23 @@
 import { describe, expect, it } from "vitest";
-import { type CommandContext } from "../../shared/internal";
-import { createMockDb } from "../../testing/index";
-import { DB } from "../generated/kysely-tailordb";
+import { createMockDb } from "../../../testing/index";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   AssignmentNotFoundError,
   PermissionNotFoundError,
   RoleNotFoundError,
 } from "../lib/errors.generated";
-import { baseAuditEvent, basePermission, baseRole, baseRolePermission } from "../testing/fixtures";
+import { basePermission, baseRole, baseRolePermission } from "../testing/fixtures";
 import { run } from "./revokePermissionFromRole";
 
 describe("revokePermissionFromRole", () => {
-  const ctx: CommandContext = {
-    actorId: "test-actor",
-    permissions: ["user-management:revokePermissionFromRole"],
-  };
-
   it("throws when role does not exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValue(undefined);
 
-    const result = await run(
-      db,
-      {
-        roleId: "nonexistent-role",
-        permissionId: basePermission.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      roleId: "nonexistent-role",
+      permissionId: basePermission.id,
+    });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(RoleNotFoundError);
@@ -36,18 +25,13 @@ describe("revokePermissionFromRole", () => {
   });
 
   it("throws when permission does not exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select.mockReturnValueOnce(baseRole).mockReturnValueOnce(undefined);
 
-    const result = await run(
-      db,
-      {
-        roleId: baseRole.id,
-        permissionId: "nonexistent-permission",
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      roleId: baseRole.id,
+      permissionId: "nonexistent-permission",
+    });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(PermissionNotFoundError);
@@ -55,59 +39,37 @@ describe("revokePermissionFromRole", () => {
   });
 
   it("throws when assignment does not exist", async () => {
-    const { db, spies } = createMockDb<DB>();
+    const { db, spies } = createMockDb<Transaction>();
     spies.select
       .mockReturnValueOnce(baseRole)
       .mockReturnValueOnce(basePermission)
       .mockReturnValueOnce(undefined);
 
-    const result = await run(
-      db,
-      {
-        roleId: baseRole.id,
-        permissionId: basePermission.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      roleId: baseRole.id,
+      permissionId: basePermission.id,
+    });
     expect(result.ok).toBe(false);
     if (!result.ok) {
       expect(result.error).toBeInstanceOf(AssignmentNotFoundError);
     }
   });
 
-  it("deletes RolePermission and logs PERMISSION_REVOKED event", async () => {
-    const { db, spies } = createMockDb<DB>();
-    const createdAuditEvent = {
-      ...baseAuditEvent,
-      eventType: "PERMISSION_REVOKED" as const,
-      actorId: "actor-1",
-      targetId: baseRole.id,
-      targetType: "Role",
-    };
+  it("deletes RolePermission", async () => {
+    const { db, spies } = createMockDb<Transaction>();
 
     spies.select
       .mockReturnValueOnce(baseRole)
       .mockReturnValueOnce(basePermission)
       .mockReturnValueOnce(baseRolePermission);
     spies.delete.mockReturnValue(baseRolePermission);
-    spies.insert.mockReturnValue(createdAuditEvent);
 
-    const result = await run(
-      db,
-      {
-        roleId: baseRole.id,
-        permissionId: basePermission.id,
-        actorId: "actor-1",
-      },
-      ctx,
-    );
+    const result = await run(db, {
+      roleId: baseRole.id,
+      permissionId: basePermission.id,
+    });
 
     expect(result.ok).toBe(true);
-    if (result.ok) {
-      expect(result.value.auditEvent.eventType).toBe("PERMISSION_REVOKED");
-      expect(result.value.auditEvent.targetId).toBe(baseRole.id);
-    }
     expect(spies.delete).toHaveBeenCalled();
   });
 });

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

@@ -1,5 +1,5 @@
-import { ok, err, type CommandContext } from "../../shared/internal";
-import { DB } from "../generated/kysely-tailordb";
+import { ok, err } from "../../../shared";
+import { Transaction } from "../generated/kysely-tailordb";
 import {
   AssignmentNotFoundError,
   PermissionNotFoundError,
@@ -9,7 +9,6 @@ import {
 export interface RevokePermissionFromRoleInput {
   roleId: string;
   permissionId: string;
-  actorId: string;
 }
 
 /**
@@ -20,8 +19,7 @@ export interface RevokePermissionFromRoleInput {
  *
  * Note: Permissions for affected users are recomputed asynchronously via executor.
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function run(db: DB, input: RevokePermissionFromRoleInput, _ctx: CommandContext) {
+export async function run(db: Transaction, input: RevokePermissionFromRoleInput) {
   const role = await db
     .selectFrom("Role")
     .selectAll()
@@ -47,6 +45,7 @@ export async function run(db: DB, input: RevokePermissionFromRoleInput, _ctx: Co
     .selectAll()
     .where("roleId", "=", input.roleId)
     .where("permissionId", "=", input.permissionId)
+    .forUpdate()
     .executeTakeFirst();
 
   if (!existingAssignment) {
@@ -62,23 +61,5 @@ export async function run(db: DB, input: RevokePermissionFromRoleInput, _ctx: Co
     .returningAll()
     .executeTakeFirst();
 
-  const auditEvent = await db
-    .insertInto("AuditEvent")
-    .values({
-      eventType: "PERMISSION_REVOKED",
-      actorId: input.actorId,
-      targetId: input.roleId,
-      targetType: "Role",
-      payload: JSON.stringify({
-        roleId: input.roleId,
-        permissionId: input.permissionId,
-        permissionKey: permission.key,
-      }),
-      createdAt: new Date(),
-      updatedAt: null,
-    })
-    .returningAll()
-    .executeTakeFirst();
-
-  return ok({ auditEvent: auditEvent! });
+  return ok({});
 }

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

@@ -1,5 +1,5 @@
 // @generated — do not edit
-import { defineCommand } from "../../shared/internal";
+import { defineCommand } from "../../../shared";
 import { permissions } from "../lib/permissions.generated";
 import { run } from "./revokeRoleFromUser";