alepha 0.14.1 → 0.14.3

package/src/api/users/controllers/AdminUserController.spec.ts

@@ -0,0 +1,372 @@
+import { Alepha } from "alepha";
+import { DbEntityNotFoundError } from "alepha/orm";
+import { AlephaSecurity } from "alepha/security";
+import { BadRequestError } from "alepha/server";
+import { describe, it } from "vitest";
+import { AdminUserController, AlephaApiUsers, UserService } from "../index.ts";
+
+const setup = async () => {
+  const alepha = Alepha.create({
+    env: { LOG_LEVEL: "error" },
+  });
+
+  alepha.with(AlephaSecurity);
+  alepha.with(AlephaApiUsers);
+
+  await alepha.start();
+
+  return {
+    alepha,
+    userService: alepha.inject(UserService),
+    controller: alepha.inject(AdminUserController),
+  };
+};
+
+describe("alepha/api/users - AdminUserController CRUD", () => {
+  it("should create a new user", async ({ expect }) => {
+    const { controller } = await setup();
+
+    const result = await controller.createUser({
+      body: {
+        username: "newuser",
+        email: "newuser@example.com",
+        phoneNumber: "+1234567890",
+        firstName: "New",
+        lastName: "User",
+        enabled: true,
+      },
+    });
+
+    expect(result.username).toBe("newuser");
+    expect(result.email).toBe("newuser@example.com");
+    expect(result.phoneNumber).toBe("+1234567890");
+    expect(result.firstName).toBe("New");
+    expect(result.lastName).toBe("User");
+    expect(result.enabled).toBe(true);
+    expect(result.emailVerified).toBe(false);
+    expect(result.roles).toEqual(["user"]);
+    expect(result.id).toBeDefined();
+  });
+
+  it("should create a user with custom roles", async ({ expect }) => {
+    const { controller } = await setup();
+
+    const result = await controller.createUser({
+      body: {
+        username: "admin",
+        email: "admin@example.com",
+        roles: ["admin", "user"],
+      },
+    });
+
+    expect(result.username).toBe("admin");
+    expect(result.email).toBe("admin@example.com");
+    expect(result.roles).toEqual(["admin", "user"]);
+  });
+
+  it("should reject duplicate username", async ({ expect }) => {
+    const { controller } = await setup();
+
+    await controller.createUser({
+      body: {
+        username: "duplicateuser",
+        email: "duplicate@example.com",
+      },
+    });
+
+    await expect(
+      controller.createUser({
+        body: {
+          username: "duplicateuser",
+          email: "duplicate2@example.com",
+        },
+      }),
+    ).rejects.toThrowError(BadRequestError);
+  });
+
+  it("should get a user by ID", async ({ expect }) => {
+    const { controller } = await setup();
+
+    const created = await controller.createUser({
+      body: {
+        username: "getuser",
+        email: "getuser@example.com",
+        firstName: "Get",
+        lastName: "User",
+      },
+    });
+
+    const result = await controller.getUser({
+      params: { id: created.id },
+    });
+
+    expect(result.id).toBe(created.id);
+    expect(result.username).toBe("getuser");
+    expect(result.email).toBe("getuser@example.com");
+    expect(result.firstName).toBe("Get");
+    expect(result.lastName).toBe("User");
+  });
+
+  it("should throw error for non-existent user", async ({ expect }) => {
+    const { controller } = await setup();
+
+    await expect(
+      controller.getUser({
+        params: { id: "550e8400-e29b-41d4-a716-446655440000" },
+      }),
+    ).rejects.toThrowError(DbEntityNotFoundError);
+  });
+
+  it("should update a user", async ({ expect }) => {
+    const { controller } = await setup();
+
+    const created = await controller.createUser({
+      body: {
+        username: "updateuser",
+        email: "updateuser@example.com",
+        firstName: "Original",
+        lastName: "Name",
+      },
+    });
+
+    const result = await controller.updateUser({
+      params: { id: created.id },
+      body: {
+        firstName: "Updated",
+        lastName: "User",
+      },
+    });
+
+    expect(result.id).toBe(created.id);
+    expect(result.username).toBe("updateuser");
+    expect(result.email).toBe("updateuser@example.com");
+    expect(result.firstName).toBe("Updated");
+    expect(result.lastName).toBe("User");
+  });
+
+  it("should update user roles", async ({ expect }) => {
+    const { controller } = await setup();
+
+    const created = await controller.createUser({
+      body: {
+        username: "roleupdate",
+        email: "roleupdate@example.com",
+      },
+    });
+
+    expect(created.roles).toEqual(["user"]);
+
+    const result = await controller.updateUser({
+      params: { id: created.id },
+      body: {
+        roles: ["admin", "moderator"],
+      },
+    });
+
+    expect(result.roles).toEqual(["admin", "moderator"]);
+  });
+
+  it("should delete a user", async ({ expect }) => {
+    const { controller } = await setup();
+
+    const created = await controller.createUser({
+      body: {
+        username: "deleteuser",
+        email: "deleteuser@example.com",
+      },
+    });
+
+    const result = await controller.deleteUser({
+      params: { id: created.id },
+    });
+
+    expect(result.ok).toBe(true);
+    expect(result.id).toBe(created.id);
+
+    // Verify user is deleted
+    await expect(
+      controller.getUser({
+        params: { id: created.id },
+      }),
+    ).rejects.toThrowError(DbEntityNotFoundError);
+  });
+
+  it("should find users with pagination", async ({ expect }) => {
+    const { controller } = await setup();
+
+    // Create multiple users
+    const user1 = await controller.createUser({
+      body: {
+        username: "user1",
+        email: "user1@example.com",
+        firstName: "User",
+        lastName: "One",
+      },
+    });
+    const user2 = await controller.createUser({
+      body: {
+        username: "user2",
+        email: "user2@example.com",
+        firstName: "User",
+        lastName: "Two",
+      },
+    });
+    const user3 = await controller.createUser({
+      body: {
+        username: "user3",
+        email: "user3@example.com",
+        firstName: "User",
+        lastName: "Three",
+      },
+    });
+
+    const result = await controller.findUsers({
+      query: {},
+    });
+
+    expect(result.content.length).toBeGreaterThanOrEqual(3);
+
+    // Verify all created users are in the results
+    const userIds = result.content.map((u) => u.id);
+    expect(userIds).toContain(user1.id);
+    expect(userIds).toContain(user2.id);
+    expect(userIds).toContain(user3.id);
+  });
+
+  it("should filter users by email", async ({ expect }) => {
+    const { controller } = await setup();
+
+    await controller.createUser({
+      body: { username: "filter1", email: "filter1@example.com" },
+    });
+    await controller.createUser({
+      body: { username: "filter2", email: "filter2@test.com" },
+    });
+
+    const result = await controller.findUsers({
+      query: { email: "%example.com%" },
+    });
+
+    expect(result.content.length).toBeGreaterThanOrEqual(1);
+    expect(result.content.every((u) => u.email?.includes("example.com"))).toBe(
+      true,
+    );
+  });
+
+  it("should filter users by enabled status", async ({ expect }) => {
+    const { controller } = await setup();
+
+    await controller.createUser({
+      body: {
+        username: "enableduser",
+        email: "enabled@example.com",
+        enabled: true,
+      },
+    });
+    await controller.createUser({
+      body: {
+        username: "disableduser",
+        email: "disabled@example.com",
+        enabled: false,
+      },
+    });
+
+    const enabledResult = await controller.findUsers({
+      query: { enabled: true },
+    });
+
+    expect(enabledResult.content.every((u) => u.enabled === true)).toBe(true);
+
+    const disabledResult = await controller.findUsers({
+      query: { enabled: false },
+    });
+
+    expect(disabledResult.content.every((u) => u.enabled === false)).toBe(true);
+  });
+
+  it("should filter users by email verification status", async ({ expect }) => {
+    const { controller } = await setup();
+
+    await controller.createUser({
+      body: {
+        username: "verifieduser",
+        email: "verified@example.com",
+        emailVerified: true,
+      },
+    });
+    await controller.createUser({
+      body: {
+        username: "unverifieduser",
+        email: "unverified@example.com",
+        emailVerified: false,
+      },
+    });
+
+    const verifiedResult = await controller.findUsers({
+      query: { emailVerified: true },
+    });
+
+    expect(verifiedResult.content.every((u) => u.emailVerified === true)).toBe(
+      true,
+    );
+
+    const unverifiedResult = await controller.findUsers({
+      query: { emailVerified: false },
+    });
+
+    expect(
+      unverifiedResult.content.every((u) => u.emailVerified === false),
+    ).toBe(true);
+  });
+
+  it("should filter users by roles", async ({ expect }) => {
+    const { controller } = await setup();
+
+    await controller.createUser({
+      body: {
+        username: "adminuser",
+        email: "admin@example.com",
+        roles: ["admin", "user"],
+      },
+    });
+    await controller.createUser({
+      body: {
+        username: "regularuser",
+        email: "regular@example.com",
+        roles: ["user"],
+      },
+    });
+
+    const adminResult = await controller.findUsers({
+      query: { roles: ["admin"] },
+    });
+
+    expect(adminResult.content.every((u) => u.roles.includes("admin"))).toBe(
+      true,
+    );
+  });
+
+  it("should sort users by creation date (newest first)", async ({
+    expect,
+  }) => {
+    const { controller } = await setup();
+
+    const user1 = await controller.createUser({
+      body: { username: "firstuser", email: "first@example.com" },
+    });
+    const user2 = await controller.createUser({
+      body: { username: "seconduser", email: "second@example.com" },
+    });
+    const user3 = await controller.createUser({
+      body: { username: "thirduser", email: "third@example.com" },
+    });
+
+    const result = await controller.findUsers({
+      query: {},
+    });
+
+    const userIds = result.content.map((u) => u.id);
+    expect(userIds.indexOf(user3.id)).toBeLessThan(userIds.indexOf(user2.id));
+    expect(userIds.indexOf(user2.id)).toBeLessThan(userIds.indexOf(user1.id));
+  });
+});

package/src/api/users/controllers/AdminUserController.ts

@@ -0,0 +1,116 @@
+import { $inject, t } from "alepha";
+import { $action, okSchema } from "alepha/server";
+import { createUserSchema } from "../schemas/createUserSchema.ts";
+import { updateUserSchema } from "../schemas/updateUserSchema.ts";
+import { userQuerySchema } from "../schemas/userQuerySchema.ts";
+import { userResourceSchema } from "../schemas/userResourceSchema.ts";
+import { UserService } from "../services/UserService.ts";
+
+export class AdminUserController {
+  protected readonly url = "/users";
+  protected readonly group = "admin:users";
+  protected readonly userService = $inject(UserService);
+
+  /**
+   * Find users with pagination and filtering.
+   */
+  public readonly findUsers = $action({
+    path: this.url,
+    group: this.group,
+    description: "Find users with pagination and filtering",
+    schema: {
+      query: t.extend(userQuerySchema, {
+        userRealmName: t.optional(t.string()),
+      }),
+      response: t.page(userResourceSchema),
+    },
+    handler: ({ query }) => {
+      const { userRealmName, ...q } = query;
+      return this.userService.findUsers(q, userRealmName);
+    },
+  });
+
+  /**
+   * Get a user by ID.
+   */
+  public readonly getUser = $action({
+    path: `${this.url}/:id`,
+    group: this.group,
+    description: "Get a user by ID",
+    schema: {
+      params: t.object({
+        id: t.uuid(),
+      }),
+      query: t.object({
+        userRealmName: t.optional(t.string()),
+      }),
+      response: userResourceSchema,
+    },
+    handler: ({ params, query }) =>
+      this.userService.getUserById(params.id, query.userRealmName),
+  });
+
+  /**
+   * Create a new user.
+   */
+  public readonly createUser = $action({
+    method: "POST",
+    path: this.url,
+    group: this.group,
+    description: "Create a new user",
+    schema: {
+      query: t.object({
+        userRealmName: t.optional(t.string()),
+      }),
+      body: createUserSchema,
+      response: userResourceSchema,
+    },
+    handler: ({ body, query }) =>
+      this.userService.createUser(body, query.userRealmName),
+  });
+
+  /**
+   * Update a user.
+   */
+  public readonly updateUser = $action({
+    method: "PATCH",
+    path: `${this.url}/:id`,
+    group: this.group,
+    description: "Update a user",
+    schema: {
+      params: t.object({
+        id: t.uuid(),
+      }),
+      query: t.object({
+        userRealmName: t.optional(t.string()),
+      }),
+      body: updateUserSchema,
+      response: userResourceSchema,
+    },
+    handler: ({ params, body, query }) =>
+      this.userService.updateUser(params.id, body, query.userRealmName),
+  });
+
+  /**
+   * Delete a user.
+   */
+  public readonly deleteUser = $action({
+    method: "DELETE",
+    path: `${this.url}/:id`,
+    group: this.group,
+    description: "Delete a user",
+    schema: {
+      params: t.object({
+        id: t.uuid(),
+      }),
+      query: t.object({
+        userRealmName: t.optional(t.string()),
+      }),
+      response: okSchema,
+    },
+    handler: async ({ params, query }) => {
+      await this.userService.deleteUser(params.id, query.userRealmName);
+      return { ok: true, id: params.id };
+    },
+  });
+}

package/src/api/users/controllers/UserController.ts

@@ -1,15 +1,11 @@
 import { $inject, t } from "alepha";
-import { pg } from "alepha/orm";
 import { $action, okSchema } from "alepha/server";
 import { completePasswordResetRequestSchema } from "../schemas/completePasswordResetRequestSchema.ts";
 import { completeRegistrationRequestSchema } from "../schemas/completeRegistrationRequestSchema.ts";
-import { createUserSchema } from "../schemas/createUserSchema.ts";
 import { passwordResetIntentResponseSchema } from "../schemas/passwordResetIntentResponseSchema.ts";
 import { registerQuerySchema } from "../schemas/registerQuerySchema.ts";
 import { registerRequestSchema } from "../schemas/registerRequestSchema.ts";
 import { registrationIntentResponseSchema } from "../schemas/registrationIntentResponseSchema.ts";
-import { updateUserSchema } from "../schemas/updateUserSchema.ts";
-import { userQuerySchema } from "../schemas/userQuerySchema.ts";
 import { userResourceSchema } from "../schemas/userResourceSchema.ts";
 import { CredentialService } from "../services/CredentialService.ts";
 import { RegistrationService } from "../services/RegistrationService.ts";
@@ -27,6 +23,7 @@ export class UserController {
    * Validates data, creates verification sessions, and stores intent in cache.
    */
   public readonly createRegistrationIntent = $action({
+    group: this.group,
     method: "POST",
     path: `${this.url}/register`,
     secure: false,
@@ -42,69 +39,12 @@ export class UserController {
       ),
   });
 
-  /**
-   * Find users with pagination and filtering.
-   */
-  public readonly findUsers = $action({
-    path: this.url,
-    group: this.group,
-    description: "Find users with pagination and filtering",
-    schema: {
-      query: t.extend(userQuerySchema, {
-        userRealmName: t.optional(t.string()),
-      }),
-      response: pg.page(userResourceSchema),
-    },
-    handler: ({ query }) => {
-      const { userRealmName, ...q } = query;
-      return this.userService.findUsers(q, userRealmName);
-    },
-  });
-
-  /**
-   * Get a user by ID.
-   */
-  public readonly getUser = $action({
-    path: `${this.url}/:id`,
-    group: this.group,
-    description: "Get a user by ID",
-    schema: {
-      params: t.object({
-        id: t.uuid(),
-      }),
-      query: t.object({
-        userRealmName: t.optional(t.string()),
-      }),
-      response: userResourceSchema,
-    },
-    handler: ({ params, query }) =>
-      this.userService.getUserById(params.id, query.userRealmName),
-  });
-
-  /**
-   * Create a new user.
-   */
-  public readonly createUser = $action({
-    method: "POST",
-    path: this.url,
-    group: this.group,
-    description: "Create a new user",
-    schema: {
-      query: t.object({
-        userRealmName: t.optional(t.string()),
-      }),
-      body: createUserSchema,
-      response: userResourceSchema,
-    },
-    handler: ({ body, query }) =>
-      this.userService.createUser(body, query.userRealmName),
-  });
-
   /**
    * Phase 2: Complete registration using an intent.
    * Validates verification codes and creates the user.
    */
   public readonly createUserFromIntent = $action({
+    group: this.group,
     method: "POST",
     path: `${this.url}/register/complete`,
     secure: false,
@@ -115,56 +55,12 @@ export class UserController {
     handler: ({ body }) => this.registrationService.completeRegistration(body),
   });
 
-  /**
-   * Update a user.
-   */
-  public readonly updateUser = $action({
-    method: "PATCH",
-    path: `${this.url}/:id`,
-    group: this.group,
-    description: "Update a user",
-    schema: {
-      params: t.object({
-        id: t.uuid(),
-      }),
-      query: t.object({
-        userRealmName: t.optional(t.string()),
-      }),
-      body: updateUserSchema,
-      response: userResourceSchema,
-    },
-    handler: ({ params, body, query }) =>
-      this.userService.updateUser(params.id, body, query.userRealmName),
-  });
-
-  /**
-   * Delete a user.
-   */
-  public readonly deleteUser = $action({
-    method: "DELETE",
-    path: `${this.url}/:id`,
-    group: this.group,
-    description: "Delete a user",
-    schema: {
-      params: t.object({
-        id: t.uuid(),
-      }),
-      query: t.object({
-        userRealmName: t.optional(t.string()),
-      }),
-      response: okSchema,
-    },
-    handler: async ({ params, query }) => {
-      await this.userService.deleteUser(params.id, query.userRealmName);
-      return { ok: true, id: params.id };
-    },
-  });
-
   /**
    * Phase 1: Create a password reset intent.
    * Validates email, sends verification code, and stores intent in cache.
    */
   public readonly createPasswordResetIntent = $action({
+    group: this.group,
     method: "POST",
     path: `${this.url}/password-reset`,
     secure: false,
@@ -189,6 +85,7 @@ export class UserController {
    * Validates verification code, updates password, and invalidates sessions.
    */
   public readonly completePasswordReset = $action({
+    group: this.group,
     method: "POST",
     path: `${this.url}/password-reset/complete`,
     secure: false,

package/src/api/users/controllers/UserRealmController.ts

@@ -10,6 +10,7 @@ import { userRealmConfigSchema } from "../schemas/userRealmConfigSchema.ts";
  */
 export class UserRealmController {
   protected readonly url = "/realms";
+  protected readonly group = "realms";
   protected readonly userRealmProvider = $inject(UserRealmProvider);
   protected readonly serverAuthProvider = $inject(ServerAuthProvider);
 
@@ -18,6 +19,7 @@ export class UserRealmController {
    * This endpoint is not exposed in the API documentation.
    */
   public readonly getRealmConfig = $action({
+    group: this.group,
     method: "GET",
     path: `${this.url}/config`,
     secure: false,
@@ -52,6 +54,7 @@ export class UserRealmController {
   });
 
   public readonly checkUsernameAvailability = $action({
+    group: this.group,
     path: `${this.url}/check-username`,
     secure: false,
     schema: {

package/src/api/users/entities/identities.ts

@@ -1,15 +1,15 @@
 import { type Static, t } from "alepha";
-import { $entity, pg } from "alepha/orm";
+import { $entity, db } from "alepha/orm";
 import { users } from "./users.ts";
 
 export const identities = $entity({
   name: "identities",
   schema: t.object({
-    id: pg.primaryKey(t.uuid()),
-    version: pg.version(),
-    createdAt: pg.createdAt(),
-    updatedAt: pg.updatedAt(),
-    userId: pg.ref(t.uuid(), () => users.cols.id),
+    id: db.primaryKey(t.uuid()),
+    version: db.version(),
+    createdAt: db.createdAt(),
+    updatedAt: db.updatedAt(),
+    userId: db.ref(t.uuid(), () => users.cols.id),
     password: t.optional(t.text()),
     provider: t.text(),
     providerUserId: t.optional(t.text()),