@tailor-platform/erp-kit 0.1.2 → 0.2.0

package/src/modules/testing/index.ts

@@ -1,6 +1,13 @@
 import { vi, expect } from "vitest";
 import type { Kysely } from "kysely";
-import { InsufficientPermissionError, type CommandContext, type Command } from "../shared/internal";
+import {
+  InsufficientPermissionError,
+  type CommandContext,
+  type Command,
+  type Result,
+  type ErrorOf,
+  type ValueOf,
+} from "../shared/internal";
 
 export type Spy = ReturnType<typeof vi.fn>;
 
@@ -82,39 +89,57 @@ export function createMockDb<T = Kysely<Record<string, unknown>>>(): {
   };
 }
 
-export function testNotFound<TInput>(
-  command: Command<TInput, unknown>,
+export function testNotFound<TInput, TReturn extends Result<unknown, Error>>(
+  command: Command<TInput, TReturn>,
   input: TInput,
   ctx: CommandContext,
-  ErrorClass: abstract new (...args: never[]) => Error,
+  expectedError: abstract new (...args: never[]) => ErrorOf<TReturn>,
 ) {
   return async () => {
     const { db, spies } = createMockDb();
     spies.select.mockReturnValue(undefined);
-    await expect(command(db, input, ctx)).rejects.toBeInstanceOf(ErrorClass);
+    const result = await command(db, input, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(expectedError);
+    }
   };
 }
 
-export function testPermissionDenied<TInput>(command: Command<TInput, unknown>, input: TInput) {
+export function testPermissionDenied<TInput, TReturn extends Result<unknown, Error>>(
+  command: Command<TInput, TReturn>,
+  input: TInput,
+) {
   return async () => {
     const { db } = createMockDb();
     const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(command(db, input, denied)).rejects.toBeInstanceOf(InsufficientPermissionError);
+    const result = await command(db, input, denied);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InsufficientPermissionError);
+    }
   };
 }
 
-export function testIdempotent<TInput>(
-  command: Command<TInput, Record<string, unknown>>,
+export function testIdempotent<
+  TInput,
+  TReturn extends Result<Record<string, unknown>, Error>,
+  TKey extends string & keyof ValueOf<TReturn>,
+>(
+  command: Command<TInput, TReturn>,
   input: TInput,
   ctx: CommandContext,
   existingEntity: Record<string, unknown>,
-  entityKey: string,
+  entityKey: TKey,
 ) {
   return async () => {
     const { db, spies } = createMockDb();
     spies.select.mockReturnValue(existingEntity);
     const result = await command(db, input, ctx);
-    expect(result[entityKey]).toEqual(existingEntity);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value[entityKey]).toEqual(existingEntity);
+    }
     expect(spies.update).not.toHaveBeenCalled();
   };
 }

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

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

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

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { createMockDb, testNotFound, testPermissionDenied } from "../../testing/index";
+import { createMockDb, testNotFound } from "../../testing/index";
 import { type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { InvalidStatusTransitionError, UserNotFoundError } from "../lib/errors";
+import { InvalidStatusTransitionError, UserNotFoundError } from "../lib/errors.generated";
 import { activeUser, baseAuditEvent, inactiveUser, pendingUser } from "../testing/fixtures";
-import { activateUser } from "./activateUser";
+import { run } from "./activateUser";
 
 describe("activateUser", () => {
   const ctx: CommandContext = {
@@ -14,30 +14,29 @@ describe("activateUser", () => {
 
   it(
     "throws when user does not exist",
-    testNotFound(
-      activateUser,
-      { userId: "nonexistent-user", actorId: "actor-1" },
-      ctx,
-      UserNotFoundError,
-    ),
+    testNotFound(run, { userId: "nonexistent-user", actorId: "actor-1" }, ctx, UserNotFoundError),
   );
 
   it("throws when user is already ACTIVE", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(activeUser);
 
-    await expect(
-      activateUser(db, { userId: activeUser.id, actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(InvalidStatusTransitionError);
+    const result = await run(db, { userId: activeUser.id, actorId: "actor-1" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
+    }
   });
 
   it("throws when user is INACTIVE (use reactivateUser instead)", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(inactiveUser);
 
-    await expect(
-      activateUser(db, { userId: inactiveUser.id, actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(InvalidStatusTransitionError);
+    const result = await run(db, { userId: inactiveUser.id, actorId: "actor-1" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
+    }
   });
 
   // Success cases
@@ -59,7 +58,7 @@ describe("activateUser", () => {
     spies.update.mockReturnValue(activatedUser);
     spies.insert.mockReturnValue(createdAuditEvent);
 
-    const result = await activateUser(
+    const result = await run(
       db,
       {
         userId: pendingUser.id,
@@ -68,8 +67,11 @@ describe("activateUser", () => {
       ctx,
     );
 
-    expect(result.user.status).toBe("ACTIVE");
-    expect(result.user.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.status).toBe("ACTIVE");
+      expect(result.value.user.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
 
@@ -91,7 +93,7 @@ describe("activateUser", () => {
     spies.update.mockReturnValue(activatedUser);
     spies.insert.mockReturnValue(createdAuditEvent);
 
-    const result = await activateUser(
+    const result = await run(
       db,
       {
         userId: pendingUser.id,
@@ -100,13 +102,11 @@ describe("activateUser", () => {
       ctx,
     );
 
-    expect(result.auditEvent.eventType).toBe("USER_ACTIVATED");
-    expect(result.auditEvent.actorId).toBe("actor-1");
-    expect(result.auditEvent.targetId).toBe(pendingUser.id);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.auditEvent.eventType).toBe("USER_ACTIVATED");
+      expect(result.value.auditEvent.actorId).toBe("actor-1");
+      expect(result.value.auditEvent.targetId).toBe(pendingUser.id);
+    }
   });
-
-  it(
-    "throws when permission is missing",
-    testPermissionDenied(activateUser, { userId: "some-user", actorId: "actor-1" }),
-  );
 });

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

@@ -1,7 +1,6 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { InvalidStatusTransitionError, UserNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { InvalidStatusTransitionError, UserNotFoundError } from "../lib/errors.generated";
 
 export interface ActivateUserInput {
   userId: string;
@@ -15,53 +14,46 @@ export interface ActivateUserInput {
  * Transitions a user from PENDING to ACTIVE status.
  * Only PENDING users can be activated; use reactivateUser for INACTIVE users.
  */
-export const activateUser = defineCommand(
-  permissions.activateUser,
-  async (db: DB, input: ActivateUserInput) => {
-    // 1. Find user by ID
-    const user = await db
-      .selectFrom("User")
-      .selectAll()
-      .where("id", "=", input.userId)
-      .executeTakeFirst();
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function run(db: DB, input: ActivateUserInput, _ctx: CommandContext) {
+  const user = await db
+    .selectFrom("User")
+    .selectAll()
+    .where("id", "=", input.userId)
+    .executeTakeFirst();
 
-    // 2. If not found, throw error
-    if (!user) {
-      throw new UserNotFoundError(input.userId);
-    }
+  if (!user) {
+    return err(new UserNotFoundError(input.userId));
+  }
 
-    // 3. Validate status transition
-    const validFromStatuses = input.from ?? ["PENDING"];
-    if (!validFromStatuses.includes(user.status)) {
-      throw new InvalidStatusTransitionError(user.status, "ACTIVE");
-    }
+  const validFromStatuses = input.from ?? ["PENDING"];
+  if (!validFromStatuses.includes(user.status)) {
+    return err(new InvalidStatusTransitionError(`${user.status} to ACTIVE`));
+  }
 
-    // 4. Update status to ACTIVE
-    const updatedUser = await db
-      .updateTable("User")
-      .set({
-        status: "ACTIVE",
-        updatedAt: new Date(),
-      })
-      .where("id", "=", input.userId)
-      .returningAll()
-      .executeTakeFirst();
+  const updatedUser = await db
+    .updateTable("User")
+    .set({
+      status: "ACTIVE",
+      updatedAt: new Date(),
+    })
+    .where("id", "=", input.userId)
+    .returningAll()
+    .executeTakeFirst();
 
-    // 5. Log USER_ACTIVATED audit event
-    const auditEvent = await db
-      .insertInto("AuditEvent")
-      .values({
-        eventType: "USER_ACTIVATED",
-        actorId: input.actorId,
-        targetId: input.userId,
-        targetType: "User",
-        payload: JSON.stringify({ previousStatus: user.status }),
-        createdAt: new Date(),
-        updatedAt: null,
-      })
-      .returningAll()
-      .executeTakeFirst();
+  const auditEvent = await db
+    .insertInto("AuditEvent")
+    .values({
+      eventType: "USER_ACTIVATED",
+      actorId: input.actorId,
+      targetId: input.userId,
+      targetType: "User",
+      payload: JSON.stringify({ previousStatus: user.status }),
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-    return { user: updatedUser!, auditEvent: auditEvent! };
-  },
-);
+  return ok({ user: updatedUser!, auditEvent: auditEvent! });
+}

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

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

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

@@ -1,10 +1,10 @@
 import { describe, expect, it } from "vitest";
-import { InsufficientPermissionError, type CommandContext } from "../../shared/internal";
+import { type CommandContext } from "../../shared/internal";
 import { createMockDb } from "../../testing/index";
 import { DB } from "../generated/kysely-tailordb";
-import { PermissionNotFoundError, RoleNotFoundError } from "../lib/errors";
+import { PermissionNotFoundError, RoleNotFoundError } from "../lib/errors.generated";
 import { baseAuditEvent, basePermission, baseRole, baseRolePermission } from "../testing/fixtures";
-import { assignPermissionToRole } from "./assignPermissionToRole";
+import { run } from "./assignPermissionToRole";
 
 describe("assignPermissionToRole", () => {
   const ctx: CommandContext = {
@@ -16,17 +16,19 @@ describe("assignPermissionToRole", () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(undefined);
 
-    await expect(
-      assignPermissionToRole(
-        db,
-        {
-          roleId: "nonexistent-role",
-          permissionId: basePermission.id,
-          actorId: "actor-1",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(RoleNotFoundError);
+    const result = await run(
+      db,
+      {
+        roleId: "nonexistent-role",
+        permissionId: basePermission.id,
+        actorId: "actor-1",
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(RoleNotFoundError);
+    }
   });
 
   it("throws when permission does not exist", async () => {
@@ -35,17 +37,19 @@ describe("assignPermissionToRole", () => {
       .mockReturnValueOnce(baseRole) // Role found
       .mockReturnValueOnce(undefined); // Permission not found
 
-    await expect(
-      assignPermissionToRole(
-        db,
-        {
-          roleId: baseRole.id,
-          permissionId: "nonexistent-permission",
-          actorId: "actor-1",
-        },
-        ctx,
-      ),
-    ).rejects.toBeInstanceOf(PermissionNotFoundError);
+    const result = await run(
+      db,
+      {
+        roleId: baseRole.id,
+        permissionId: "nonexistent-permission",
+        actorId: "actor-1",
+      },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(PermissionNotFoundError);
+    }
   });
 
   it("returns success when assignment already exists (idempotent)", async () => {
@@ -55,7 +59,7 @@ describe("assignPermissionToRole", () => {
       .mockReturnValueOnce(basePermission) // Permission found
       .mockReturnValueOnce(baseRolePermission); // Assignment already exists
 
-    const result = await assignPermissionToRole(
+    const result = await run(
       db,
       {
         roleId: baseRole.id,
@@ -65,7 +69,10 @@ describe("assignPermissionToRole", () => {
       ctx,
     );
 
-    expect(result.rolePermission).toEqual(baseRolePermission);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.rolePermission).toEqual(baseRolePermission);
+    }
     expect(spies.insert).not.toHaveBeenCalled();
   });
 
@@ -89,7 +96,7 @@ describe("assignPermissionToRole", () => {
       .mockReturnValueOnce(undefined); // No existing assignment
     spies.insert.mockReturnValueOnce(newRolePermission).mockReturnValueOnce(createdAuditEvent);
 
-    const result = await assignPermissionToRole(
+    const result = await run(
       db,
       {
         roleId: baseRole.id,
@@ -99,21 +106,13 @@ describe("assignPermissionToRole", () => {
       ctx,
     );
 
-    expect(result.rolePermission.roleId).toBe(baseRole.id);
-    expect(result.rolePermission.permissionId).toBe(basePermission.id);
-    expect(result.auditEvent?.eventType).toBe("PERMISSION_ASSIGNED");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.rolePermission.roleId).toBe(baseRole.id);
+      expect(result.value.rolePermission.permissionId).toBe(basePermission.id);
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+      expect((result.value as any).auditEvent?.eventType).toBe("PERMISSION_ASSIGNED");
+    }
     expect(spies.insert).toHaveBeenCalled();
   });
-
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      assignPermissionToRole(
-        db,
-        { roleId: "role-1", permissionId: "perm-1", actorId: "actor-1" },
-        denied,
-      ),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
-  });
 });

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

@@ -1,7 +1,6 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
-import { PermissionNotFoundError, RoleNotFoundError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { PermissionNotFoundError, RoleNotFoundError } from "../lib/errors.generated";
 
 export interface AssignPermissionToRoleInput {
   roleId: string;
@@ -17,71 +16,69 @@ export interface AssignPermissionToRoleInput {
  *
  * Note: Permissions for affected users are recomputed asynchronously via executor.
  */
-export const assignPermissionToRole = defineCommand(
-  permissions.assignPermissionToRole,
-  async (db: DB, input: AssignPermissionToRoleInput) => {
-    const role = await db
-      .selectFrom("Role")
-      .selectAll()
-      .where("id", "=", input.roleId)
-      .executeTakeFirst();
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function run(db: DB, input: AssignPermissionToRoleInput, _ctx: CommandContext) {
+  const role = await db
+    .selectFrom("Role")
+    .selectAll()
+    .where("id", "=", input.roleId)
+    .executeTakeFirst();
 
-    if (!role) {
-      throw new RoleNotFoundError(input.roleId);
-    }
+  if (!role) {
+    return err(new RoleNotFoundError(input.roleId));
+  }
 
-    const permission = await db
-      .selectFrom("Permission")
-      .selectAll()
-      .where("id", "=", input.permissionId)
-      .executeTakeFirst();
+  const permission = await db
+    .selectFrom("Permission")
+    .selectAll()
+    .where("id", "=", input.permissionId)
+    .executeTakeFirst();
 
-    if (!permission) {
-      throw new PermissionNotFoundError(input.permissionId);
-    }
+  if (!permission) {
+    return err(new PermissionNotFoundError(input.permissionId));
+  }
 
-    // Idempotent: return existing assignment without creating duplicates
-    const existingAssignment = await db
-      .selectFrom("RolePermission")
-      .selectAll()
-      .where("roleId", "=", input.roleId)
-      .where("permissionId", "=", input.permissionId)
-      .executeTakeFirst();
+  // Idempotent: return existing assignment without creating duplicates
+  const existingAssignment = await db
+    .selectFrom("RolePermission")
+    .selectAll()
+    .where("roleId", "=", input.roleId)
+    .where("permissionId", "=", input.permissionId)
+    .executeTakeFirst();
 
-    if (existingAssignment) {
-      return { rolePermission: existingAssignment };
-    }
+  if (existingAssignment) {
+    return ok({ rolePermission: existingAssignment });
+  }
 
-    // Permission recomputation for affected users is handled asynchronously by executor
-    const rolePermission = await db
-      .insertInto("RolePermission")
-      .values({
+  // Permission recomputation for affected users is handled asynchronously by executor
+  const rolePermission = await db
+    .insertInto("RolePermission")
+    .values({
+      roleId: input.roleId,
+      permissionId: input.permissionId,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
+
+  const auditEvent = await db
+    .insertInto("AuditEvent")
+    .values({
+      eventType: "PERMISSION_ASSIGNED",
+      actorId: input.actorId,
+      targetId: input.roleId,
+      targetType: "Role",
+      payload: JSON.stringify({
         roleId: input.roleId,
         permissionId: input.permissionId,
-        createdAt: new Date(),
-        updatedAt: null,
-      })
-      .returningAll()
-      .executeTakeFirst();
-
-    const auditEvent = await db
-      .insertInto("AuditEvent")
-      .values({
-        eventType: "PERMISSION_ASSIGNED",
-        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();
+        permissionKey: permission.key,
+      }),
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-    return { rolePermission: rolePermission!, auditEvent: auditEvent! };
-  },
-);
+  return ok({ rolePermission: rolePermission!, auditEvent: auditEvent! });
+}

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

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