alepha 0.14.4 → 0.15.1

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,16 +256,6 @@ export class SessionService {
       userId: session.userId,
     });
 
-    const { name } = this.userRealmProvider.getRealm(userRealmName);
-
-    await this.auditService.recordAuth("token_refresh", {
-      userId: user.id,
-      userEmail: user.email ?? undefined,
-      userRealm: name,
-      sessionId: session.id,
-      description: "Session token refreshed",
-    });
-
     return {
       user,
       expiresIn: expiresAt.unix() - now.unix(),
@@ -270,7 +279,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 +301,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/AlephaCli.ts

@@ -5,7 +5,6 @@ import { CleanCommand } from "../commands/clean.ts";
 import { DbCommand } from "../commands/db.ts";
 import { DeployCommand } from "../commands/deploy.ts";
 import { DevCommand } from "../commands/dev.ts";
-import { FormatCommand } from "../commands/format.ts";
 import { GitProvider } from "../commands/gen/changelog.ts";
 import { GenCommand } from "../commands/gen.ts";
 import { InitCommand } from "../commands/init.ts";
@@ -14,6 +13,7 @@ import { RootCommand } from "../commands/root.ts";
 import { TestCommand } from "../commands/test.ts";
 import { TypecheckCommand } from "../commands/typecheck.ts";
 import { VerifyCommand } from "../commands/verify.ts";
+import { AppEntryProvider } from "../providers/AppEntryProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -73,7 +73,6 @@ export const AlephaCli = $module({
     DbCommand,
     DeployCommand,
     DevCommand,
-    FormatCommand,
     InitCommand,
     LintCommand,
     RootCommand,
@@ -82,6 +81,7 @@ export const AlephaCli = $module({
     VerifyCommand,
     GenCommand,
     // Support services
+    AppEntryProvider,
     GitProvider,
   ],
 });

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,46 +100,61 @@ 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,
           fixedExtension: false,
           platform: "node", // TODO: node must be enabled only if index.node.ts exists
+          inlineOnly: false,
           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,
             dts: false,
+            inlineOnly: false,
             external,
           });
         }
 
         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,
             dts: false,
+            inlineOnly: false,
             external,
           });
         }
 
-        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,
+            inlineOnly: false,
+            external,
+          });
+        }
+
+        const config = this.fs.join(
           tmpDir,
           `tsdown-${item.name.replace("/", "-")}.config.js`,
         );
@@ -143,8 +162,10 @@ export class AlephaPackageBuilderCli {
           config,
           `export default ${JSON.stringify(entries, null, 2)};`,
         );
+
+        // /!\ Warning /!\
+        // avoid to call tsdown programmatically, when we spawn 8 processes at once it 'JavaScript heap out of memory' :---)
         await run(`npx tsdown -c=${config}`);
-        //await this.fs.rm(config);
       };
 
       const concurrency = Math.ceil(os.cpus().length / 2);
@@ -168,6 +189,8 @@ export class AlephaPackageBuilderCli {
   });
 }
 
+export default AlephaPackageBuilderCli;
+
 async function getAllFiles(dir: string): Promise<string[]> {
   const files: string[] = [];
 
@@ -261,7 +284,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 +312,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 +354,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,19 @@
+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();
+};

package/src/cli/assets/biomeJson.ts

@@ -1,4 +1,5 @@
-export const biomeJson = `
+export const biomeJson = () =>
+  `
 {
   "$schema": "https://biomejs.dev/schemas/latest/schema.json",
   "vcs": {