alepha 0.13.8 → 0.14.1

package/src/cli/commands/DrizzleCommands.ts

@@ -3,7 +3,11 @@ import { join } from "node:path";
 import { $inject, AlephaError, t } from "alepha";
 import { $command } from "alepha/command";
 import { $logger } from "alepha/logger";
-import type { DrizzleKitProvider, RepositoryProvider } from "alepha/orm";
+import type {
+  DatabaseProvider,
+  DrizzleKitProvider,
+  RepositoryProvider,
+} from "alepha/orm";
 import { AlephaCliUtils } from "../services/AlephaCliUtils.ts";
 
 const drizzleCommandFlags = t.object({
@@ -13,6 +17,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 {
@@ -23,7 +33,7 @@ export class DrizzleCommands {
    * Check if database migrations are up to date.
    */
   check = $command({
-    name: "db:check-migrations",
+    name: "check-migrations",
     description: "Check if database migration files are up to date",
     args: t.optional(
       t.text({
@@ -128,7 +138,7 @@ export class DrizzleCommands {
    * - Invokes Drizzle Kit's CLI to generate migration files based on the current schema.
    */
   generate = $command({
-    name: "db:generate",
+    name: "generate",
     description: "Generate migration files based on current database schema",
     summary: false,
     args: t.optional(
@@ -149,12 +159,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}) ...`,
       });
@@ -170,7 +182,7 @@ export class DrizzleCommands {
    * - Invokes Drizzle Kit's push command to apply schema changes directly.
    */
   push = $command({
-    name: "db:push",
+    name: "push",
     description: "Push database schema changes directly to the database",
     summary: false,
     args: t.optional(
@@ -181,11 +193,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}) ...`,
       });
@@ -201,7 +214,7 @@ export class DrizzleCommands {
    * - Invokes Drizzle Kit's migrate command to apply pending migrations.
    */
   migrate = $command({
-    name: "db:migrate",
+    name: "migrate",
     description: "Apply pending database migrations",
     summary: false,
     args: t.optional(
@@ -212,11 +225,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}) ...`,
       });
@@ -232,7 +246,7 @@ export class DrizzleCommands {
    * - Invokes Drizzle Kit's studio command to launch the web-based database browser.
    */
   studio = $command({
-    name: "db:studio",
+    name: "studio",
     description: "Launch Drizzle Studio database browser",
     summary: false,
     args: t.optional(
@@ -243,17 +257,223 @@ 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}) ...`,
       });
     },
   });
 
+  /**
+   * Parent command for database operations.
+   */
+  db = $command({
+    name: "db",
+    description: "Database management commands",
+    children: [this.check, this.generate, this.push, this.migrate, this.studio],
+    handler: async ({ help }) => {
+      help();
+    },
+  });
+
+  /**
+   * 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.loadEnv(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: DatabaseProvider;
+    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.provider.schema) {
+      config.schemaFilter = options.provider.schema;
+    }
+
+    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/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 {
@@ -121,15 +122,11 @@ export class ViteCommands {
           description: "Generate sitemap.xml with base URL",
         }),
       ),
-      prerender: t.optional(
-        t.boolean({
-          description: "Pre-render static pages",
-        }),
-      ),
     }),
     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
@@ -156,11 +153,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.loadEnv(root, [".env", ".env.production"]);
 
       const stats = flags.stats ?? viteAlephaBuildOptions.stats ?? false;
       const hasServer = viteAlephaBuildOptions.serverEntry !== false;
@@ -173,6 +173,12 @@ export class ViteCommands {
         // No index.html
       }
 
+      // Extract client options
+      const clientOptions =
+        typeof viteAlephaBuildOptions.client === "object"
+          ? viteAlephaBuildOptions.client
+          : {};
+
       // Build client
       if (hasClient) {
         await run({
@@ -182,6 +188,7 @@ export class ViteCommands {
               silent: true,
               dist: `${distDir}/${clientDir}`,
               stats,
+              precompress: clientOptions.precompress,
             }),
         });
       }
@@ -224,11 +231,7 @@ export class ViteCommands {
 
       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({
@@ -246,11 +249,7 @@ export class ViteCommands {
         }
 
         // Pre-render static pages
-        const shouldPrerender =
-          flags.prerender ??
-          (typeof viteAlephaBuildOptions.client === "object"
-            ? viteAlephaBuildOptions.client.prerender
-            : false);
+        const shouldPrerender = clientOptions.prerender;
 
         if (shouldPrerender) {
           await run({
@@ -259,6 +258,7 @@ export class ViteCommands {
               await prerenderPages({
                 dist: `${distDir}/${clientDir}`,
                 entry: `${distDir}/index.js`,
+                compress: clientOptions.precompress,
               });
             },
           });
@@ -283,11 +283,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,
             }),
         });
       }
@@ -312,7 +317,24 @@ export class ViteCommands {
   public readonly test = $command({
     name: "test",
     description: "Run tests using Vitest",
-    handler: async ({ root }) => {
+    flags: t.object({
+      config: t.optional(
+        t.string({
+          description: "Path to Vitest config file",
+          alias: "c",
+        }),
+      ),
+    }),
+    env: t.object({
+      VITEST_ARGS: t.optional(
+        t.string({
+          default: "",
+          description:
+            "Additional arguments to pass to Vitest. E.g., --coverage",
+        }),
+      ),
+    }),
+    handler: async ({ root, flags, env }) => {
       await this.utils.ensureConfig(root, {
         tsconfigJson: true,
         viteConfigTs: true,
@@ -321,7 +343,9 @@ export class ViteCommands {
       // Ensure vitest is installed before running
       await this.utils.ensureDependency(root, "vitest");
 
-      await this.utils.exec(`vitest run ${this.env.VITEST_ARGS}`);
+      const config = flags.config ? `--config=${flags.config}` : "";
+
+      await this.utils.exec(`vitest run ${config} ${env.VITEST_ARGS}`);
     },
   });
 }

package/src/cli/defineConfig.ts

@@ -0,0 +1,15 @@
+import type { Alepha } from "alepha";
+import type { CommandPrimitive } from "alepha/command";
+
+export type AlephaCliConfig = (alepha: Alepha) => {
+  commands?: Record<string, CommandPrimitive>;
+};
+
+export const defineConfig = (config: AlephaCliConfig) => {
+  return (alepha: Alepha) => {
+    const { commands } = config(alepha);
+    return {
+      ...commands,
+    };
+  };
+};

package/src/cli/index.ts

@@ -1,9 +1,12 @@
 export * from "./apps/AlephaCli.ts";
 export * from "./apps/AlephaPackageBuilderCli.ts";
 export * from "./commands/BiomeCommands.ts";
+export * from "./commands/ChangelogCommands.ts";
 export * from "./commands/CoreCommands.ts";
+export * from "./commands/DeployCommands.ts";
 export * from "./commands/DrizzleCommands.ts";
 export * from "./commands/VerifyCommands.ts";
 export * from "./commands/ViteCommands.ts";
+export * from "./defineConfig.ts";
 export * from "./services/AlephaCliUtils.ts";
 export * from "./version.ts";