alepha 0.13.5 → 0.13.7

package/src/vite/tasks/buildServer.ts

@@ -85,6 +85,7 @@ export async function buildServer(
       noExternal: true,
     },
     build: {
+      sourcemap: true, // or "hidden" if you don't want to expose source maps
       ssr: opts.entry,
       outDir: `${opts.distDir}/server`,
       minify: true,
@@ -133,7 +134,7 @@ export async function buildServer(
       `${opts.distDir}/${opts.clientDir}/index.html`,
       "utf-8",
     );
-    template = `process.env.REACT_SERVER_TEMPLATE ??= \`${index.replace(/>\s*</g, "><").trim()}\`;\n`;
+    template = `__alepha.set("alepha.react.server.template", \`${index.replace(/>\s*</g, "><").trim()}\`);\n`;
   }
 
   const warning =
@@ -141,11 +142,9 @@ export async function buildServer(
     "\n" +
     "// Changes to this file will be lost when the code is regenerated.\n";
 
-  const forceProduction = "process.env.NODE_ENV ??= 'production';\n";
-
   await writeFile(
     `${opts.distDir}/index.js`,
-    `${warning}\n${forceProduction}${template}\nawait import('./server/${entryFile}');`.trim(),
+    `${warning}\nimport './server/${entryFile}';${template}`.trim(),
   );
 
   return { entryFile };

package/src/vite/tasks/generateCloudflare.ts

@@ -1,5 +1,5 @@
-import { writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
 
 export interface GenerateCloudflareOptions {
   /**
@@ -24,43 +24,59 @@ const WARNING_COMMENT =
 export async function generateCloudflare(
   opts: GenerateCloudflareOptions = {},
 ): Promise<void> {
-  const dist = opts.distDir ?? "dist";
+  const distDir = opts.distDir ?? "dist";
   const root = process.cwd();
+  const name = basename(root);
 
-  // Get current directory name for worker name
-  const parts = root.split("/");
-  const name = parts[parts.length - 1];
+  await writeWranglerConfig(root, distDir, name);
+  await writeWorkerEntryPoint(root, distDir);
+}
 
+/**
+ * Write the wrangler.jsonc configuration file for Cloudflare Workers
+ */
+async function writeWranglerConfig(
+  root: string,
+  distDir: string,
+  name: string,
+): Promise<void> {
   const wrangler = {
-    name: name,
-    main: "./worker.js",
+    name,
+    main: "./main.cloudflare.js",
     compatibility_flags: ["nodejs_compat"],
     compatibility_date: "2025-11-17",
   };
 
-  writeFileSync(
-    join(root, dist, "wrangler.jsonc"),
+  await writeFile(
+    join(root, distDir, "wrangler.jsonc"),
     JSON.stringify(wrangler, null, 2),
   );
+}
 
+/**
+ * Write the worker entry point that bootstraps Alepha and handles fetch requests
+ */
+async function writeWorkerEntryPoint(
+  root: string,
+  distDir: string,
+): Promise<void> {
   const workerCode = `
-process.env.ALEPHA_SERVERLESS = "true";
-
-await import("./index.js");
+import "./index.js";
 
 export default {
-  fetch: async (request, env, ctx) => {
+  fetch: async (request) => {
+    const ctx = { req: request, res: undefined };
 
     await __alepha.start();
-    const ev = { req: request, res: undefined };
-    await __alepha.events.emit("web:request", ev);
-    return ev.res;
+    await __alepha.events.emit("web:request", ctx);
+
+    return ctx.res;
   },
 };
 `.trim();
 
-  writeFileSync(
-    join(root, dist, "worker.js"),
+  await writeFile(
+    join(root, distDir, "main.cloudflare.js"),
     `${WARNING_COMMENT}\n${workerCode}`.trim(),
   );
 }

package/src/vite/tasks/generateDocker.ts

@@ -38,14 +38,28 @@ export async function generateDocker(
   const image = opts.image ?? "node:24-alpine";
   const command = opts.command ?? "node";
 
-  // Copy drizzle migrations if they exist
+  await copyDrizzleMigrations(distDir);
+  await writeDockerfile(distDir, image, command);
+}
+
+/**
+ * Copy drizzle migrations to the dist directory if they exist
+ */
+async function copyDrizzleMigrations(distDir: string): Promise<void> {
   const hasMigrations = await fileExists("drizzle");
   if (hasMigrations) {
-    await cp("drizzle", `${distDir}/drizzle`, {
-      recursive: true,
-    });
+    await cp("drizzle", `${distDir}/drizzle`, { recursive: true });
   }
+}
 
+/**
+ * Write the Dockerfile with the specified base image and command
+ */
+async function writeDockerfile(
+  distDir: string,
+  image: string,
+  command: string,
+): Promise<void> {
   const dockerfile = `# This file was automatically generated. DO NOT MODIFY.
 # Changes to this file will be lost when the code is regenerated.
 FROM ${image}

package/src/vite/tasks/generateSitemap.ts

@@ -28,13 +28,11 @@ export interface GenerateSitemapOptions {
 export async function generateSitemap(
   opts: GenerateSitemapOptions,
 ): Promise<string> {
-  const alepha = await importAlepha(opts.entry, {
-    env: opts.template
-      ? {
-          REACT_SERVER_TEMPLATE: opts.template,
-        }
-      : {},
-  });
+  const alepha = await importAlepha(opts.entry);
+
+  if (opts.template) {
+    alepha.set("alepha.react.server.template", opts.template);
+  }
 
   if (!alepha.isConfigured()) {
     await alepha.events.emit("configure", alepha);

package/src/vite/tasks/generateVercel.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { mkdir, stat, writeFile } from "node:fs/promises";
 import { importVite } from "../helpers/importVite.ts";
 
 export interface GenerateVercelOptions {
@@ -52,33 +52,62 @@ export async function generateVercel(
   const distDir = opts.distDir ?? "dist";
   const clientDir = opts.clientDir ?? "public";
   const { loadEnv } = await importVite();
-
   const env = loadEnv("production", process.cwd(), "");
 
-  // Ensure the api directory exists
-  if (!existsSync(`${distDir}/api`)) {
-    mkdirSync(`${distDir}/api`);
+  await writeApiEntryPoint(distDir);
+  await writeVercelConfig(distDir, clientDir, opts.config?.config);
+
+  const projectId = env.VERCEL_PROJECT_ID ?? opts.config?.projectId;
+  const projectName = env.VERCEL_PROJECT_NAME ?? opts.config?.projectName;
+  const orgId = env.VERCEL_ORG_ID ?? opts.config?.orgId;
+
+  if (projectId && orgId) {
+    await writeProjectConfig(distDir, projectId, projectName, orgId);
   }
 
-  // Add the only one entry point for Vercel
-  writeFileSync(
+  await ensureClientDir(distDir, clientDir);
+}
+
+/**
+ * Check if a file or directory exists at the given path
+ */
+async function exists(path: string): Promise<boolean> {
+  return stat(path)
+    .then(() => true)
+    .catch(() => false);
+}
+
+/**
+ * Create the serverless function entry point that bootstraps Alepha and handles requests
+ */
+async function writeApiEntryPoint(distDir: string): Promise<void> {
+  await mkdir(`${distDir}/api`, { recursive: true });
+  await writeFile(
     `${distDir}/api/index.js`,
     `${WARNING_COMMENT}
 import "../index.js";
 
-export default async function (req, res) {
+export default async (req, res) => {
 \tawait __alepha.start();
-\t__alepha.events.emit("node:request", { req, res });
+\tawait __alepha.events.emit("node:request", { req, res });
 }
 `,
   );
+}
 
-  // Always generate a vercel.json file
-  writeFileSync(
+/**
+ * Generate vercel.json with route rewrites to direct all traffic to the serverless function
+ */
+async function writeVercelConfig(
+  distDir: string,
+  clientDir: string,
+  config?: VercelConfig["config"],
+): Promise<void> {
+  await writeFile(
     `${distDir}/vercel.json`,
     JSON.stringify(
       {
-        ...opts?.config?.config,
+        ...config,
         rewrites: [
           {
             source: "/(.*)",
@@ -93,36 +122,42 @@ export default async function (req, res) {
       "  ",
     ),
   );
+}
 
-  // Generate .vercel/project.json if VERCEL_PROJECT_ID and VERCEL_ORG_ID are set
-  const projectId = env.VERCEL_PROJECT_ID ?? opts.config?.projectId;
-  const projectName = env.VERCEL_PROJECT_NAME ?? opts.config?.projectName;
-  const orgId = env.VERCEL_ORG_ID ?? opts.config?.orgId;
-
-  if (projectId && orgId) {
-    try {
-      mkdirSync(`${distDir}/.vercel`, { recursive: true });
-    } catch (_e) {
-      // Ignore error if directory already exists
-    }
-
-    writeFileSync(
-      `${distDir}/.vercel/project.json`,
-      JSON.stringify(
-        {
-          projectId,
-          projectName,
-          orgId,
-        },
-        null,
-        "  ",
-      ),
-    );
-  }
+/**
+ * Generate .vercel/project.json to link the deployment to a Vercel project
+ */
+async function writeProjectConfig(
+  distDir: string,
+  projectId: string,
+  projectName: string | undefined,
+  orgId: string,
+): Promise<void> {
+  await mkdir(`${distDir}/.vercel`, { recursive: true });
+  await writeFile(
+    `${distDir}/.vercel/project.json`,
+    JSON.stringify(
+      {
+        projectId,
+        projectName,
+        orgId,
+      },
+      null,
+      "  ",
+    ),
+  );
+}
 
-  // If /public does not exist, create an empty one to avoid Vercel errors
-  if (!existsSync(`${distDir}/${clientDir}`)) {
-    mkdirSync(`${distDir}/${clientDir}`, { recursive: true });
-    writeFileSync(`${distDir}/${clientDir}/.keep`, "");
+/**
+ * Create the client directory with a .keep file if it doesn't exist to avoid Vercel errors
+ */
+async function ensureClientDir(
+  distDir: string,
+  clientDir: string,
+): Promise<void> {
+  const path = `${distDir}/${clientDir}`;
+  if (!(await exists(path))) {
+    await mkdir(path, { recursive: true });
+    await writeFile(`${path}/.keep`, "");
   }
 }

package/src/vite/tasks/runAlepha.ts

@@ -91,6 +91,18 @@ export class AlephaRunner {
   async start(server: ViteDevServer): Promise<void> {
     const { loadEnv } = await importVite();
 
+    // unfortunately, vite SSR loader does not fix stack traces automatically
+    // for now, we make a global helper and alepha/logger will use it before logging errors
+    // that's not ideal but works for now
+    (global as any).ssrFixStacktrace = (e: Error) => {
+      server.ssrFixStacktrace(e);
+      let it: any = e;
+      do {
+        server.ssrFixStacktrace(it);
+        it = it.cause;
+      } while (it instanceof Error);
+    };
+
     if (this.state.started) {
       await this.restart(server, true);
       return;
@@ -130,7 +142,9 @@ export class AlephaRunner {
 
     try {
       const now = Date.now();
-      await server.ssrLoadModule(fileUrl);
+      await server.ssrLoadModule(fileUrl, {
+        fixStacktrace: true,
+      });
       this.state.log(`[DEBUG] Alepha app loaded in ${Date.now() - now}ms`);
       await new Promise((r) => setTimeout(r, 10));
 
@@ -160,6 +174,7 @@ export class AlephaRunner {
         if (e.cause instanceof Error) {
           server.ssrFixStacktrace(e.cause);
         }
+
         this.state.app?.log?.error("App failed to start:", e);
         this.state.app?.log?.info("Waiting for changes to restart...");
       }

package/src/websocket/providers/NodeWebSocketServerProvider.ts

@@ -1,13 +1,5 @@
 import type { IncomingMessage } from "node:http";
-import {
-  $env,
-  $hook,
-  $inject,
-  Alepha,
-  type Static,
-  TypeBoxValue,
-  t,
-} from "alepha";
+import { $env, $hook, $inject, Alepha, type Static, t, Value } from "alepha";
 import { $logger } from "alepha/logger";
 import { WebSocket, WebSocketServer } from "ws";
 import { WebSocketValidationError } from "../errors/WebSocketError.ts";
@@ -507,8 +499,8 @@ export class NodeWebSocketConnection implements WebSocketConnection {
 
       // Validate message against schema (out = client→server)
       const outSchema = this.endpoint.channel.options.schema.out;
-      if (!TypeBoxValue.Check(outSchema, message)) {
-        const errors = Array.from(TypeBoxValue.Errors(outSchema, message));
+      if (!Value.Check(outSchema, message)) {
+        const errors = Array.from(Value.Errors(outSchema, message));
         throw new WebSocketValidationError(
           `Message validation failed: ${errors.map((e: any) => e.message).join(", ")}`,
         );

package/src/websocket/services/WebSocketClient.ts

@@ -4,8 +4,8 @@ import {
   Alepha,
   AlephaError,
   type Static,
-  TypeBoxValue,
   t,
+  Value,
 } from "alepha";
 import { $logger } from "alepha/logger";
 import type { ChannelPrimitive, TWSObject } from "../primitives/$channel.ts";
@@ -332,8 +332,8 @@ export class WebSocketChannelConnection<
 
     // Validate outgoing message against schema
     const outSchema = this.channel.options.schema.out;
-    if (!TypeBoxValue.Check(outSchema, message)) {
-      const errors = Array.from(TypeBoxValue.Errors(outSchema, message));
+    if (!Value.Check(outSchema, message)) {
+      const errors = Array.from(Value.Errors(outSchema, message));
       this.log.warn("Message validation failed", { errors });
       throw new Error(
         `Message validation failed: ${errors.map((e) => e.message).join(", ")}`,