alepha 0.14.4 → 0.15.0

package/src/api/users/services/RegistrationService.ts

@@ -10,7 +10,7 @@ import { BadRequestError, ConflictError, HttpError } from "alepha/server";
 import { $client } from "alepha/server/links";
 import type { UserEntity } from "../entities/users.ts";
 import { UserNotifications } from "../notifications/UserNotifications.ts";
-import { UserRealmProvider } from "../providers/UserRealmProvider.ts";
+import { RealmProvider } from "../providers/RealmProvider.ts";
 import type { CompleteRegistrationRequest } from "../schemas/completeRegistrationRequestSchema.ts";
 import type { RegisterRequest } from "../schemas/registerRequestSchema.ts";
 import type { RegistrationIntentResponse } from "../schemas/registrationIntentResponseSchema.ts";
@@ -45,7 +45,7 @@ export class RegistrationService {
   protected readonly cryptoProvider = $inject(CryptoProvider);
   protected readonly verificationController = $client<VerificationController>();
   protected readonly userNotifications = $inject(UserNotifications);
-  protected readonly userRealmProvider = $inject(UserRealmProvider);
+  protected readonly realmProvider = $inject(RealmProvider);
   protected readonly auditService = $inject(AuditService);
 
   protected readonly intentCache = $cache<RegistrationIntent>({
@@ -69,9 +69,7 @@ export class RegistrationService {
       userRealmName,
     });
 
-    const realmSettings =
-      this.userRealmProvider.getRealm(userRealmName).settings;
-    const userRepository = this.userRealmProvider.userRepository(userRealmName);
+    const realmSettings = this.realmProvider.getRealm(userRealmName).settings;
 
     // Check if registration is allowed
     if (realmSettings?.registrationAllowed === false) {
@@ -87,6 +85,22 @@ export class RegistrationService {
       throw new BadRequestError("Username is required");
     }
 
+    if (body.username) {
+      const usernameRegExp = realmSettings?.usernameRegExp;
+      if (usernameRegExp) {
+        const regex = new RegExp(usernameRegExp);
+        if (!regex.test(body.username)) {
+          this.log.debug("Registration rejected: username regex mismatch", {
+            userRealmName,
+            username: body.username,
+          });
+          throw new BadRequestError(
+            "Username does not meet the required format",
+          );
+        }
+      }
+    }
+
     if (realmSettings?.emailRequired !== false && !body.email) {
       this.log.debug("Registration rejected: email required", {
         userRealmName,
@@ -189,9 +203,9 @@ export class RegistrationService {
     }
 
     const userRealmName = intent.realmName;
-    const userRepository = this.userRealmProvider.userRepository(userRealmName);
+    const userRepository = this.realmProvider.userRepository(userRealmName);
     const identityRepository =
-      this.userRealmProvider.identityRepository(userRealmName);
+      this.realmProvider.identityRepository(userRealmName);
 
     // Validate email verification if required
     if (intent.requirements.email) {
@@ -275,7 +289,7 @@ export class RegistrationService {
       username: user.username,
     });
 
-    const realm = this.userRealmProvider.getRealm(userRealmName);
+    const realm = this.realmProvider.getRealm(userRealmName);
 
     await this.auditService.recordUser("create", {
       userId: user.id,
@@ -301,7 +315,7 @@ export class RegistrationService {
     body: Pick<RegisterRequest, "username" | "email" | "phoneNumber">,
     userRealmName?: string,
   ): Promise<void> {
-    const userRepository = this.userRealmProvider.userRepository(userRealmName);
+    const userRepository = this.realmProvider.userRepository(userRealmName);
 
     if (body.username) {
       const existingUser = await userRepository
@@ -341,26 +355,23 @@ export class RegistrationService {
    */
   protected async sendEmailVerification(email: string): Promise<void> {
     this.log.debug("Sending email verification code", { email });
-    try {
-      const verification =
-        await this.verificationController.requestVerificationCode({
-          params: { type: "code" },
-          body: { target: email },
-        });
 
-      await this.userNotifications.emailVerification.push({
-        contact: email,
-        variables: {
-          email,
-          code: verification.token,
-          expiresInMinutes: Math.floor(verification.codeExpiration / 60),
-        },
+    const verification =
+      await this.verificationController.requestVerificationCode({
+        params: { type: "code" },
+        body: { target: email },
       });
-      this.log.debug("Email verification code sent", { email });
-    } catch (error) {
-      // Silent fail - verification service may have rate limiting
-      this.log.warn("Failed to send email verification code", error);
-    }
+
+    await this.userNotifications.emailVerification.push({
+      contact: email,
+      variables: {
+        email,
+        code: verification.token,
+        expiresInMinutes: Math.floor(verification.codeExpiration / 60),
+      },
+    });
+
+    this.log.debug("Email verification code sent", { email });
   }
 
   /**

package/src/api/users/services/SessionCrudService.ts

@@ -2,15 +2,15 @@ import { $inject } from "alepha";
 import { $logger } from "alepha/logger";
 import type { Page } from "alepha/orm";
 import type { SessionEntity } from "../entities/sessions.ts";
-import { UserRealmProvider } from "../providers/UserRealmProvider.ts";
+import { RealmProvider } from "../providers/RealmProvider.ts";
 import type { SessionQuery } from "../schemas/sessionQuerySchema.ts";
 
 export class SessionCrudService {
   protected readonly log = $logger();
-  protected readonly userRealmProvider = $inject(UserRealmProvider);
+  protected readonly realmProvider = $inject(RealmProvider);
 
   public sessions(userRealmName?: string) {
-    return this.userRealmProvider.sessionRepository(userRealmName);
+    return this.realmProvider.sessionRepository(userRealmName);
   }
 
   /**

package/src/api/users/services/SessionService.spec.ts

@@ -7,8 +7,8 @@ import {
 import { describe, it } from "vitest";
 import {
   AlephaApiUsers,
+  RealmProvider,
   SessionService,
-  UserRealmProvider,
   UserService,
 } from "../index.ts";
 
@@ -26,8 +26,8 @@ const setup = async (options?: { usernameEnabled?: boolean }) => {
 
   // Configure realm settings if provided
   if (options?.usernameEnabled) {
-    const userRealmProvider = alepha.inject(UserRealmProvider);
-    userRealmProvider.register("default", {
+    const realmProvider = alepha.inject(RealmProvider);
+    realmProvider.register("default", {
       settings: {
         usernameEnabled: true,
       } as never,

package/src/api/users/services/SessionService.ts

@@ -14,7 +14,7 @@ import { type ServerRequest, UnauthorizedError } from "alepha/server";
 import type { OAuth2Profile } from "alepha/server/auth";
 import { $client } from "alepha/server/links";
 import type { UserEntity } from "../entities/users.ts";
-import { UserRealmProvider } from "../providers/UserRealmProvider.ts";
+import { RealmProvider } from "../providers/RealmProvider.ts";
 
 export class SessionService {
   protected readonly alepha = $inject(Alepha);
@@ -22,20 +22,20 @@ export class SessionService {
   protected readonly dateTimeProvider = $inject(DateTimeProvider);
   protected readonly cryptoProvider = $inject(CryptoProvider);
   protected readonly log = $logger();
-  protected readonly userRealmProvider = $inject(UserRealmProvider);
+  protected readonly realmProvider = $inject(RealmProvider);
   protected readonly fileController = $client<FileController>();
   protected readonly auditService = $inject(AuditService);
 
   public users(userRealmName?: string) {
-    return this.userRealmProvider.userRepository(userRealmName);
+    return this.realmProvider.userRepository(userRealmName);
   }
 
   public sessions(userRealmName?: string) {
-    return this.userRealmProvider.sessionRepository(userRealmName);
+    return this.realmProvider.sessionRepository(userRealmName);
   }
 
   public identities(userRealmName?: string) {
-    return this.userRealmProvider.identityRepository(userRealmName);
+    return this.realmProvider.identityRepository(userRealmName);
   }
 
   /**
@@ -55,7 +55,7 @@ export class SessionService {
     password: string,
     userRealmName?: string,
   ): Promise<UserEntity> {
-    const { settings, name } = this.userRealmProvider.getRealm(userRealmName);
+    const { settings, name } = this.realmProvider.getRealm(userRealmName);
     const isEmail = username.includes("@");
     const isPhone = /^[+\d][\d\s()-]+$/.test(username);
     const isUsername = !isEmail && !isPhone;
@@ -70,6 +70,25 @@ export class SessionService {
       where.realm = name;
 
       if (settings.usernameEnabled !== false && isUsername) {
+        // validate username format if regex is provided
+        if (settings.usernameRegExp) {
+          const regex = new RegExp(settings.usernameRegExp);
+          if (!regex.test(username)) {
+            this.log.warn("Username does not match required format", {
+              provider,
+              username,
+              realm: name,
+            });
+
+            await this.auditService.recordAuth("login_failed", {
+              userRealm: name,
+              description: "Username does not match required format",
+              metadata: { provider, username },
+            });
+
+            throw new InvalidCredentialsError();
+          }
+        }
         where.username = username;
       } else if (settings.emailEnabled !== false && isEmail) {
         where.email = username;
@@ -237,7 +256,7 @@ export class SessionService {
       userId: session.userId,
     });
 
-    const { name } = this.userRealmProvider.getRealm(userRealmName);
+    const { name } = this.realmProvider.getRealm(userRealmName);
 
     await this.auditService.recordAuth("token_refresh", {
       userId: user.id,
@@ -270,7 +289,7 @@ export class SessionService {
     this.log.debug("Session deleted");
 
     if (session) {
-      const { name } = this.userRealmProvider.getRealm(userRealmName);
+      const { name } = this.realmProvider.getRealm(userRealmName);
 
       await this.auditService.recordAuth("logout", {
         userId: session.userId,
@@ -292,7 +311,7 @@ export class SessionService {
       email: profile.email,
     });
 
-    const realm = this.userRealmProvider.getRealm(userRealmName);
+    const realm = this.realmProvider.getRealm(userRealmName);
     const identities = this.identities(userRealmName);
     const users = this.users(userRealmName);
 

package/src/api/users/services/UserService.ts

@@ -7,7 +7,7 @@ import { BadRequestError } from "alepha/server";
 import { $client } from "alepha/server/links";
 import type { UserEntity } from "../entities/users.ts";
 import { UserNotifications } from "../notifications/UserNotifications.ts";
-import { UserRealmProvider } from "../providers/UserRealmProvider.ts";
+import { RealmProvider } from "../providers/RealmProvider.ts";
 import type { CreateUser } from "../schemas/createUserSchema.ts";
 import type { UpdateUser } from "../schemas/updateUserSchema.ts";
 import type { UserQuery } from "../schemas/userQuerySchema.ts";
@@ -16,11 +16,11 @@ export class UserService {
   protected readonly log = $logger();
   protected readonly verificationController = $client<VerificationController>();
   protected readonly userNotifications = $inject(UserNotifications);
-  protected readonly userRealmProvider = $inject(UserRealmProvider);
+  protected readonly realmProvider = $inject(RealmProvider);
   protected readonly auditService = $inject(AuditService);
 
   public users(userRealmName?: string) {
-    return this.userRealmProvider.userRepository(userRealmName);
+    return this.realmProvider.userRepository(userRealmName);
   }
 
   /**
@@ -156,7 +156,7 @@ export class UserService {
 
     this.log.info("Email verified", { email, userId: user.id, type });
 
-    const realm = this.userRealmProvider.getRealm(userRealmName);
+    const realm = this.realmProvider.getRealm(userRealmName);
 
     await this.auditService.recordUser("update", {
       userId: user.id,
@@ -256,7 +256,7 @@ export class UserService {
       userRealmName,
     });
 
-    const realm = this.userRealmProvider.getRealm(userRealmName);
+    const realm = this.realmProvider.getRealm(userRealmName);
 
     // TODO: one query instead of 3
 
@@ -342,7 +342,7 @@ export class UserService {
     const user = await this.users(userRealmName).updateById(id, data);
     this.log.debug("User updated", { userId: id });
 
-    const realm = this.userRealmProvider.getRealm(userRealmName);
+    const realm = this.realmProvider.getRealm(userRealmName);
 
     // Build changes object showing what was updated
     const changes: Record<string, { from: unknown; to: unknown }> = {};
@@ -382,7 +382,7 @@ export class UserService {
     await this.users(userRealmName).deleteById(id);
     this.log.info("User deleted", { userId: id });
 
-    const realm = this.userRealmProvider.getRealm(userRealmName);
+    const realm = this.realmProvider.getRealm(userRealmName);
 
     await this.auditService.recordUser("delete", {
       userRealm: realm.name,

package/src/batch/providers/BatchProvider.ts

@@ -1,4 +1,3 @@
-import { randomUUID } from "node:crypto";
 import { $inject, type Alepha } from "alepha";
 import { DateTimeProvider, type DurationLike } from "alepha/datetime";
 import { $logger } from "alepha/logger";
@@ -188,7 +187,7 @@ export class BatchProvider {
     item: TItem,
   ): string {
     // 1. Generate unique ID
-    const id = randomUUID();
+    const id = crypto.randomUUID();
 
     // 2. Determine the partition key (with error handling)
     let partitionKey: string;

package/src/cli/apps/AlephaPackageBuilderCli.ts

@@ -1,7 +1,7 @@
 import { access, readdir, readFile } from "node:fs/promises";
 import * as os from "node:os";
 import { join } from "node:path";
-import { $inject } from "alepha";
+import { $inject, AlephaError } from "alepha";
 import { $command } from "alepha/command";
 import { FileSystemProvider } from "alepha/file";
 import type { InlineConfig } from "tsdown";
@@ -11,6 +11,7 @@ interface Module {
   dependencies: string[];
   native?: boolean;
   browser?: boolean;
+  bun?: boolean;
   node?: boolean;
 }
 
@@ -24,13 +25,13 @@ export class AlephaPackageBuilderCli {
     handler: async ({ run, root }) => {
       const modules: Array<Module> = [];
 
-      const pkg = await readFile("package.json", "utf-8");
-      const pkgData = JSON.parse(pkg);
+      const pkgBuffer = await this.fs.readFile("package.json");
+      const pkgData = JSON.parse(pkgBuffer.toString("utf-8"));
       const packageName = pkgData.name as string;
 
       await run("analyze modules", async () => {
         modules.push(
-          ...(await analyzeModules(join(root, this.src), packageName)),
+          ...(await analyzeModules(this.fs.join(root, this.src), packageName)),
         );
       });
 
@@ -56,6 +57,10 @@ export class AlephaPackageBuilderCli {
           pkgData.exports[path].browser = `./src/${item.name}/index.browser.ts`;
         }
 
+        if (item.bun) {
+          pkgData.exports[path].bun = `./src/${item.name}/index.bun.ts`;
+        }
+
         pkgData.exports[path].import = `./src/${item.name}/index.ts`;
         pkgData.exports[path].default = `./src/${item.name}/index.ts`;
       }
@@ -72,21 +77,20 @@ export class AlephaPackageBuilderCli {
 
       await this.fs.writeFile("package.json", JSON.stringify(pkgData, null, 2));
 
-      const tmpDir = join(root, "node_modules/.alepha");
+      const tmpDir = this.fs.join(root, "node_modules/.alepha");
       await this.fs.mkdir(tmpDir, { recursive: true }).catch(() => {});
 
       await this.fs.writeFile(
-        join(tmpDir, "module-dependencies.json"),
+        this.fs.join(tmpDir, "module-dependencies.json"),
         JSON.stringify(modules, null, 2),
       );
 
-      const tsconfig = await readFile(
-        join(root, "../../tsconfig.json"),
-        "utf-8",
+      const tsconfigBuffer = await this.fs.readFile(
+        this.fs.join(root, "../../tsconfig.json"),
       );
 
       const external: string[] = Object.keys(
-        JSON.parse(tsconfig).compilerOptions.paths,
+        JSON.parse(tsconfigBuffer.toString("utf-8")).compilerOptions.paths,
       );
 
       external.push("bun");
@@ -96,11 +100,11 @@ export class AlephaPackageBuilderCli {
 
       const build = async (item: Module) => {
         const entries: InlineConfig[] = [];
-        const src = join(root, this.src, item.name);
-        const dest = join(root, this.dist, item.name);
+        const src = this.fs.join(root, this.src, item.name);
+        const dest = this.fs.join(root, this.dist, item.name);
 
         entries.push({
-          entry: join(src, "index.ts"),
+          entry: this.fs.join(src, "index.ts"),
           outDir: dest,
           format: ["esm"],
           sourcemap: true,
@@ -109,13 +113,12 @@ export class AlephaPackageBuilderCli {
           external,
           dts: {
             sourcemap: true,
-            resolve: false,
           },
         });
 
         if (item.native) {
           entries.push({
-            entry: join(src, "index.native.ts"),
+            entry: this.fs.join(src, "index.native.ts"),
             outDir: dest,
             platform: "neutral",
             sourcemap: true,
@@ -126,7 +129,7 @@ export class AlephaPackageBuilderCli {
 
         if (item.browser) {
           entries.push({
-            entry: join(src, "index.browser.ts"),
+            entry: this.fs.join(src, "index.browser.ts"),
             outDir: dest,
             platform: "browser",
             sourcemap: true,
@@ -135,7 +138,19 @@ export class AlephaPackageBuilderCli {
           });
         }
 
-        const config = join(
+        if (item.bun) {
+          entries.push({
+            entry: this.fs.join(src, "index.bun.ts"),
+            outDir: dest,
+            platform: "node",
+            sourcemap: true,
+            fixedExtension: false,
+            dts: false,
+            external,
+          });
+        }
+
+        const config = this.fs.join(
           tmpDir,
           `tsdown-${item.name.replace("/", "-")}.config.js`,
         );
@@ -261,7 +276,9 @@ function detectCircularDependencies(modules: Module[]): void {
   for (const module of modules) {
     const cycle = hasCycle(module.name);
     if (cycle) {
-      throw new Error(`Circular dependency detected: ${cycle.join(" -> ")}`);
+      throw new AlephaError(
+        `Circular dependency detected: ${cycle.join(" -> ")}`,
+      );
     }
   }
 }
@@ -287,13 +304,14 @@ export async function analyzeModules(
           // This is a module
           const dependencies = new Set<string>();
 
-          // Check for browser/node entry points
+          // Check for browser/node/bun entry points
           const hasBrowser = await fileExists(
             join(modulePath, "index.browser.ts"),
           );
           const hasNative = await fileExists(
             join(modulePath, "index.native.ts"),
           );
+          const hasBun = await fileExists(join(modulePath, "index.bun.ts"));
           const hasNode = await fileExists(join(modulePath, "index.node.ts"));
 
           // Get all .ts/.tsx files in this module
@@ -328,6 +346,7 @@ export async function analyzeModules(
 
           if (hasNative) module.native = true;
           if (hasBrowser) module.browser = true;
+          if (hasBun) module.bun = true;
           if (hasNode) module.node = true;
 
           modules.push(module);

package/src/cli/assets/apiHelloControllerTs.ts

@@ -0,0 +1,18 @@
+export const apiHelloControllerTs = () => `
+import { t } from "alepha";
+import { $action } from "alepha/server";
+
+export class HelloController {
+  hello = $action({
+    path: "/hello",
+    schema: {
+      response: t.object({
+        message: t.string(),
+      }),
+    },
+    handler: () => ({
+      message: "Hello, Alepha!",
+    }),
+  });
+}
+`.trim();

package/src/cli/assets/apiIndexTs.ts

@@ -0,0 +1,16 @@
+export interface ApiIndexTsOptions {
+  appName?: string;
+}
+
+export const apiIndexTs = (options: ApiIndexTsOptions = {}) => {
+  const { appName = "app" } = options;
+  return `
+import { $module } from "alepha";
+import { HelloController } from "./controllers/HelloController.ts";
+
+export const ApiModule = $module({
+  name: "${appName}.api",
+  services: [HelloController],
+});
+`.trim();
+};