alepha 0.13.7 → 0.14.0

package/src/cli/commands/DrizzleCommands.ts

@@ -13,6 +13,12 @@ const drizzleCommandFlags = t.object({
         "Database provider name to target (e.g., 'postgres', 'sqlite')",
     }),
   ),
+  mode: t.optional(
+    t.text({
+      description:
+        "Environment variable file(s) to load (e.g., 'production' to load .env.production) https://vite.dev/guide/env-and-mode",
+    }),
+  ),
 });
 
 export class DrizzleCommands {
@@ -149,12 +155,14 @@ export class DrizzleCommands {
       const commandFlags = flags.custom
         ? `--custom=${flags.custom}`
         : undefined;
-      await this.utils.runDrizzleKitCommand({
+
+      await this.runDrizzleKitCommand({
         root,
         args,
         command: "generate",
         commandFlags,
         provider: flags.provider,
+        env: flags.mode,
         logMessage: (providerName, dialect) =>
           `Generate '${providerName}' migrations (${dialect}) ...`,
       });
@@ -181,11 +189,12 @@ export class DrizzleCommands {
     ),
     flags: drizzleCommandFlags,
     handler: async ({ root, args, flags }) => {
-      await this.utils.runDrizzleKitCommand({
+      await this.runDrizzleKitCommand({
         root,
         args,
         command: "push",
         provider: flags.provider,
+        env: flags.mode,
         logMessage: (providerName, dialect) =>
           `Push '${providerName}' schema (${dialect}) ...`,
       });
@@ -212,11 +221,12 @@ export class DrizzleCommands {
     ),
     flags: drizzleCommandFlags,
     handler: async ({ root, args, flags }) => {
-      await this.utils.runDrizzleKitCommand({
+      await this.runDrizzleKitCommand({
         root,
         args,
         command: "migrate",
         provider: flags.provider,
+        env: flags.mode,
         logMessage: (providerName, dialect) =>
           `Migrate '${providerName}' database (${dialect}) ...`,
       });
@@ -243,17 +253,207 @@ export class DrizzleCommands {
     ),
     flags: drizzleCommandFlags,
     handler: async ({ root, args, flags }) => {
-      await this.utils.runDrizzleKitCommand({
+      await this.runDrizzleKitCommand({
         root,
         args,
         command: "studio",
         provider: flags.provider,
+        env: flags.mode,
         logMessage: (providerName, dialect) =>
           `Launch Studio for '${providerName}' (${dialect}) ...`,
       });
     },
   });
 
+  /**
+   * Run a drizzle-kit command for all database providers in an Alepha instance.
+   *
+   * Iterates through all repository providers, prepares Drizzle config for each,
+   * and executes the specified drizzle-kit command.
+   *
+   * @param options - Configuration including command to run, flags, and logging
+   */
+  public async runDrizzleKitCommand(options: {
+    root: string;
+    args?: string;
+    command: string;
+    commandFlags?: string;
+    provider?: string;
+    logMessage: (providerName: string, dialect: string) => string;
+    env?: string;
+  }): Promise<void> {
+    const rootDir = options.root;
+
+    const envFiles = [".env"];
+    if (options.env) {
+      envFiles.push(`.env.${options.env}`);
+    }
+
+    await this.utils.loadEnvFile(rootDir, envFiles);
+
+    this.log.debug(`Using project root: ${rootDir}`);
+
+    const { alepha, entry } = await this.utils.loadAlephaFromServerEntryFile(
+      rootDir,
+      options.args,
+    );
+
+    const drizzleKitProvider =
+      alepha.inject<DrizzleKitProvider>("DrizzleKitProvider");
+    const repositoryProvider =
+      alepha.inject<RepositoryProvider>("RepositoryProvider");
+    const accepted = new Set<string>([]);
+
+    for (const primitive of repositoryProvider.getRepositories()) {
+      const provider = primitive.provider;
+      const providerName = provider.name;
+      const dialect = provider.dialect;
+
+      if (accepted.has(providerName)) {
+        continue;
+      }
+      accepted.add(providerName);
+
+      // Skip if provider filter is set and doesn't match
+      if (options.provider && options.provider !== providerName) {
+        this.log.debug(
+          `Skipping provider '${providerName}' (filter: ${options.provider})`,
+        );
+        continue;
+      }
+
+      this.log.info("");
+      this.log.info(options.logMessage(providerName, dialect));
+
+      const drizzleConfigJsPath = await this.prepareDrizzleConfig({
+        kit: drizzleKitProvider,
+        provider,
+        providerName,
+        providerUrl: provider.url,
+        dialect,
+        entry,
+        rootDir,
+      });
+
+      const flags = options.commandFlags ? ` ${options.commandFlags}` : "";
+      await this.utils.exec(
+        `drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`,
+        {
+          env: {
+            NODE_OPTIONS: "--import tsx",
+          },
+        },
+      );
+    }
+  }
+
+  /**
+   * Prepare Drizzle configuration files for a database provider.
+   *
+   * Creates temporary entities.js and drizzle.config.js files needed
+   * for Drizzle Kit commands to run properly.
+   *
+   * @param options - Configuration options including kit, provider info, and paths
+   * @returns Path to the generated drizzle.config.js file
+   */
+  public async prepareDrizzleConfig(options: {
+    kit: any;
+    provider: any;
+    providerName: string;
+    providerUrl: string;
+    dialect: string;
+    entry: string;
+    rootDir: string;
+  }): Promise<string> {
+    const models = Object.keys(options.kit.getModels(options.provider));
+    const entitiesJs = this.utils.generateEntitiesJs(
+      options.entry,
+      options.providerName,
+      models,
+    );
+
+    const entitiesJsPath = await this.utils.writeConfigFile(
+      "entities.js",
+      entitiesJs,
+      options.rootDir,
+    );
+
+    const config: Record<string, any> = {
+      schema: entitiesJsPath,
+      out: `./migrations/${options.providerName}`,
+      dialect: options.dialect,
+      dbCredentials: {
+        url: options.providerUrl,
+      },
+    };
+
+    if (options.providerName === "d1") {
+      config.driver = "d1-http";
+    }
+
+    if (options.providerName === "pglite") {
+      config.driver = "pglite";
+    }
+
+    if (options.dialect === "sqlite") {
+      if (options.providerName === "d1") {
+        const token = process.env.CLOUDFLARE_API_TOKEN;
+        if (!token) {
+          throw new AlephaError(
+            "CLOUDFLARE_API_TOKEN environment variable is not set. https://orm.drizzle.team/docs/guides/d1-http-with-drizzle-kit",
+          );
+        }
+
+        const accountId = process.env.CLOUDFLARE_ACCOUNT_ID;
+        if (!accountId) {
+          throw new AlephaError(
+            "CLOUDFLARE_ACCOUNT_ID environment variable is not set. https://orm.drizzle.team/docs/guides/d1-http-with-drizzle-kit",
+          );
+        }
+
+        const url = options.providerUrl;
+        if (!url.startsWith("cloudflare-d1://")) {
+          throw new AlephaError(
+            "D1 provider URL must start with 'cloudflare-d1://'.",
+          );
+        }
+
+        const [, databaseId] = url
+          .replace("cloudflare-d1://", "")
+          .replace("cloudflare-d1:", "")
+          .split(":");
+
+        if (!databaseId) {
+          throw new AlephaError(
+            "Database ID is missing in the D1 provider URL. Cloudflare D1 URL format: cloudflare-d1://<database_name>:<database_id>",
+          );
+        }
+
+        config.dbCredentials = {
+          accountId,
+          databaseId,
+          token,
+        };
+      } else {
+        let url = options.providerUrl;
+        url = url.replace("sqlite://", "").replace("file://", "");
+        url = join(options.rootDir, url);
+
+        config.dbCredentials = {
+          url,
+        };
+      }
+    }
+
+    const drizzleConfigJs = `export default ${JSON.stringify(config, null, 2)}`;
+
+    return await this.utils.writeConfigFile(
+      "drizzle.config.js",
+      drizzleConfigJs,
+      options.rootDir,
+    );
+  }
+
   // /**
   //  * Drop database schema (development only)
   //  *

package/src/cli/commands/VerifyCommands.ts

@@ -37,7 +37,10 @@ export class VerifyCommands {
         await run("alepha db:check-migrations");
       }
 
-      await run("alepha build");
+      const isExpo = await this.utils.hasExpo(root);
+      if (!isExpo) {
+        await run("alepha build");
+      }
       await run("alepha clean");
     },
   });

package/src/cli/commands/ViteCommands.ts

@@ -1,4 +1,5 @@
 import { access, readFile, unlink, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 import { join } from "node:path";
 import { $env, $inject, OPTIONS, t } from "alepha";
 import { $command } from "alepha/command";
@@ -13,8 +14,8 @@ import {
   generateSitemap,
   generateVercel,
   prerenderPages,
-  type ViteAlephaBuildOptions,
 } from "alepha/vite";
+import type * as Vite from "vite";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 export class ViteCommands {
@@ -29,6 +30,7 @@ export class ViteCommands {
 
   public readonly run = $command({
     name: "run",
+    hide: true,
     description: "Run a TypeScript file directly",
     flags: t.object({
       watch: t.optional(
@@ -54,11 +56,18 @@ export class ViteCommands {
     description: "Run the project in development mode",
     args: t.optional(t.text({ title: "path", description: "Filepath to run" })),
     handler: async ({ args, root }) => {
+      const expo = await this.utils.hasExpo(root);
+
       await this.utils.ensureConfig(root, {
-        viteConfigTs: true,
+        viteConfigTs: !expo,
         tsconfigJson: true,
       });
 
+      if (expo) {
+        await this.utils.exec(`expo start`);
+        return;
+      }
+
       const entry = await boot.getServerEntry(root, args);
       this.log.trace("Entry file found", { entry });
 
@@ -122,6 +131,13 @@ export class ViteCommands {
     handler: async ({ flags, args, run, root }) => {
       // Tell viteAlephaBuild plugin to skip - CLI handles all tasks
       process.env.ALEPHA_BUILD_MODE = "cli";
+      process.env.NODE_ENV = "production";
+
+      if (await this.utils.hasExpo(root)) {
+        // will coming soon
+        // 1. ensure "expo prebuild" is run
+        return;
+      }
 
       await this.utils.ensureConfig(root, {
         viteConfigTs: true,
@@ -142,11 +158,14 @@ export class ViteCommands {
         alias: "clean dist",
       });
 
-      const viteConfig = await import(join(root, "vite.config.ts"));
-      const viteAlephaBuildOptions: ViteAlephaBuildOptions =
-        viteConfig?.default?.plugins.find((it: any) => !!it[OPTIONS])?.[
-          OPTIONS
-        ] ?? {};
+      const vite: typeof Vite = createRequire(import.meta.url)("vite");
+      const config = await vite.resolveConfig({}, "build", "production");
+      const alephaPlugin: any = config.plugins.find(
+        (it) => it.name === "alepha:build",
+      );
+      const viteAlephaBuildOptions = alephaPlugin?.[OPTIONS] || {};
+
+      await this.utils.loadEnvFile(root, [".env", ".env.production"]);
 
       const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
       const hasServer = viteAlephaBuildOptions.serverEntry !== false;
@@ -159,6 +178,12 @@ export class ViteCommands {
         // No index.html
       }
 
+      // Extract client options
+      const clientOptions =
+        typeof viteAlephaBuildOptions.client === "object"
+          ? viteAlephaBuildOptions.client
+          : {};
+
       // Build client
       if (hasClient) {
         await run({
@@ -168,6 +193,7 @@ export class ViteCommands {
               silent: true,
               dist: `${distDir}/${clientDir}`,
               stats,
+              precompress: clientOptions.precompress,
             }),
         });
       }
@@ -201,23 +227,16 @@ export class ViteCommands {
       });
 
       // Copy assets
-      // TODO: only copy if assets are found? Currently will always run
-      await run({
-        name: "copy assets",
-        handler: () =>
-          copyAssets({
-            entry: `${distDir}/index.js`,
-            distDir,
-          }),
+      await copyAssets({
+        root,
+        entry: `${distDir}/index.js`,
+        distDir,
+        run,
       });
 
       if (hasClient) {
         // Generate sitemap
-        const sitemapBaseUrl =
-          flags.sitemap ??
-          (typeof viteAlephaBuildOptions.client === "object"
-            ? viteAlephaBuildOptions.client.sitemap?.hostname
-            : undefined);
+        const sitemapBaseUrl = flags.sitemap ?? clientOptions.sitemap?.hostname;
 
         if (sitemapBaseUrl) {
           await run({
@@ -235,11 +254,7 @@ export class ViteCommands {
         }
 
         // Pre-render static pages
-        const shouldPrerender =
-          flags.prerender ??
-          (typeof viteAlephaBuildOptions.client === "object"
-            ? viteAlephaBuildOptions.client.prerender
-            : false);
+        const shouldPrerender = flags.prerender ?? clientOptions.prerender;
 
         if (shouldPrerender) {
           await run({
@@ -248,6 +263,7 @@ export class ViteCommands {
               await prerenderPages({
                 dist: `${distDir}/${clientDir}`,
                 entry: `${distDir}/index.js`,
+                compress: clientOptions.precompress,
               });
             },
           });
@@ -272,11 +288,16 @@ export class ViteCommands {
       }
 
       if (flags.cloudflare || viteAlephaBuildOptions.cloudflare) {
+        const config =
+          typeof viteAlephaBuildOptions.cloudflare === "boolean"
+            ? {}
+            : viteAlephaBuildOptions.cloudflare;
         await run({
           name: "add Cloudflare config",
           handler: () =>
             generateCloudflare({
               distDir,
+              config,
             }),
         });
       }