@tailor-platform/erp-kit 0.1.2 → 0.2.0

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

@@ -1,12 +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 { DuplicateRoleNameError, MissingRequiredFieldError } from "../lib/errors";
+import { DuplicateRoleNameError, MissingRequiredFieldError } from "../lib/errors.generated";
 import { baseRole } from "../testing/fixtures";
-import { makeCreateRole } from "./createRole";
-
-const createRole = makeCreateRole();
+import { run } from "./createRole";
 
 describe("createRole", () => {
   const ctx: CommandContext = {
@@ -18,26 +16,32 @@ describe("createRole", () => {
   it("throws when name is empty", async () => {
     const { db } = createMockDb<DB>();
 
-    await expect(createRole(db, { name: "" }, ctx)).rejects.toBeInstanceOf(
-      MissingRequiredFieldError,
-    );
+    const result = await run(db, { name: "" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
   });
 
   it("throws when name is whitespace only", async () => {
     const { db } = createMockDb<DB>();
 
-    await expect(createRole(db, { name: "   " }, ctx)).rejects.toBeInstanceOf(
-      MissingRequiredFieldError,
-    );
+    const result = await run(db, { name: "   " }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
   });
 
   it("throws when role name already exists", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(baseRole);
 
-    await expect(createRole(db, { name: baseRole.name }, ctx)).rejects.toBeInstanceOf(
-      DuplicateRoleNameError,
-    );
+    const result = await run(db, { name: baseRole.name }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(DuplicateRoleNameError);
+    }
   });
 
   // Success cases
@@ -53,9 +57,12 @@ describe("createRole", () => {
     spies.select.mockReturnValue(undefined); // No existing role
     spies.insert.mockReturnValue(createdRole);
 
-    const result = await createRole(db, { name: "Viewer" }, ctx);
+    const result = await run(db, { name: "Viewer" }, ctx);
 
-    expect(result.role.name).toBe("Viewer");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.role.name).toBe("Viewer");
+    }
     expect(spies.insert).toHaveBeenCalled();
   });
 
@@ -71,7 +78,7 @@ describe("createRole", () => {
     spies.select.mockReturnValue(undefined);
     spies.insert.mockReturnValue(createdRole);
 
-    const result = await createRole(
+    const result = await run(
       db,
       {
         name: "Editor",
@@ -80,20 +87,14 @@ describe("createRole", () => {
       ctx,
     );
 
-    expect(result.role.name).toBe("Editor");
-    expect(result.role.description).toBe("Can edit content");
-  });
-
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(createRole(db, { name: "Test" }, denied)).rejects.toBeInstanceOf(
-      InsufficientPermissionError,
-    );
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.role.name).toBe("Editor");
+      expect(result.value.role.description).toBe("Can edit content");
+    }
   });
 
   it("passes custom fields through to insert", async () => {
-    const createRoleWithFields = makeCreateRole<{ department: string }>();
     const { db, spies } = createMockDb<DB>();
     const createdRole = {
       ...baseRole,
@@ -105,7 +106,7 @@ describe("createRole", () => {
     spies.select.mockReturnValue(undefined);
     spies.insert.mockReturnValue(createdRole);
 
-    await createRoleWithFields(db, { name: "Viewer", department: "Engineering" }, ctx);
+    await run(db, { name: "Viewer", department: "Engineering" }, ctx);
 
     expect(spies.values).toHaveBeenNthCalledWith(
       1,

package/src/modules/user-management/command/createRole.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 { DuplicateRoleNameError, MissingRequiredFieldError } from "../lib/errors";
-import { permissions } from "../permissions";
+import { DuplicateRoleNameError, MissingRequiredFieldError } from "../lib/errors.generated";
 
 interface CreateRoleInput {
   name: string;
@@ -14,39 +13,40 @@ interface CreateRoleInput {
  * Creates a new role with the specified name.
  * Validates that the name is unique within the system.
  */
-export function makeCreateRole<CF extends Record<string, unknown>>() {
-  return defineCommand(permissions.createRole, async (db: DB, input: CreateRoleInput & CF) => {
-    const { name, description, ...customFields } = input;
+export async function run<CF extends Record<string, unknown>>(
+  db: DB,
+  input: CreateRoleInput & CF,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _ctx: CommandContext,
+) {
+  const { name, description, ...customFields } = input;
 
-    // 1. Validate name is provided
-    if (!name || name.trim() === "") {
-      throw new MissingRequiredFieldError("name");
-    }
+  if (!name || name.trim() === "") {
+    return err(new MissingRequiredFieldError("name"));
+  }
 
-    // 2. Check if role name already exists
-    const existingRole = await db
-      .selectFrom("Role")
-      .selectAll()
-      .where("name", "=", name)
-      .executeTakeFirst();
+  const existingRole = await db
+    .selectFrom("Role")
+    .selectAll()
+    .where("name", "=", name)
+    .executeTakeFirst();
 
-    if (existingRole) {
-      throw new DuplicateRoleNameError(name);
-    }
+  if (existingRole) {
+    return err(new DuplicateRoleNameError(name));
+  }
 
-    // 3. Create role
-    const role = await db
-      .insertInto("Role")
-      .values({
-        ...(customFields as Record<string, unknown>),
-        name,
-        description: description ?? null,
-        createdAt: new Date(),
-        updatedAt: null,
-      })
-      .returningAll()
-      .executeTakeFirst();
+  // 3. Create role
+  const role = await db
+    .insertInto("Role")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      name,
+      description: description ?? null,
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-    return { role: role! };
-  });
+  return ok({ role: role! });
 }

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

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

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

@@ -1,16 +1,14 @@
 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 {
   InvalidEmailError,
   MissingRequiredFieldError,
   UserAlreadyExistsError,
-} from "../lib/errors";
+} from "../lib/errors.generated";
 import { activeUser, baseAuditEvent, pendingUser } from "../testing/fixtures";
-import { makeCreateUser } from "./createUser";
-
-const createUser = makeCreateUser();
+import { run } from "./createUser";
 
 describe("createUser", () => {
   const ctx: CommandContext = {
@@ -22,50 +20,74 @@ describe("createUser", () => {
   it("throws when email is empty", async () => {
     const { db } = createMockDb<DB>();
 
-    await expect(
-      createUser(db, { email: "", name: "Test User", actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(MissingRequiredFieldError);
+    const result = await run(db, { email: "", name: "Test User", actorId: "actor-1" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
   });
 
   it("throws when name is empty", async () => {
     const { db } = createMockDb<DB>();
 
-    await expect(
-      createUser(db, { email: "test@example.com", name: "", actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(MissingRequiredFieldError);
+    const result = await run(db, { email: "test@example.com", name: "", actorId: "actor-1" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
   });
 
   it("throws when name is whitespace only", async () => {
     const { db } = createMockDb<DB>();
 
-    await expect(
-      createUser(db, { email: "test@example.com", name: "   ", actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(MissingRequiredFieldError);
+    const result = await run(
+      db,
+      { email: "test@example.com", name: "   ", actorId: "actor-1" },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(MissingRequiredFieldError);
+    }
   });
 
   it("throws when email format is invalid (no @)", async () => {
     const { db } = createMockDb<DB>();
 
-    await expect(
-      createUser(db, { email: "invalidemail", name: "Test User", actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(InvalidEmailError);
+    const result = await run(
+      db,
+      { email: "invalidemail", name: "Test User", actorId: "actor-1" },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidEmailError);
+    }
   });
 
   it("throws when email format is invalid (no domain)", async () => {
     const { db } = createMockDb<DB>();
 
-    await expect(
-      createUser(db, { email: "test@", name: "Test User", actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(InvalidEmailError);
+    const result = await run(db, { email: "test@", name: "Test User", actorId: "actor-1" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidEmailError);
+    }
   });
 
   it("throws when email already exists", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(activeUser);
 
-    await expect(
-      createUser(db, { email: activeUser.email, name: "New User", actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(UserAlreadyExistsError);
+    const result = await run(
+      db,
+      { email: activeUser.email, name: "New User", actorId: "actor-1" },
+      ctx,
+    );
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(UserAlreadyExistsError);
+    }
   });
 
   // Success cases
@@ -89,7 +111,7 @@ describe("createUser", () => {
     spies.select.mockReturnValue(undefined); // No existing user
     spies.insert.mockReturnValueOnce(createdUser).mockReturnValueOnce(createdAuditEvent);
 
-    const result = await createUser(
+    const result = await run(
       db,
       {
         email: "new@example.com",
@@ -99,9 +121,12 @@ describe("createUser", () => {
       ctx,
     );
 
-    expect(result.user.email).toBe("new@example.com");
-    expect(result.user.name).toBe("New User");
-    expect(result.user.status).toBe("PENDING");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.email).toBe("new@example.com");
+      expect(result.value.user.name).toBe("New User");
+      expect(result.value.user.status).toBe("PENDING");
+    }
     expect(spies.insert).toHaveBeenCalled();
   });
 
@@ -121,7 +146,7 @@ describe("createUser", () => {
     spies.select.mockReturnValue(undefined);
     spies.insert.mockReturnValueOnce(createdUser).mockReturnValueOnce(createdAuditEvent);
 
-    const result = await createUser(
+    const result = await run(
       db,
       {
         email: "test@example.com",
@@ -131,21 +156,15 @@ describe("createUser", () => {
       ctx,
     );
 
-    expect(result.auditEvent.eventType).toBe("USER_CREATED");
-    expect(result.auditEvent.actorId).toBe("actor-1");
-    expect(result.auditEvent.targetId).toBe(createdUser.id);
-  });
-
-  it("throws when permission is missing", async () => {
-    const { db } = createMockDb<DB>();
-    const denied: CommandContext = { actorId: "test-actor", permissions: [] };
-    await expect(
-      createUser(db, { email: "test@example.com", name: "Test User", actorId: "actor-1" }, denied),
-    ).rejects.toBeInstanceOf(InsufficientPermissionError);
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.auditEvent.eventType).toBe("USER_CREATED");
+      expect(result.value.auditEvent.actorId).toBe("actor-1");
+      expect(result.value.auditEvent.targetId).toBe(createdUser.id);
+    }
   });
 
   it("passes custom fields through to insert", async () => {
-    const createUserWithFields = makeCreateUser<{ department: string }>();
     const { db, spies } = createMockDb<DB>();
     const createdUser = {
       ...pendingUser,
@@ -166,7 +185,7 @@ describe("createUser", () => {
     spies.select.mockReturnValue(undefined);
     spies.insert.mockReturnValueOnce(createdUser).mockReturnValueOnce(createdAuditEvent);
 
-    const result = await createUserWithFields(
+    const result = await run(
       db,
       {
         email: "new@example.com",
@@ -177,7 +196,10 @@ describe("createUser", () => {
       ctx,
     );
 
-    expect(result.user.id).toBe("new-user-id");
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.id).toBe("new-user-id");
+    }
     expect(spies.insert).toHaveBeenCalledTimes(2);
 
     // User insert includes custom field

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

@@ -1,11 +1,10 @@
-import { defineCommand } from "../../shared/internal";
+import { ok, err, type CommandContext } from "../../shared/internal";
 import { DB } from "../generated/kysely-tailordb";
 import {
   InvalidEmailError,
   MissingRequiredFieldError,
   UserAlreadyExistsError,
-} from "../lib/errors";
-import { permissions } from "../permissions";
+} from "../lib/errors.generated";
 
 interface CreateUserInput {
   email: string;
@@ -21,65 +20,64 @@ const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  * Creates a new user account in PENDING status.
  * Validates email format and uniqueness, and logs a USER_CREATED audit event.
  */
-export function makeCreateUser<CF extends Record<string, unknown>>() {
-  return defineCommand(permissions.createUser, async (db: DB, input: CreateUserInput & CF) => {
-    const { email, name, actorId, ...customFields } = input;
+export async function run<CF extends Record<string, unknown>>(
+  db: DB,
+  input: CreateUserInput & CF,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  _ctx: CommandContext,
+) {
+  const { email, name, actorId, ...customFields } = input;
 
-    // 1. Validate email is provided
-    if (!email || email.trim() === "") {
-      throw new MissingRequiredFieldError("email");
-    }
+  if (!email || email.trim() === "") {
+    return err(new MissingRequiredFieldError("email"));
+  }
 
-    // 2. Validate name is provided
-    if (!name || name.trim() === "") {
-      throw new MissingRequiredFieldError("name");
-    }
+  if (!name || name.trim() === "") {
+    return err(new MissingRequiredFieldError("name"));
+  }
 
-    // 3. Validate email format
-    if (!EMAIL_PATTERN.test(email)) {
-      throw new InvalidEmailError(email);
-    }
+  if (!EMAIL_PATTERN.test(email)) {
+    return err(new InvalidEmailError(email));
+  }
 
-    // 4. Check if email already exists
-    const existingUser = await db
-      .selectFrom("User")
-      .selectAll()
-      .where("email", "=", email)
-      .executeTakeFirst();
+  const existingUser = await db
+    .selectFrom("User")
+    .selectAll()
+    .where("email", "=", email)
+    .executeTakeFirst();
 
-    if (existingUser) {
-      throw new UserAlreadyExistsError(email);
-    }
+  if (existingUser) {
+    return err(new UserAlreadyExistsError(email));
+  }
 
-    // 5. Create user with PENDING status
-    const user = await db
-      .insertInto("User")
-      .values({
-        ...(customFields as Record<string, unknown>),
-        email,
-        name,
-        status: "PENDING",
-        createdAt: new Date(),
-        updatedAt: null,
-      })
-      .returningAll()
-      .executeTakeFirst();
+  // 5. Create user with PENDING status
+  const user = await db
+    .insertInto("User")
+    .values({
+      ...(customFields as Record<string, unknown>),
+      email,
+      name,
+      status: "PENDING",
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-    // 6. Log USER_CREATED audit event
-    const auditEvent = await db
-      .insertInto("AuditEvent")
-      .values({
-        eventType: "USER_CREATED",
-        actorId,
-        targetId: user!.id,
-        targetType: "User",
-        payload: JSON.stringify({ email, name, ...customFields }),
-        createdAt: new Date(),
-        updatedAt: null,
-      })
-      .returningAll()
-      .executeTakeFirst();
+  // 6. Log USER_CREATED audit event
+  const auditEvent = await db
+    .insertInto("AuditEvent")
+    .values({
+      eventType: "USER_CREATED",
+      actorId,
+      targetId: user!.id,
+      targetType: "User",
+      payload: JSON.stringify({ email, name, ...customFields }),
+      createdAt: new Date(),
+      updatedAt: null,
+    })
+    .returningAll()
+    .executeTakeFirst();
 
-    return { user: user!, auditEvent: auditEvent! };
-  });
+  return ok({ user: user!, auditEvent: auditEvent! });
 }

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

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

package/src/modules/user-management/command/deactivateUser.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 { deactivateUser } from "./deactivateUser";
+import { run } from "./deactivateUser";
 
 describe("deactivateUser", () => {
   const ctx: CommandContext = {
@@ -14,30 +14,29 @@ describe("deactivateUser", () => {
 
   it(
     "throws when user does not exist",
-    testNotFound(
-      deactivateUser,
-      { userId: "nonexistent-user", actorId: "actor-1" },
-      ctx,
-      UserNotFoundError,
-    ),
+    testNotFound(run, { userId: "nonexistent-user", actorId: "actor-1" }, ctx, UserNotFoundError),
   );
 
   it("throws when user is PENDING", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(pendingUser);
 
-    await expect(
-      deactivateUser(db, { userId: pendingUser.id, actorId: "actor-1" }, ctx),
-    ).rejects.toBeInstanceOf(InvalidStatusTransitionError);
+    const result = await run(db, { userId: pendingUser.id, actorId: "actor-1" }, ctx);
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error).toBeInstanceOf(InvalidStatusTransitionError);
+    }
   });
 
   it("throws when user is already INACTIVE", async () => {
     const { db, spies } = createMockDb<DB>();
     spies.select.mockReturnValue(inactiveUser);
 
-    await expect(
-      deactivateUser(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("deactivateUser", () => {
     spies.update.mockReturnValue(deactivatedUser);
     spies.insert.mockReturnValue(createdAuditEvent);
 
-    const result = await deactivateUser(
+    const result = await run(
       db,
       {
         userId: activeUser.id,
@@ -68,8 +67,11 @@ describe("deactivateUser", () => {
       ctx,
     );
 
-    expect(result.user.status).toBe("INACTIVE");
-    expect(result.user.updatedAt).not.toBeNull();
+    expect(result.ok).toBe(true);
+    if (result.ok) {
+      expect(result.value.user.status).toBe("INACTIVE");
+      expect(result.value.user.updatedAt).not.toBeNull();
+    }
     expect(spies.update).toHaveBeenCalled();
   });
 
@@ -91,7 +93,7 @@ describe("deactivateUser", () => {
     spies.update.mockReturnValue(deactivatedUser);
     spies.insert.mockReturnValue(createdAuditEvent);
 
-    const result = await deactivateUser(
+    const result = await run(
       db,
       {
         userId: activeUser.id,
@@ -100,13 +102,11 @@ describe("deactivateUser", () => {
       ctx,
     );
 
-    expect(result.auditEvent.eventType).toBe("USER_DEACTIVATED");
-    expect(result.auditEvent.actorId).toBe("actor-1");
-    expect(result.auditEvent.targetId).toBe(activeUser.id);
+    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);
+    }
   });
-
-  it(
-    "throws when permission is missing",
-    testPermissionDenied(deactivateUser, { userId: "some-user", actorId: "actor-1" }),
-  );
 });