alepha 0.13.8 → 0.14.0

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

@@ -0,0 +1,164 @@
+import { $env, $hook, $inject, AlephaError, t } from "alepha";
+import { $logger } from "alepha/logger";
+import type { DrizzleD1Database } from "drizzle-orm/d1";
+import type { PgDatabase } from "drizzle-orm/pg-core";
+import { SqliteModelBuilder } from "../../services/SqliteModelBuilder.ts";
+import { DrizzleKitProvider } from "../DrizzleKitProvider.ts";
+import { DatabaseProvider, type SQLLike } from "./DatabaseProvider.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+/**
+ * D1Database interface matching Cloudflare's D1 API.
+ */
+export interface D1Database {
+  prepare(query: string): D1PreparedStatement;
+  batch<T = unknown>(statements: D1PreparedStatement[]): Promise<T[]>;
+  exec(query: string): Promise<D1ExecResult>;
+  dump(): Promise<ArrayBuffer>;
+}
+
+export interface D1PreparedStatement {
+  bind(...values: unknown[]): D1PreparedStatement;
+  first<T = unknown>(colName?: string): Promise<T | null>;
+  run(): Promise<D1Result>;
+  all<T = unknown>(): Promise<D1Result<T>>;
+  raw<T = unknown>(): Promise<T[]>;
+}
+
+export interface D1Result<T = unknown> {
+  results: T[];
+  success: boolean;
+  meta: {
+    duration: number;
+    changes: number;
+    last_row_id: number;
+    served_by: string;
+    internal_stats: unknown;
+  };
+}
+
+export interface D1ExecResult {
+  count: number;
+  duration: number;
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+/**
+ * Cloudflare D1 SQLite provider using Drizzle ORM.
+ *
+ * This provider requires a D1 binding to be set via `cloudflareD1Options` before starting.
+ * The binding is typically obtained from the Cloudflare Workers environment.
+ *
+ * @example
+ * ```ts
+ * // In your Cloudflare Worker
+ * alepha.set(cloudflareD1Options, { binding: env.DB });
+ * ```
+ */
+export class CloudflareD1Provider extends DatabaseProvider {
+  protected readonly kit = $inject(DrizzleKitProvider);
+  protected readonly log = $logger();
+  protected readonly builder = $inject(SqliteModelBuilder);
+  protected readonly env = $env(
+    t.object({
+      DATABASE_URL: t.string({
+        description: "Expect to be 'cloudflare-d1://name:id'",
+      }),
+    }),
+  );
+
+  protected d1?: D1Database;
+  protected drizzleDb?: DrizzleD1Database;
+
+  public get name() {
+    return "d1";
+  }
+
+  public override readonly dialect = "sqlite";
+
+  public override get url(): string {
+    return this.env.DATABASE_URL;
+  }
+
+  public override get db(): PgDatabase<any> {
+    if (!this.drizzleDb) {
+      throw new AlephaError("D1 database not initialized");
+    }
+
+    return this.drizzleDb as unknown as PgDatabase<any>;
+  }
+
+  public override async execute(
+    query: SQLLike,
+  ): Promise<Array<Record<string, unknown>>> {
+    const { rows } = await (this.db as any).run(query);
+    return rows;
+  }
+
+  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'.",
+        );
+      }
+
+      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.migrateDatabase();
+
+      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 });
+  }
+
+  /**
+   * Override development migration to skip sync (not supported on D1).
+   * D1 requires proper migrations to be applied.
+   */
+  protected override async runDevelopmentMigration(
+    migrationsFolder: string,
+  ): Promise<void> {
+    await this.executeMigrations(migrationsFolder);
+  }
+
+  /**
+   * Override test migration to run migrations instead of sync.
+   * D1 doesn't support schema synchronization.
+   */
+  protected override async runTestMigration(): Promise<void> {
+    const migrationsFolder = this.getMigrationsFolder();
+    try {
+      await this.executeMigrations(migrationsFolder);
+    } catch {
+      this.log.warn(
+        "D1 migrations failed in test environment - ensure migrations exist",
+      );
+    }
+  }
+}

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

@@ -145,7 +145,9 @@ export class NodeSqliteProvider extends DatabaseProvider {
     on: "start",
     handler: async () => {
       const { DatabaseSync } = await import("node:sqlite");
-      const filepath = this.url.replace("sqlite://", "");
+
+      const filepath = this.url.replace("sqlite://", "").replace("sqlite:", "");
+
       if (filepath !== ":memory:" && filepath !== "") {
         const dirname = filepath.split("/").slice(0, -1).join("/");
         if (dirname) {

package/src/vite/plugins/viteAlephaBuild.ts

@@ -1,4 +1,5 @@
 import { readFile, unlink, writeFile } from "node:fs/promises";
+import { OPTIONS } from "alepha";
 import type { Plugin, UserConfig } from "vite";
 import { boot } from "../helpers/boot.ts";
 import { fileExists } from "../helpers/fileExists.ts";
@@ -14,6 +15,7 @@ import {
   generateVercel,
   prerenderPages,
   type VercelConfig,
+  type WranglerConfig,
 } from "../tasks/index.ts";
 
 export interface ViteAlephaBuildOptions {
@@ -43,7 +45,7 @@ export interface ViteAlephaBuildOptions {
    *
    * @default false
    */
-  cloudflare?: boolean;
+  cloudflare?: boolean | WranglerConfig;
 
   /**
    * If true, the build will be optimized for Docker deployment.
@@ -89,8 +91,9 @@ export async function viteAlephaBuild(
   let rootConfig: UserConfig = {};
 
   return {
-    name: "alepha-build",
+    name: "alepha:build",
     apply: "build",
+    [OPTIONS as any]: options,
     config(config, ctx) {
       const buildMode = process.env.ALEPHA_BUILD_MODE as
         | AlephaBuildMode
@@ -254,8 +257,11 @@ export async function viteAlephaBuild(
       }
 
       if (options.cloudflare) {
+        const config =
+          typeof options.cloudflare === "boolean" ? {} : options.cloudflare;
         await generateCloudflare({
           distDir,
+          config,
         });
       }
 

package/src/vite/plugins/viteAlephaDev.ts

@@ -132,12 +132,16 @@ export async function viteAlephaDev(
       });
 
       server.config.logger.info = (msg: string) => {
-        runner.app?.log?.info(msg.trim());
+        console.log(msg);
       };
 
       server.config.logger.clearScreen = () => {};
 
-      await runner.start(server);
+      // Return a function - it runs AFTER internal middlewares are set up
+      // and after buildStart has been called
+      return async () => {
+        await runner.start(server);
+      };
     },
     async closeBundle() {
       // Cleanup handled by runner

package/src/vite/tasks/buildServer.ts

@@ -144,7 +144,7 @@ export async function buildServer(
 
   await writeFile(
     `${opts.distDir}/index.js`,
-    `${warning}\nimport './server/${entryFile}';${template}`.trim(),
+    `${warning}\nimport './server/${entryFile}';\n\n${template}`.trim(),
   );
 
   return { entryFile };

package/src/vite/tasks/generateCloudflare.ts

@@ -1,4 +1,4 @@
-import { writeFile } from "node:fs/promises";
+import { access, writeFile } from "node:fs/promises";
 import { basename, join } from "node:path";
 
 export interface GenerateCloudflareOptions {
@@ -8,6 +8,15 @@ export interface GenerateCloudflareOptions {
    * @default "dist"
    */
   distDir?: string;
+
+  /**
+   * Additional Wrangler configuration options to merge into wrangler.jsonc.
+   */
+  config?: WranglerConfig;
+}
+
+export interface WranglerConfig {
+  [key: string]: any;
 }
 
 const WARNING_COMMENT =
@@ -27,30 +36,47 @@ export async function generateCloudflare(
   const distDir = opts.distDir ?? "dist";
   const root = process.cwd();
   const name = basename(root);
+  const hasAssets = await access(join(root, distDir, "public"))
+    .then(() => true)
+    .catch(() => false);
 
-  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 = {
+  const wrangler: WranglerConfig = {
     name,
     main: "./main.cloudflare.js",
     compatibility_flags: ["nodejs_compat"],
     compatibility_date: "2025-11-17",
+    ...opts.config,
   };
 
+  if (hasAssets) {
+    wrangler.assets ??= {
+      directory: "./public",
+      binding: "ASSETS",
+    };
+  }
+
+  const url = process.env.DATABASE_URL;
+  if (url?.startsWith("cloudflare-d1:")) {
+    const [name, id] = url
+      .replace("cloudflare-d1://", "")
+      .replace("cloudflare-d1:", "")
+      .split(":");
+    wrangler.d1_databases = wrangler.d1_databases || [];
+    wrangler.d1_databases.push({
+      binding: name,
+      database_name: name,
+      database_id: id,
+    });
+    wrangler.vars ??= {};
+    wrangler.vars.DATABASE_URL = `cloudflare-d1://${name}:${id}`;
+  }
+
   await writeFile(
     join(root, distDir, "wrangler.jsonc"),
     JSON.stringify(wrangler, null, 2),
   );
+
+  await writeWorkerEntryPoint(root, distDir);
 }
 
 /**
@@ -64,9 +90,11 @@ async function writeWorkerEntryPoint(
 import "./index.js";
 
 export default {
-  fetch: async (request) => {
+  fetch: async (request, env) => {
     const ctx = { req: request, res: undefined };
 
+    __alepha.set("cloudflare.env", env);
+
     await __alepha.start();
     await __alepha.events.emit("web:request", ctx);
 

package/src/vite/tasks/runAlepha.ts

@@ -156,6 +156,7 @@ export class AlephaRunner {
 
       this.state.app.store.set("alepha.node.server" as any, server.httpServer);
 
+      console.log("");
       await this.state.app.start();
       this.state.started = true;