alepha 0.15.0 → 0.15.1

package/src/vite/plugins/viteAlephaDev.ts

@@ -1,177 +0,0 @@
-import type { IncomingMessage, ServerResponse } from "node:http";
-import type { Plugin, ResolvedConfig, UserConfig } from "vite";
-import { boot } from "../helpers/boot.ts";
-import { importVite } from "../helpers/importVite.ts";
-import { createAlephaRunner, isViteInternalPath } from "../tasks/runAlepha.ts";
-
-export interface ViteAlephaDevOptions {
-  /**
-   * Path to the entry file for the server build.
-   * If empty, plugin will be disabled.
-   */
-  serverEntry?: string | false;
-
-  /**
-   * If true, enables debug logging.
-   *
-   * @default false
-   */
-  debug?: boolean;
-}
-
-/**
- * Plug Alepha into Vite development server.
- *
- * This plugin manages the Alepha application lifecycle during development,
- * handling hot module replacement and request forwarding.
- */
-export async function viteAlephaDev(
-  options: ViteAlephaDevOptions = {},
-): Promise<Plugin> {
-  let entry = options.serverEntry;
-  if (!entry) {
-    entry = await boot.getServerEntry();
-    if (!entry) {
-      return {
-        name: "alepha-dev",
-        apply: "serve",
-        config() {},
-      };
-    }
-  }
-
-  const runner = createAlephaRunner({
-    entry,
-    debug: options.debug,
-  });
-
-  const { loadEnv } = await importVite();
-  const env = loadEnv("development", process.cwd(), "SERVER");
-
-  const config: UserConfig = {};
-  if (env.SERVER_PORT) {
-    config.server = {
-      port: parseInt(env.SERVER_PORT, 10),
-    };
-  }
-
-  return {
-    name: "alepha-dev",
-    apply: "serve",
-    config: () => config,
-    configResolved(resolvedConfig: ResolvedConfig) {
-      runner.setConfig(resolvedConfig);
-    },
-    async handleHotUpdate(ctx) {
-      if (options.debug) {
-        console.log("[DEBUG] HMR", ctx.file);
-      }
-
-      if (ctx.file.includes("/.idea/")) {
-        return [];
-      }
-
-      const isServerOnly = !ctx.modules[0]?._clientModule;
-      const isBrowserOnly = !ctx.modules[0]?._ssrModule;
-      const isSsrEnabled = runner.isSsrEnabled();
-
-      if (isBrowserOnly) {
-        if (options.debug) {
-          console.log(
-            "[DEBUG] HMR - browser only - no reason to reload server",
-          );
-        }
-        return;
-      }
-
-      const root = process.cwd().replace(/\\/g, "/");
-      const invalidate = !ctx.file.startsWith(root);
-      if (invalidate && options.debug) {
-        console.log("[DEBUG] HMR - outside root - invalidate all");
-      }
-
-      if (!isSsrEnabled && isServerOnly) {
-        await runner.restart(ctx.server, invalidate);
-        return [];
-      }
-
-      if (isSsrEnabled && ctx.modules[0]) {
-        const skip = await runner.restart(ctx.server, invalidate);
-        if (skip) {
-          return [];
-        }
-
-        if (!runner.isStarted) {
-          if (options.debug) {
-            console.log("[DEBUG] HMR - abort due to app not started");
-          }
-          return [];
-        }
-
-        if (isServerOnly && runner.isStarted) {
-          runner.sendReload(ctx.server);
-          return [];
-        }
-      }
-    },
-    async configureServer(server) {
-      if (env.SERVER_PORT) {
-        server.config.server.port = parseInt(env.SERVER_PORT, 10);
-      }
-      const middleware = (
-        req: IncomingMessage,
-        res: ServerResponse,
-        next: any,
-      ) => {
-        if (
-          runner.isStarted &&
-          runner.app &&
-          req.url &&
-          !isViteInternalPath(req.url)
-        ) {
-          // Patch res.end to detect if alepha handled the request
-          // If not, we call next() to let vite handle it (e.g. for static files)
-          let ended = false;
-
-          const writeHead = res.writeHead.bind(res);
-          res.writeHead = (...args: any[]) => {
-            ended = true;
-            return writeHead(args[0], args[1], args[2]);
-          };
-
-          return runner.app.events
-            .emit("node:request" as any, { req, res })
-            .then(() => {
-              if (!ended) {
-                next();
-              }
-            });
-        }
-        next();
-      };
-
-      // Forward vite request to alepha server
-      server.middlewares.use((req, res, next) => {
-        // TODO: wait if restarting ?
-        middleware(req, res, next);
-      });
-
-      server.config.logger.info = (msg: string) => {
-        console.log(msg);
-      };
-
-      server.config.logger.clearScreen = () => {};
-
-      // Return a function - it runs AFTER internal middlewares are set up
-      // and after buildStart has been called
-      return () => {
-        server.httpServer?.once("listening", () => {
-          runner.start(server);
-        });
-      };
-    },
-    async closeBundle() {
-      // Cleanup handled by runner
-    },
-  };
-}

package/src/vite/tasks/devServer.ts

@@ -1,71 +0,0 @@
-import type { InlineConfig } from "vite";
-import { importVite } from "../helpers/importVite.ts";
-import { importViteReact } from "../helpers/importViteReact.ts";
-import { viteAlephaDev } from "../plugins/viteAlephaDev.ts";
-import { viteAlephaSsrPreload } from "../plugins/viteAlephaSsrPreload.ts";
-
-export interface DevServerOptions {
-  /**
-   * Path to the server entry file.
-   * If not provided, will auto-detect.
-   */
-  entry?: string;
-
-  /**
-   * Port to run the dev server on.
-   */
-  port?: number;
-
-  /**
-   * Host to bind the dev server to.
-   */
-  host?: string | boolean;
-
-  /**
-   * Enable debug logging.
-   */
-  debug?: boolean;
-}
-
-/**
- * Start Vite development server with Alepha plugins.
- *
- * This task starts the Vite dev server with all required plugins:
- * - @vitejs/plugin-react (JSX/TSX compilation)
- * - viteAlephaDev (Alepha server integration)
- * - viteAlephaSsrPreload (SSR module preloading)
- */
-export async function devServer(opts: DevServerOptions = {}): Promise<void> {
-  const { createServer, mergeConfig } = await importVite();
-  const plugins: any[] = [];
-
-  // Add React plugin for JSX/TSX compilation
-  const viteReact = await importViteReact();
-  if (viteReact) plugins.push(viteReact());
-
-  // Add SSR preload plugin
-  plugins.push(viteAlephaSsrPreload());
-
-  // Add Alepha dev plugin
-  plugins.push(
-    await viteAlephaDev({
-      serverEntry: opts.entry,
-      debug: opts.debug,
-    }),
-  );
-
-  const config: InlineConfig = {
-    plugins,
-    server: {
-      port: opts.port,
-      host: opts.host,
-    },
-  };
-
-  const server = await createServer(mergeConfig(config, {}));
-  await server.listen();
-
-  console.log(""); // blank line
-  server.printUrls();
-  server.bindCLIShortcuts({ print: true });
-}

package/src/vite/tasks/runAlepha.ts

@@ -1,270 +0,0 @@
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-import type { Alepha, State } from "alepha";
-import type { ResolvedConfig, ViteDevServer } from "vite";
-import { importVite } from "../helpers/importVite.ts";
-
-export interface AlephaRunnerOptions {
-  /**
-   * Path to the server entry file.
-   */
-  entry: string;
-
-  /**
-   * Enable debug logging.
-   */
-  debug?: boolean;
-}
-
-export interface AlephaRunnerState {
-  root: string;
-  started: boolean;
-  app?: Alepha;
-  config?: ResolvedConfig;
-  lock?: PromiseWithResolvers<void>;
-  log: (...msg: string[]) => void;
-  entry: string;
-  onReload?: () => void;
-}
-
-/**
- * Create an Alepha runner for development.
- *
- * The runner manages the lifecycle of an Alepha application during
- * Vite dev server operation, handling start/stop/restart and HMR.
- */
-export function createAlephaRunner(opts: AlephaRunnerOptions): AlephaRunner {
-  const state: AlephaRunnerState = {
-    root: process.cwd().replace(/\\/g, "/"),
-    started: false,
-    log: opts.debug ? (...msg: string[]) => console.log(...msg) : () => {},
-    entry: opts.entry,
-    onReload: () => {},
-  };
-
-  return new AlephaRunner(state);
-}
-
-export class AlephaRunner {
-  protected state: AlephaRunnerState;
-
-  constructor(state: AlephaRunnerState) {
-    this.state = state;
-  }
-
-  /**
-   * Set resolved Vite config.
-   */
-  setConfig(config: ResolvedConfig): void {
-    this.state.config = config;
-  }
-
-  /**
-   * Check if SSR is enabled for the running app.
-   */
-  isSsrEnabled(): boolean {
-    if (!this.state.app) return false;
-    return (
-      (this.state.app.store.get("alepha.react.server.ssr" as keyof State) as
-        | boolean
-        | undefined) ?? false
-    );
-  }
-
-  /**
-   * Check if app is started.
-   */
-  get isStarted(): boolean {
-    return this.state.started;
-  }
-
-  /**
-   * Get the running Alepha app instance.
-   */
-  get app(): Alepha | undefined {
-    return this.state.app;
-  }
-
-  /**
-   * Start the Alepha application.
-   */
-  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;
-    }
-
-    if (!this.state.config) {
-      this.state.log("[DEBUG] No config - skip starting");
-      return;
-    }
-
-    this.state.onReload?.();
-
-    this.state.log("[DEBUG] Starting Alepha app...");
-
-    this.state.started = false;
-    this.state.app = undefined;
-
-    const serverEntryPath = path.resolve(
-      this.state.config.root,
-      this.state.entry,
-    );
-    const fileUrl = pathToFileURL(`${serverEntryPath}`).href;
-    const env = loadEnv("development", this.state.config.root, "");
-    const before = { ...process.env };
-
-    for (const key in env) {
-      process.env[key] = env[key];
-    }
-
-    let port = 5173;
-    const address = server.httpServer?.address();
-    if (typeof address === "object" && address?.port) {
-      port = address.port;
-    }
-
-    process.env.NODE_ENV ??= "development";
-    process.env.VITE_ALEPHA_DEV = "true";
-    process.env.SERVER_HOST ??=
-      typeof server.config.server.host === "string"
-        ? server.config.server.host
-        : "localhost";
-    process.env.SERVER_PORT ??= String(port);
-
-    try {
-      const now = Date.now();
-      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));
-
-      this.state.app = (globalThis as any).__alepha;
-      if (!this.state.app) {
-        this.state.log("[DEBUG] No app found - skip starting");
-        return;
-      }
-
-      this.state.app.store.set("alepha.node.server" as any, server.httpServer);
-
-      console.log("");
-      await this.state.app.start();
-      this.state.started = true;
-
-      process.env = { ...before };
-
-      this.state.log("[DEBUG] Starting Done!");
-    } catch (e) {
-      if (e instanceof Error) {
-        let it: any = e;
-        do {
-          server.ssrFixStacktrace(it);
-          it = it.cause;
-        } while (it instanceof Error);
-
-        server.ssrFixStacktrace(e);
-        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...");
-      }
-      this.state.log("[DEBUG] Alepha app start error");
-      this.state.started = false;
-    }
-  }
-
-  /**
-   * Stop the Alepha application.
-   */
-  async stop(): Promise<void> {
-    if (this.state.app?.stop && this.state.started) {
-      this.state.log("[DEBUG] Stopping Alepha app...");
-      await this.state.app.stop();
-      this.state.started = false;
-      this.state.log("[DEBUG] Stopping Done!");
-    } else {
-      this.state.log("[DEBUG] Alepha app not started - skip stop");
-    }
-  }
-
-  /**
-   * Restart the Alepha application.
-   *
-   * @returns true if the restart was skipped due to locking
-   */
-  async restart(server: ViteDevServer, invalidate?: boolean): Promise<boolean> {
-    if (this.state.lock) {
-      this.state.log("[DEBUG] STILL LOCKING");
-      return true;
-    }
-
-    this.state.log("[DEBUG] LOCK RESTART");
-    this.state.lock = Promise.withResolvers();
-
-    const now = Date.now();
-    this.state.log("[DEBUG] RESTART");
-    await this.stop();
-    this.state.log(`[DEBUG] RESTART (stop) in ${Date.now() - now}ms`);
-
-    if (invalidate) {
-      server.moduleGraph.invalidateAll();
-    }
-
-    await this.start(server);
-    this.state.log(`[DEBUG] RESTART OK in ${Date.now() - now}ms`);
-
-    setTimeout(() => {
-      this.state.log("[DEBUG] UNLOCK RESTART");
-      this.state.lock?.resolve();
-      this.state.lock = undefined;
-    }, 500);
-
-    return false;
-  }
-
-  /**
-   * Send reload event to client.
-   */
-  sendReload(server: ViteDevServer): void {
-    server.ws.send({
-      type: "custom",
-      event: "alepha:reload",
-      data: {},
-    });
-  }
-}
-
-/**
- * Check if a URL path is a Vite internal file.
- */
-export function isViteInternalPath(pathname: string): boolean {
-  const [path] = pathname.split("?");
-
-  // Vite internal files
-  if (
-    path.startsWith("/@") ||
-    path.startsWith("/src") ||
-    path.includes("/node_modules/")
-  ) {
-    return true;
-  }
-
-  return false;
-}