alepha 0.15.2 → 0.15.3

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

@@ -64,7 +64,7 @@ export class CloudflareD1Provider extends DatabaseProvider {
   protected readonly env = $env(
     t.object({
       DATABASE_URL: t.string({
-        description: "Expect to be 'cloudflare-d1://name:id'",
+        description: "Expect to be 'd1://name:id'",
       }),
     }),
   );
@@ -104,41 +104,68 @@ export class CloudflareD1Provider extends DatabaseProvider {
   protected readonly onStart = $hook({
     on: "start",
     handler: async () => {
-      const [bindingName] = this.env.DATABASE_URL.replace(
-        "cloudflare-d1://",
-        "",
-      ).split(":");
-      const cloudflareEnv = this.alepha.store.get("cloudflare.env" as any);
-      if (!cloudflareEnv) {
-        throw new AlephaError(
-          "Cloudflare Workers environment not found in Alepha store under 'cloudflare.env'.",
+      try {
+        const [bindingName] = this.env.DATABASE_URL.replace("d1://", "").split(
+          ":",
         );
+        const cloudflareEnv = this.alepha.store.get("cloudflare.env" as any);
+        if (!cloudflareEnv) {
+          throw new AlephaError(
+            "Cloudflare Workers environment not found in Alepha store under 'cloudflare.env'.",
+          );
+        }
+
+        const binding = cloudflareEnv[bindingName] as D1Database;
+        if (!binding) {
+          throw new AlephaError(
+            `D1 binding '${bindingName}' not found in Cloudflare Workers environment.`,
+          );
+        }
+
+        this.d1 = binding;
+
+        // Dynamic import to avoid crashes when not on Cloudflare
+        const { drizzle } = await import("drizzle-orm/d1");
+
+        this.drizzleDb = drizzle(this.d1) as DrizzleD1Database;
+
+        // Never migrate in serverless mode - D1 migrations must be applied
+        // via `wrangler d1 migrations apply` before deployment
+        if (!this.alepha.isServerless()) {
+          await this.migrate();
+        }
+
+        this.log.info("Using Cloudflare D1 database");
+      } catch (error) {
+        // Log the full error for debugging since Cloudflare Workers
+        // doesn't properly display error causes
+        const errorMessage =
+          error instanceof Error
+            ? `${error.message}${error.stack ? `\n${error.stack}` : ""}`
+            : String(error);
+        this.log.error(`D1 initialization failed: ${errorMessage}`);
+        throw error;
       }
-
-      const binding = cloudflareEnv[bindingName] as D1Database;
-      if (!binding) {
-        throw new AlephaError(
-          `D1 binding '${bindingName}' not found in Cloudflare Workers environment.`,
-        );
-      }
-
-      this.d1 = binding;
-
-      // Dynamic import to avoid crashes when not on Cloudflare
-      const { drizzle } = await import("drizzle-orm/d1");
-
-      this.drizzleDb = drizzle(this.d1) as DrizzleD1Database;
-
-      await this.migrate();
-
-      this.log.info("Using Cloudflare D1 database");
     },
   });
 
   protected async executeMigrations(migrationsFolder: string): Promise<void> {
-    // Dynamic import for D1 migrator
-    const { migrate } = await import("drizzle-orm/d1/migrator");
-    await migrate(this.db as any, { migrationsFolder });
+    this.log.debug(`Running D1 migrations from '${migrationsFolder}'...`);
+    try {
+      // Dynamic import for D1 migrator
+      const { migrate } = await import("drizzle-orm/d1/migrator");
+      await migrate(this.db as any, { migrationsFolder });
+      this.log.debug("D1 migrations completed successfully");
+    } catch (error) {
+      const errorMessage =
+        error instanceof Error
+          ? `${error.name}: ${error.message}`
+          : String(error);
+      throw new AlephaError(
+        `D1 migration failed from '${migrationsFolder}': ${errorMessage}`,
+        { cause: error },
+      );
+    }
   }
 
   /**

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

@@ -97,9 +97,17 @@ export abstract class DatabaseProvider {
   }
 
   /**
-   * Base migration orchestration - handles environment logic
+   * Base migration orchestration - handles environment logic.
+   *
+   * Never runs in serverless mode - migrations should be applied during
+   * deployment, not at runtime (to avoid race conditions and timeouts).
    */
   public async migrate(): Promise<void> {
+    // Never migrate in serverless mode - migrations should be applied during deployment
+    if (this.alepha.isServerless()) {
+      return;
+    }
+
     const migrationsFolder = this.getMigrationsFolder();
 
     // Handle different environments

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

@@ -157,7 +157,10 @@ export class NodeSqliteProvider extends DatabaseProvider {
 
       this.sqlite = new DatabaseSync(filepath);
 
-      await this.migrate();
+      // Never migrate in serverless mode - migrations should be applied during deployment
+      if (!this.alepha.isServerless()) {
+        await this.migrate();
+      }
 
       this.log.info(`Using SQLite database at ${filepath}`);
     },

package/src/react/router/hooks/useActive.ts

@@ -36,7 +36,7 @@ export const useActive = (args: string | UseActiveOptions): UseActiveHook => {
 
         setPending(true);
         try {
-          await router.go(href);
+          await router.push(href);
         } finally {
           setPending(false);
         }

package/src/react/router/hooks/useRouter.ts

@@ -13,7 +13,7 @@ import { ReactRouter } from "../services/ReactRouter.ts";
  * }
  *
  * const router = useRouter<App>();
- * router.go("home"); // typesafe
+ * router.push("home"); // typesafe
  */
 export const useRouter = <T extends object = any>(): ReactRouter<T> => {
   return useInject(ReactRouter<T>);

package/src/react/router/index.ts

@@ -11,6 +11,7 @@ import {
   ReactPageProvider,
   type ReactRouterState,
 } from "./providers/ReactPageProvider.ts";
+import { ReactPreloadProvider } from "./providers/ReactPreloadProvider.ts";
 import { ReactServerProvider } from "./providers/ReactServerProvider.ts";
 import { ReactServerTemplateProvider } from "./providers/ReactServerTemplateProvider.ts";
 import { SSRManifestProvider } from "./providers/SSRManifestProvider.ts";
@@ -23,6 +24,7 @@ import { ReactRouter } from "./services/ReactRouter.ts";
 export * from "./index.shared.ts";
 export * from "./providers/ReactBrowserProvider.ts";
 export * from "./providers/ReactPageProvider.ts";
+export * from "./providers/ReactPreloadProvider.ts";
 export * from "./providers/ReactServerProvider.ts";
 export * from "./providers/ReactServerTemplateProvider.ts";
 export * from "./providers/SSRManifestProvider.ts";
@@ -117,6 +119,7 @@ export const AlephaReactRouter = $module({
   services: [
     ReactPageProvider,
     ReactPageService,
+    ReactPreloadProvider,
     ReactRouter,
     ReactServerProvider,
     ReactServerTemplateProvider,
@@ -136,6 +139,7 @@ export const AlephaReactRouter = $module({
       })
       .with(SSRManifestProvider)
       .with(ReactServerTemplateProvider)
+      .with(ReactPreloadProvider)
       .with(ReactServerProvider)
       .with(ReactPageProvider)
       .with(ReactRouter),

package/src/react/router/primitives/$page.browser.spec.tsx

@@ -34,7 +34,7 @@ describe("$page browser tests", () => {
     const router = alepha.inject(ReactRouter);
 
     await act(async () => {
-      await router.go("/");
+      await router.push("/");
     });
 
     await waitFor(() => {
@@ -64,7 +64,7 @@ describe("$page browser tests", () => {
 
     // Navigate to home
     await act(async () => {
-      await router.go("/");
+      await router.push("/");
     });
 
     await waitFor(() => {
@@ -73,7 +73,7 @@ describe("$page browser tests", () => {
 
     // Navigate to about
     await act(async () => {
-      await router.go("/about");
+      await router.push("/about");
     });
 
     await waitFor(() => {
@@ -119,7 +119,7 @@ describe("$page browser tests", () => {
       const router = alepha.inject(ReactRouter);
 
       await act(async () => {
-        await router.go("/user/123");
+        await router.push("/user/123");
       });
 
       await waitFor(() => {
@@ -153,7 +153,7 @@ describe("$page browser tests", () => {
       const router = alepha.inject(ReactRouter);
 
       await act(async () => {
-        await router.go("/async");
+        await router.push("/async");
       });
 
       await waitFor(
@@ -204,7 +204,7 @@ describe("$page browser tests", () => {
 
       // Try to access protected - should redirect to login
       await act(async () => {
-        await router.go("/protected");
+        await router.push("/protected");
       });
 
       await waitFor(() => {
@@ -215,7 +215,7 @@ describe("$page browser tests", () => {
       isAuthenticated = true;
 
       await act(async () => {
-        await router.go("/protected");
+        await router.push("/protected");
       });
 
       await waitFor(() => {
@@ -248,7 +248,7 @@ describe("$page browser tests", () => {
       const router = alepha.inject(ReactRouter);
 
       await act(async () => {
-        await router.go("/error");
+        await router.push("/error");
       });
 
       await waitFor(() => {
@@ -294,7 +294,7 @@ describe("$page browser tests", () => {
 
       // Navigate to home - should show layout and home
       await act(async () => {
-        await router.go("/");
+        await router.push("/");
       });
 
       await waitFor(() => {
@@ -306,7 +306,7 @@ describe("$page browser tests", () => {
 
       // Navigate to about - layout should persist
       await act(async () => {
-        await router.go("/about");
+        await router.push("/about");
       });
 
       await waitFor(() => {
@@ -348,7 +348,7 @@ describe("$page browser tests", () => {
       const router = alepha.inject(ReactRouter);
 
       await act(async () => {
-        await router.go("/page");
+        await router.push("/page");
       });
 
       await waitFor(() => {
@@ -404,7 +404,7 @@ describe("$page browser tests", () => {
       const router = alepha.inject(ReactRouter);
 
       await act(async () => {
-        await router.go("/section/page");
+        await router.push("/section/page");
       });
 
       await waitFor(() => {
@@ -441,7 +441,7 @@ describe("$page browser tests", () => {
 
       // Navigate to home
       await act(async () => {
-        await router.go("/");
+        await router.push("/");
       });
 
       await waitFor(() => {
@@ -452,7 +452,7 @@ describe("$page browser tests", () => {
 
       // Navigate away from home to about
       await act(async () => {
-        await router.go("/about");
+        await router.push("/about");
       });
 
       await waitFor(() => {
@@ -490,7 +490,7 @@ describe("$page browser tests", () => {
 
       // Navigate to home first
       await act(async () => {
-        await router.go("/");
+        await router.push("/");
       });
 
       await waitFor(() => {
@@ -503,7 +503,7 @@ describe("$page browser tests", () => {
 
       // Navigate to about - onEnter should be called
       await act(async () => {
-        await router.go("/about");
+        await router.push("/about");
       });
 
       await waitFor(() => {
@@ -533,7 +533,7 @@ describe("$page browser tests", () => {
 
       // Navigate to home - onEnter should be called
       await act(async () => {
-        await router.go("/");
+        await router.push("/");
       });
 
       await waitFor(() => {
@@ -582,7 +582,7 @@ describe("$page browser tests", () => {
 
       // Navigate to child1
       await act(async () => {
-        await router.go("/child1");
+        await router.push("/child1");
       });
 
       await waitFor(() => {
@@ -595,7 +595,7 @@ describe("$page browser tests", () => {
 
       // Navigate to child2 - parent onEnter should NOT be called again
       await act(async () => {
-        await router.go("/child2");
+        await router.push("/child2");
       });
 
       await waitFor(() => {
@@ -633,7 +633,7 @@ describe("$page browser tests", () => {
       const router = alepha.inject(ReactRouter);
 
       await act(async () => {
-        await router.go("/user/abc123");
+        await router.push("/user/abc123");
       });
 
       await waitFor(() => {
@@ -678,7 +678,7 @@ describe("$page browser tests", () => {
       const router = alepha.inject(ReactRouter);
 
       await act(async () => {
-        await router.go("/search?q=typescript&page=2");
+        await router.push("/search?q=typescript&page=2");
       });
 
       await waitFor(() => {
@@ -728,7 +728,7 @@ describe("$page browser tests", () => {
 
       // Navigate with query params
       await act(async () => {
-        await router.go("/search?q=alepha&page=5");
+        await router.push("/search?q=alepha&page=5");
       });
 
       await waitFor(() => {
@@ -783,7 +783,7 @@ describe("$page browser tests", () => {
       const router = alepha.inject(ReactRouter);
 
       await act(async () => {
-        await router.go("/users/john/posts?sort=popular&limit=20");
+        await router.push("/users/john/posts?sort=popular&limit=20");
       });
 
       await waitFor(() => {
@@ -835,7 +835,7 @@ describe("$page browser tests", () => {
 
       // Navigate without query params - should use defaults
       await act(async () => {
-        await router.go("/search");
+        await router.push("/search");
       });
 
       await waitFor(() => {

package/src/react/router/primitives/$page.spec.tsx

@@ -521,38 +521,6 @@ describe("$page primitive tests", () => {
     expect(functionRendered.html).toBe("Function animation");
   });
 
-  test("$page - match method (not implemented)", ({ expect }) => {
-    class App {
-      page = $page({
-        path: "/test",
-        component: () => "test",
-      });
-    }
-
-    const app = alepha.inject(App);
-
-    expect(app.page.match("/test")).toBe(false);
-    expect(app.page.match("/other")).toBe(false);
-  });
-
-  test("$page - pathname method", ({ expect }) => {
-    class App {
-      withPath = $page({
-        path: "/test/:id",
-        component: () => "test",
-      });
-
-      withoutPath = $page({
-        component: () => "test",
-      });
-    }
-
-    const app = alepha.inject(App);
-
-    expect(app.withPath.pathname({})).toBe("/test/:id");
-    expect(app.withoutPath.pathname({})).toBe("");
-  });
-
   test("$page - complex schema with nested objects", async ({ expect }) => {
     class App {
       complex = $page({

package/src/react/router/primitives/$page.ts

@@ -368,10 +368,7 @@ export interface PagePrimitiveOptions<
   [PAGE_PRELOAD_KEY]?: string;
 }
 
-export type ErrorHandler = (
-  error: Error,
-  state: ReactRouterState,
-) => ReactNode | Redirection | undefined;
+// ---------------------------------------------------------------------------------------------------------------------
 
 export class PagePrimitive<
   TConfig extends PageConfigSchema = PageConfigSchema,
@@ -413,22 +410,17 @@ export class PagePrimitive<
   }> {
     return this.reactPageService.fetch(this.options.path || "", options);
   }
-
-  public match(url: string): boolean {
-    // TODO: Implement a way to match the URL against the pathname
-    return false;
-  }
-
-  public pathname(config: any) {
-    // TODO: Implement a way to generate the pathname based on the config
-    return this.options.path || "";
-  }
 }
 
 $page[KIND] = PagePrimitive;
 
 // ---------------------------------------------------------------------------------------------------------------------
 
+export type ErrorHandler = (
+  error: Error,
+  state: ReactRouterState,
+) => ReactNode | Redirection | undefined;
+
 export interface PageConfigSchema {
   query?: TSchema;
   params?: TSchema;

package/src/react/router/providers/ReactBrowserProvider.ts

@@ -12,14 +12,14 @@ import { DateTimeProvider } from "alepha/datetime";
 import { $logger } from "alepha/logger";
 import { BrowserHeadProvider } from "alepha/react/head";
 import { LinkProvider } from "alepha/server/links";
-import type { RouterGoOptions } from "../services/ReactRouter.ts";
+import type { RouterPushOptions } from "../services/ReactRouter.ts";
 import { ReactBrowserRouterProvider } from "./ReactBrowserRouterProvider.ts";
 import type {
   PreviousLayerData,
   ReactRouterState,
 } from "./ReactPageProvider.ts";
 
-export type { RouterGoOptions } from "../services/ReactRouter.ts";
+export type { RouterPushOptions } from "../services/ReactRouter.ts";
 
 /**
  * React browser renderer configuration atom
@@ -158,7 +158,10 @@ export class ReactBrowserProvider {
     await this.render({ previous });
   }
 
-  public async go(url: string, options: RouterGoOptions = {}): Promise<void> {
+  public async push(
+    url: string,
+    options: RouterPushOptions = {},
+  ): Promise<void> {
     this.log.trace(`Going to ${url}`, {
       url,
       options,

package/src/react/router/providers/ReactPageProvider.ts

@@ -101,7 +101,7 @@ export class ReactPageProvider {
   ) {
     const page = this.page(name);
     if (!page) {
-      throw new Error(`Page ${name} not found`);
+      throw new AlephaError(`Page ${name} not found`);
     }
 
     let url = page.path ?? "";

package/src/react/router/providers/ReactPreloadProvider.spec.ts

@@ -0,0 +1,142 @@
+import { Alepha } from "alepha";
+import { HttpClient, ServerProvider } from "alepha/server";
+import { describe, it } from "vitest";
+import { ssrManifestAtom } from "../atoms/ssrManifestAtom.ts";
+import { $page } from "../index.ts";
+
+describe("ReactPreloadProvider", () => {
+  class App {
+    home = $page({
+      path: "/",
+      component: () => "Hello World",
+    });
+  }
+
+  it("should add Link header with entry assets to HTML responses", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create({
+      env: { LOG_LEVEL: "error", SERVER_PORT: 0 },
+    }).with(App);
+
+    // Set up mock SSR manifest with entry assets
+    alepha.store.set(ssrManifestAtom, {
+      client: {
+        "src/entry.tsx": {
+          file: "assets/entry.abc123.js",
+          isEntry: true,
+          css: ["assets/style.def456.css"],
+        },
+      },
+    });
+
+    await alepha.start();
+
+    const server = alepha.inject(ServerProvider);
+    const http = alepha.inject(HttpClient);
+
+    const response = await http.fetch(`${server.hostname}/`);
+
+    // Check that the Link header is present
+    const linkHeader = response.headers.get("link");
+    expect(linkHeader).toBeTruthy();
+    expect(linkHeader).toContain(
+      "</assets/style.def456.css>; rel=preload; as=style",
+    );
+    expect(linkHeader).toContain(
+      "</assets/entry.abc123.js>; rel=modulepreload",
+    );
+
+    await alepha.stop();
+  });
+
+  it("should not add Link header when no SSR manifest is available", async ({
+    expect,
+  }) => {
+    const alepha = Alepha.create({
+      env: { LOG_LEVEL: "error", SERVER_PORT: 0 },
+    }).with(App);
+
+    // No SSR manifest set
+
+    await alepha.start();
+
+    const server = alepha.inject(ServerProvider);
+    const http = alepha.inject(HttpClient);
+
+    const response = await http.fetch(`${server.hostname}/`);
+
+    // Link header should not be present (or empty)
+    const linkHeader = response.headers.get("link");
+    expect(linkHeader).toBeNull();
+
+    await alepha.stop();
+  });
+
+  it("should handle base path in manifest", async ({ expect }) => {
+    const alepha = Alepha.create({
+      env: { LOG_LEVEL: "error", SERVER_PORT: 0 },
+    }).with(App);
+
+    // Set up mock SSR manifest with base path
+    alepha.store.set(ssrManifestAtom, {
+      base: "/app",
+      client: {
+        "src/entry.tsx": {
+          file: "assets/entry.abc123.js",
+          isEntry: true,
+          css: ["assets/style.def456.css"],
+        },
+      },
+    });
+
+    await alepha.start();
+
+    const server = alepha.inject(ServerProvider);
+    const http = alepha.inject(HttpClient);
+
+    const response = await http.fetch(`${server.hostname}/`);
+
+    // Check that the Link header includes base path
+    const linkHeader = response.headers.get("link");
+    expect(linkHeader).toBeTruthy();
+    expect(linkHeader).toContain(
+      "</app/assets/style.def456.css>; rel=preload; as=style",
+    );
+    expect(linkHeader).toContain(
+      "</app/assets/entry.abc123.js>; rel=modulepreload",
+    );
+
+    await alepha.stop();
+  });
+
+  it("should handle entry with only JS (no CSS)", async ({ expect }) => {
+    const alepha = Alepha.create({
+      env: { LOG_LEVEL: "error", SERVER_PORT: 0 },
+    }).with(App);
+
+    // Set up mock SSR manifest with only JS entry
+    alepha.store.set(ssrManifestAtom, {
+      client: {
+        "src/entry.tsx": {
+          file: "assets/entry.abc123.js",
+          isEntry: true,
+        },
+      },
+    });
+
+    await alepha.start();
+
+    const server = alepha.inject(ServerProvider);
+    const http = alepha.inject(HttpClient);
+
+    const response = await http.fetch(`${server.hostname}/`);
+
+    // Check that the Link header contains only JS modulepreload
+    const linkHeader = response.headers.get("link");
+    expect(linkHeader).toBeTruthy();
+    expect(linkHeader).toBe("</assets/entry.abc123.js>; rel=modulepreload");
+
+    await alepha.stop();
+  });
+});