alepha 0.13.2 → 0.13.3

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

@@ -23,12 +23,22 @@ export class UserService {
 
   /**
    * Request email verification for a user.
+   * @param email - The email address to verify.
+   * @param userRealmName - Optional realm name.
+   * @param method - The verification method: "code" (default) or "link".
+   * @param verifyUrl - Base URL for verification link (required when method is "link").
    */
   public async requestEmailVerification(
     email: string,
     userRealmName?: string,
+    method: "code" | "link" = "code",
+    verifyUrl?: string,
   ): Promise<boolean> {
-    this.log.trace("Requesting email verification", { email, userRealmName });
+    this.log.trace("Requesting email verification", {
+      email,
+      userRealmName,
+      method,
+    });
 
     const user = await this.users(userRealmName)
       .findOne({
@@ -54,23 +64,47 @@ export class UserService {
     try {
       const verification =
         await this.verificationController.requestVerificationCode({
-          params: { type: "code" },
+          params: { type: method },
           body: { target: email },
         });
 
-      await this.userNotifications.emailVerification.push({
-        contact: email,
-        variables: {
+      if (method === "link") {
+        // Build verification URL with token
+        const url = new URL(verifyUrl || "/verify-email", "http://localhost");
+        url.searchParams.set("email", email);
+        url.searchParams.set("token", verification.token);
+        const fullVerifyUrl = verifyUrl
+          ? `${verifyUrl}${url.search}`
+          : url.pathname + url.search;
+
+        await this.userNotifications.emailVerificationLink.push({
+          contact: email,
+          variables: {
+            email,
+            verifyUrl: fullVerifyUrl,
+            expiresInMinutes: Math.floor(verification.codeExpiration / 60),
+          },
+        });
+
+        this.log.debug("Email verification link sent", {
           email,
-          code: verification.token,
-          expiresInMinutes: Math.floor(verification.codeExpiration / 60),
-        },
-      });
+          userId: user.id,
+        });
+      } else {
+        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,
-        userId: user.id,
-      });
+        this.log.debug("Email verification code sent", {
+          email,
+          userId: user.id,
+        });
+      }
     } catch (error) {
       // Silent fail for security
       this.log.warn("Failed to send email verification", { email, error });
@@ -81,6 +115,7 @@ export class UserService {
 
   /**
    * Verify a user's email using a valid verification token.
+   * Supports both code (6-digit) and link (UUID) verification tokens.
    */
   public async verifyEmail(
     email: string,
@@ -89,13 +124,18 @@ export class UserService {
   ): Promise<void> {
     this.log.trace("Verifying email", { email, userRealmName });
 
+    // Detect verification type based on token format
+    // Codes are 6-digit numbers, links are UUIDs
+    const isCode = /^\d{6}$/.test(token);
+    const type = isCode ? "code" : "link";
+
     const result = await this.verificationController
       .validateVerificationCode({
-        params: { type: "code" },
+        params: { type },
         body: { target: email, token },
       })
       .catch(() => {
-        this.log.warn("Invalid email verification token", { email });
+        this.log.warn("Invalid email verification token", { email, type });
         throw new BadRequestError("Invalid or expired verification token");
       });
 
@@ -112,7 +152,7 @@ export class UserService {
       emailVerified: true,
     });
 
-    this.log.info("Email verified", { email, userId: user.id });
+    this.log.info("Email verified", { email, userId: user.id, type });
   }
 
   /**

package/src/api-verifications/index.browser.ts

@@ -0,0 +1,15 @@
+import { $module } from "alepha";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export * from "./entities/verifications.ts";
+export * from "./schemas/requestVerificationCodeResponseSchema.ts";
+export * from "./schemas/validateVerificationCodeResponseSchema.ts";
+export * from "./schemas/verificationTypeEnumSchema.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export const AlephaApiVerification = $module({
+  name: "alepha.api.verifications",
+  services: [],
+});

package/src/api-verifications/index.ts

@@ -6,6 +6,7 @@ import { VerificationService } from "./services/VerificationService.ts";
 // ---------------------------------------------------------------------------------------------------------------------
 
 export * from "./controllers/VerificationController.ts";
+export * from "./entities/verifications.ts";
 export * from "./schemas/requestVerificationCodeResponseSchema.ts";
 export * from "./schemas/validateVerificationCodeResponseSchema.ts";
 export * from "./schemas/verificationTypeEnumSchema.ts";

package/src/batch/providers/BatchProvider.ts

@@ -213,13 +213,6 @@ export class BatchProvider {
     };
 
     // CAUTION: Do not log.debug/info here as it may cause infinite loops if logging is batched
-    // log.trace is safe
-
-    this.log.trace("Pushing item to batch", {
-      id,
-      partitionKey,
-      item,
-    });
 
     context.itemStates.set(id, itemState);
 

package/src/bucket/index.ts

@@ -61,12 +61,14 @@ export const AlephaBucket = $module({
     MemoryFileStorageProvider,
     LocalFileStorageProvider,
   ],
-  register: (alepha) =>
+  register: (alepha) => {
     alepha.with({
       optional: true,
       provide: FileStorageProvider,
-      use: alepha.isTest()
-        ? MemoryFileStorageProvider
-        : LocalFileStorageProvider,
-    }),
+      use:
+        alepha.isTest() || alepha.isServerless()
+          ? MemoryFileStorageProvider
+          : LocalFileStorageProvider,
+    });
+  },
 });

package/src/cli/apps/AlephaCli.ts

@@ -1,4 +1,6 @@
-import { $module } from "alepha";
+import { join } from "node:path";
+import { $hook, $inject, $module, Alepha } from "alepha";
+import { FileSystemProvider } from "alepha/file";
 import { BiomeCommands } from "../commands/BiomeCommands.ts";
 import { CoreCommands } from "../commands/CoreCommands.ts";
 import { DrizzleCommands } from "../commands/DrizzleCommands.ts";
@@ -6,9 +8,33 @@ import { VerifyCommands } from "../commands/VerifyCommands.ts";
 import { ViteCommands } from "../commands/ViteCommands.ts";
 import { ProcessRunner } from "../services/ProcessRunner.ts";
 
+class AlephaCliExtension {
+  protected readonly alepha = $inject(Alepha);
+  protected readonly fs = $inject(FileSystemProvider);
+  protected readonly onConfigure = $hook({
+    on: "configure",
+    handler: async () => {
+      const extensionPath = join(process.cwd(), "alepha.config.ts");
+      const hasExtension = await this.fs.exists(extensionPath);
+      if (!hasExtension) {
+        return;
+      }
+
+      // import
+      const { default: Extension } = await import(extensionPath);
+      if (typeof Extension !== "function") {
+        return;
+      }
+
+      this.alepha.with(Extension);
+    },
+  });
+}
+
 export const AlephaCli = $module({
   name: "alepha.cli",
   services: [
+    AlephaCliExtension,
     ProcessRunner,
     CoreCommands,
     DrizzleCommands,

package/src/cli/apps/AlephaPackageBuilderCli.ts

@@ -49,10 +49,13 @@ export class AlephaPackageBuilderCli {
           pkgData.exports[path]["react-native"] =
             `./src/${item.name}/index.browser.ts`;
         }
+
         if (item.browser) {
           pkgData.exports[path].browser = `./src/${item.name}/index.browser.ts`;
         }
+
         pkgData.exports[path].import = `./src/${item.name}/index.ts`;
+        pkgData.exports[path].default = `./src/${item.name}/index.ts`;
       }
 
       if (packageName === "alepha") {

package/src/cli/commands/CoreCommands.ts

@@ -62,11 +62,15 @@ export class CoreCommands {
       react: t.optional(
         t.boolean({ description: "Include Alepha React dependencies" }),
       ),
-      admin: t.optional(
-        t.boolean({ description: "Include Alepha admin panel dependencies" }),
+      ui: t.optional(
+        t.boolean({ description: "Include Alepha UI dependencies" }),
       ),
     }),
     handler: async ({ run, flags, root }) => {
+      if (flags.ui) {
+        flags.react = true;
+      }
+
       await run({
         name: "Ensuring configuration files",
         handler: async () => {

package/src/cli/commands/ViteCommands.ts

@@ -145,6 +145,7 @@ export class ViteCommands {
         ] ?? {};
 
       const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
+      const hasServer = viteAlephaBuildOptions.serverEntry !== false;
 
       let hasClient = false;
       try {
@@ -189,7 +190,7 @@ export class ViteCommands {
           });
 
           // Server will handle index.html if both client & server are built
-          if (clientBuilt) {
+          if (clientBuilt && hasServer) {
             await unlink(`${distDir}/${clientDir}/index.html`);
           }
         },

package/src/cli/services/ProjectUtils.ts

@@ -72,6 +72,11 @@ export class ProjectUtils {
 
     const devDependencies: Record<string, string> = {};
 
+    if (modes.ui) {
+      dependencies["@alepha/ui"] = `^${version}`;
+      modes.react = true;
+    }
+
     if (modes.react) {
       dependencies["@alepha/react"] = `^${version}`;
       dependencies.react = "^19.2.0";
@@ -79,10 +84,6 @@ export class ProjectUtils {
       devDependencies["@types/react"] = "^19.2.0";
     }
 
-    if (modes.admin) {
-      dependencies["@alepha/ui"] = `^${version}`;
-    }
-
     return {
       type: "module",
       dependencies,
@@ -174,33 +175,6 @@ export class ProjectUtils {
     await Promise.all(tasks);
   }
 
-  /**
-   * Ensure package.json exists and is configured as ES module.
-   *
-   * Similar to ensurePackageJson but only validates/sets the "type": "module" field.
-   * Throws an error if no package.json exists.
-   *
-   * @param root - The root directory of the project
-   * @throws {AlephaError} If no package.json is found
-   */
-  public async ensurePackageJsonModule(root: string): Promise<void> {
-    const packageJsonPath = join(root, "package.json");
-    try {
-      await access(packageJsonPath);
-    } catch (error) {
-      throw new AlephaError(
-        "No package.json found in project root. Run 'npx alepha init' to create one.",
-      );
-    }
-
-    const content = await readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(content);
-    if (!packageJson.type || packageJson.type !== "module") {
-      packageJson.type = "module";
-      await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-    }
-  }
-
   /**
    * Ensure tsconfig.json exists in the project.
    *
@@ -217,25 +191,30 @@ export class ProjectUtils {
    *
    * Creates a standard Alepha vite.config.ts if none exists.
    */
-  public async ensureViteConfig(root: string): Promise<void> {
-    await this.ensureFileExists(root, "vite.config.ts", viteConfigTs(), false);
+  public async ensureViteConfig(
+    root: string,
+    serverEntry?: string,
+  ): Promise<void> {
+    await this.ensureFileExists(
+      root,
+      "vite.config.ts",
+      viteConfigTs(serverEntry),
+      false,
+    );
   }
 
-  protected async ensureFileExists(
+  protected async checkFileExists(
     root: string,
     name: string,
-    content: string,
     checkParentDirectories: boolean = false,
-  ): Promise<void> {
+  ): Promise<boolean> {
     const configPath = join(root, name);
-
     if (!checkParentDirectories) {
       try {
         await access(configPath);
-        return;
+        return true;
       } catch {
-        await writeFile(configPath, content);
-        return;
+        return false;
       }
     }
 
@@ -259,8 +238,23 @@ export class ProjectUtils {
       level += 1;
     }
 
+    return found;
+  }
+
+  protected async ensureFileExists(
+    root: string,
+    name: string,
+    content: string,
+    checkParentDirectories: boolean = false,
+  ): Promise<void> {
+    const found = await this.checkFileExists(
+      root,
+      name,
+      checkParentDirectories,
+    );
+
     if (!found) {
-      await writeFile(configPath, content);
+      await writeFile(join(root, name), content);
     }
   }
 
@@ -277,35 +271,6 @@ export class ProjectUtils {
     await this.ensureFileExists(root, "biome.json", biomeJson, true);
   }
 
-  // ===================================================================================================================
-  // Vite Configuration
-  // ===================================================================================================================
-
-  /**
-   * Get the path to Vite configuration file.
-   *
-   * Looks for an existing vite.config.ts in the project root, or creates one if it doesn't exist.
-   *
-   * @param root - The root directory of the project (defaults to process.cwd())
-   * @param serverEntry - Optional path to the server entry file to include in the config
-   * @returns Absolute path to the vite.config.ts file
-   */
-  public async getViteConfigPath(
-    root: string,
-    serverEntry?: string,
-  ): Promise<string> {
-    try {
-      const viteConfigPath = join(root, "vite.config.ts");
-      await access(viteConfigPath);
-      return viteConfigPath;
-    } catch {
-      return this.runner.writeConfigFile(
-        "vite.config.ts",
-        viteConfigTs(serverEntry),
-      );
-    }
-  }
-
   // ===================================================================================================================
   // Drizzle ORM & Kit Utilities
   // ===================================================================================================================
@@ -544,13 +509,13 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
   public async getPackageManager(
     root: string,
   ): Promise<"yarn" | "pnpm" | "npm"> {
-    if (await this.fs.exists(join(root, "yarn.lock"))) {
+    if (await this.checkFileExists(root, "yarn.lock", true)) {
       return "yarn";
-    } else if (await this.fs.exists(join(root, "pnpm-lock.yaml"))) {
+    }
+    if (await this.checkFileExists(root, "pnpm-lock.yaml", true)) {
       return "pnpm";
-    } else {
-      return "npm";
     }
+    return "npm";
   }
 
   public async ensureIndexHtml(root: string) {
@@ -597,5 +562,5 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
 
 export interface DependencyModes {
   react?: boolean;
-  admin?: boolean;
+  ui?: boolean;
 }

package/src/command/helpers/Asker.ts

@@ -7,6 +7,7 @@ import {
   type Static,
   type TSchema,
   type TString,
+  t,
 } from "alepha";
 import { $logger } from "alepha/logger";
 
@@ -44,6 +45,8 @@ export interface AskMethod {
     question: string,
     options?: AskOptions<T>,
   ): Promise<Static<T>>;
+
+  permission: (question: string) => Promise<boolean>;
 }
 
 export class Asker {
@@ -63,6 +66,13 @@ export class Asker {
       return await this.prompt<T>(question, options);
     };
 
+    askFn.permission = async (question: string) => {
+      const response = await this.prompt(`${question} [Y/n]`, {
+        schema: t.enum(["Y", "y", "n", "no", "yes"], { default: "Y" }),
+      });
+      return response.charAt(0).toLowerCase() === "y";
+    };
+
     return askFn;
   }
 

package/src/email/index.ts

@@ -68,11 +68,19 @@ export const AlephaEmail = $module({
         use: NodemailerEmailProvider,
       });
     } else {
-      alepha.with({
-        optional: true,
-        provide: EmailProvider,
-        use: LocalEmailProvider,
-      });
+      if (alepha.isServerless()) {
+        alepha.with({
+          optional: true,
+          provide: EmailProvider,
+          use: MemoryEmailProvider,
+        });
+      } else {
+        alepha.with({
+          optional: true,
+          provide: EmailProvider,
+          use: LocalEmailProvider,
+        });
+      }
     }
   },
 });

package/src/orm/providers/drivers/NodeSqliteProvider.ts

@@ -82,10 +82,10 @@ export class NodeSqliteProvider extends DatabaseProvider {
       return path;
     }
 
-    if (this.alepha.isTest()) {
+    if (this.alepha.isTest() || this.alepha.isServerless()) {
       return ":memory:";
     } else {
-      return "node_modules/sqlite.db";
+      return "node_modules/.alepha/sqlite.db";
     }
   }
 
@@ -149,7 +149,7 @@ export class NodeSqliteProvider extends DatabaseProvider {
       if (filepath !== ":memory:" && filepath !== "") {
         const dirname = filepath.split("/").slice(0, -1).join("/");
         if (dirname) {
-          await mkdir(dirname, { recursive: true });
+          await mkdir(dirname, { recursive: true }).catch(() => null);
         }
       }
 

package/src/server-cookies/providers/ServerCookiesProvider.ts

@@ -11,6 +11,7 @@ import {
   $hook,
   $inject,
   Alepha,
+  AlephaError,
   type Static,
   type TSchema,
   t,
@@ -89,7 +90,7 @@ export class ServerCookiesProvider {
       this.alepha.context.get<ServerRequest>("request")?.cookies;
     if (cookies) return cookies;
     if (contextCookies) return contextCookies;
-    throw new Error(
+    throw new AlephaError(
       "Cookie context is not available. This method must be called within a server request cycle.",
     );
   }

package/src/server-static/providers/ServerStaticProvider.ts

@@ -98,8 +98,15 @@ export class ServerStaticProvider {
           reply.headers["content-type"] = "text/html";
           reply.status = 200;
 
-          // Serve index.html for all unmatched routes
-          return createReadStream(join(root, "index.html"));
+          return new Promise<any>((resolve, reject) => {
+            const stream = createReadStream(join(root, "index.html"));
+            stream.on("open", () => {
+              resolve(stream);
+            });
+            stream.on("error", (err) => {
+              reject(err);
+            });
+          });
         },
       });
     }
@@ -161,7 +168,15 @@ export class ServerStaticProvider {
         return;
       }
 
-      return createReadStream(path);
+      return new Promise<any>((resolve, reject) => {
+        const stream = createReadStream(path);
+        stream.on("open", () => {
+          resolve(stream);
+        });
+        stream.on("error", (err) => {
+          reject(err);
+        });
+      });
     };
   }