alepha 0.13.8 → 0.14.0

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 {
@@ -130,6 +131,7 @@ 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
@@ -156,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;
@@ -173,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({
@@ -182,6 +193,7 @@ export class ViteCommands {
               silent: true,
               dist: `${distDir}/${clientDir}`,
               stats,
+              precompress: clientOptions.precompress,
             }),
         });
       }
@@ -224,11 +236,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 +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({
@@ -259,6 +263,7 @@ export class ViteCommands {
               await prerenderPages({
                 dist: `${distDir}/${clientDir}`,
                 entry: `${distDir}/index.js`,
+                compress: clientOptions.precompress,
               });
             },
           });
@@ -283,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,
             }),
         });
       }

package/src/cli/services/AlephaCliUtils.ts

@@ -5,7 +5,6 @@ import { $inject, Alepha, AlephaError } from "alepha";
 import type { RunnerMethod } from "alepha/command";
 import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
-import type { DrizzleKitProvider, RepositoryProvider } from "alepha/orm";
 import { boot } from "alepha/vite";
 import { tsImport } from "tsx/esm/api";
 import { appRouterTs } from "../assets/appRouterTs.ts";
@@ -495,159 +494,33 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
   }
 
   /**
-   * Prepare Drizzle configuration files for a database provider.
+   * Load environment variables from a .env file.
    *
-   * 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
+   * Reads the .env file in the specified root directory and sets
+   * the environment variables in process.env.
    */
-  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.generateEntitiesJs(
-      options.entry,
-      options.providerName,
-      models,
-    );
-
-    const entitiesJsPath = await this.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.dialect === "sqlite") {
-      let url = options.providerUrl;
-      url = url.replace("sqlite://", "").replace("file://", "");
-      url = join(options.rootDir, url);
-
-      config.dbCredentials = {
-        url,
-      };
-    }
-
-    if (options.providerName === "pglite") {
-      config.driver = "pglite";
-    }
-
-    const drizzleConfigJs = `export default ${JSON.stringify(config, null, 2)}`;
-
-    return await this.writeConfigFile(
-      "drizzle.config.js",
-      drizzleConfigJs,
-      options.rootDir,
-    );
-  }
-
-  public async loadEnvFile(root: string): Promise<void> {
-    const envPath = join(root, ".env");
-    try {
-      const envContent = await readFile(envPath, "utf8");
-      const lines = envContent.split("\n");
-      for (const line of lines) {
-        const [key, ...rest] = line.split("=");
-        if (key) {
-          const value = rest.join("=");
-          process.env[key.trim()] = value.trim();
+  public async loadEnvFile(
+    root: string,
+    files: string[] = [".env"],
+  ): Promise<void> {
+    for (const it of files) {
+      for (const file of [it, `${it}.local`]) {
+        const envPath = join(root, file);
+        try {
+          const envContent = await readFile(envPath, "utf8");
+          const lines = envContent.split("\n");
+          for (const line of lines) {
+            const [key, ...rest] = line.split("=");
+            if (key) {
+              const value = rest.join("=");
+              process.env[key.trim()] = value.trim();
+            }
+          }
+          this.log.debug(`Loaded environment variables from ${envPath}`);
+        } catch {
+          this.log.debug(`No ${file} file found at ${envPath}, skipping load.`);
         }
       }
-      this.log.debug(`Loaded environment variables from ${envPath}`);
-    } catch {
-      this.log.debug(`No .env file found at ${envPath}, skipping load.`);
-    }
-  }
-
-  /**
-   * 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;
-  }): Promise<void> {
-    const rootDir = options.root;
-
-    await this.loadEnvFile(rootDir);
-
-    this.log.debug(`Using project root: ${rootDir}`);
-
-    const { alepha, entry } = await this.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.exec(
-        `drizzle-kit ${options.command} --config=${drizzleConfigJsPath}${flags}`,
-        {
-          env: {
-            NODE_OPTIONS: "--import tsx",
-          },
-        },
-      );
     }
   }
 

package/src/command/providers/CliProvider.ts

@@ -146,6 +146,7 @@ export class CliProvider {
         argv,
         command.options.args,
         command.name === "",
+        command.flags,
       );
 
       await this.alepha.context.run(async () => {
@@ -297,9 +298,12 @@ export class CliProvider {
   ): Record<string, any> {
     const result: Record<string, any> = {};
 
-    for (const arg of argv.filter((a) => a.startsWith("-"))) {
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i];
+      if (!arg.startsWith("-")) continue;
+
       const [rawKey, ...valueParts] = arg.replace(/^-{1,2}/, "").split("=");
-      const value = valueParts.join("=");
+      let value = valueParts.join("=");
 
       const def = flagDefs.find((d) => d.aliases.includes(rawKey));
       if (!def) continue;
@@ -307,6 +311,7 @@ export class CliProvider {
       if (t.schema.isBoolean(def.schema)) {
         result[def.key] = true;
       } else if (value) {
+        // Value provided via --flag=value syntax
         try {
           if (t.schema.isObject(def.schema) || t.schema.isArray(def.schema)) {
             result[def.key] = JSON.parse(value);
@@ -317,24 +322,90 @@ export class CliProvider {
           throw new CommandError(`Invalid JSON value for flag --${rawKey}`);
         }
       } else {
-        throw new CommandError(`Flag --${rawKey} requires a value.`);
+        // Check for space-separated value: --flag value
+        const nextArg = argv[i + 1];
+        if (nextArg && !nextArg.startsWith("-")) {
+          value = nextArg;
+          try {
+            if (t.schema.isObject(def.schema) || t.schema.isArray(def.schema)) {
+              result[def.key] = JSON.parse(value);
+            } else {
+              result[def.key] = value;
+            }
+          } catch {
+            throw new CommandError(`Invalid JSON value for flag --${rawKey}`);
+          }
+        } else {
+          throw new CommandError(`Flag --${rawKey} requires a value.`);
+        }
       }
     }
 
     return result;
   }
 
+  /**
+   * Get indices of argv elements that are consumed by flags (including space-separated values).
+   */
+  protected getFlagConsumedIndices(
+    argv: string[],
+    flagDefs: { key: string; aliases: string[]; schema: TSchema }[],
+  ): Set<number> {
+    const consumed = new Set<number>();
+
+    for (let i = 0; i < argv.length; i++) {
+      const arg = argv[i];
+      if (!arg.startsWith("-")) continue;
+
+      consumed.add(i);
+
+      const [rawKey, ...valueParts] = arg.replace(/^-{1,2}/, "").split("=");
+      const hasEqualValue = valueParts.length > 0;
+
+      const def = flagDefs.find((d) => d.aliases.includes(rawKey));
+      if (!def) continue;
+
+      // If not a boolean flag and no = value, the next arg is consumed as the value
+      if (!t.schema.isBoolean(def.schema) && !hasEqualValue) {
+        const nextArg = argv[i + 1];
+        if (nextArg && !nextArg.startsWith("-")) {
+          consumed.add(i + 1);
+        }
+      }
+    }
+
+    return consumed;
+  }
+
   protected parseCommandArgs(
     argv: string[],
     schema?: TSchema,
     isRootCommand = false,
+    flagSchema?: TObject,
   ): any {
     if (!schema) {
       return undefined;
     }
 
-    // Extract positional arguments (non-flag arguments)
-    const positionalArgs = argv.filter((arg) => !arg.startsWith("-"));
+    // Get indices consumed by flags (including space-separated values)
+    const flagDefs = flagSchema
+      ? Object.entries(flagSchema.properties).map(([key, value]) => ({
+          key,
+          aliases: [
+            key,
+            ...((value as any).aliases ??
+              ((value as any).alias ? [(value as any).alias] : undefined) ??
+              []),
+          ],
+          schema: value as TSchema,
+        }))
+      : [];
+    const consumedIndices = this.getFlagConsumedIndices(argv, flagDefs);
+
+    // Extract positional arguments (non-flag arguments that aren't consumed as flag values)
+    const positionalArgs = argv.filter(
+      (arg, idx) => !arg.startsWith("-") && !consumedIndices.has(idx),
+    );
     // For root commands, there's no command name to remove; otherwise slice off the command name
     const argsOnly = isRootCommand ? positionalArgs : positionalArgs.slice(1);
 

package/src/core/providers/SchemaValidator.ts

@@ -1,10 +1,12 @@
 import type { TSchema } from "typebox";
 import { Compile, type Validator } from "typebox/compile";
 import { TypeBoxError } from "../errors/TypeBoxError.ts";
-import type { Static } from "./TypeProvider.ts";
+import { $hook } from "../primitives/$hook.ts";
+import { type Static, t, Value } from "./TypeProvider.ts";
 
 export class SchemaValidator {
   protected cache = new Map<TSchema, Validator>();
+  protected useEval: boolean = true;
 
   /**
    * Validate the value against the provided schema.
@@ -23,6 +25,10 @@ export class SchemaValidator {
     });
 
     try {
+      //
+      if (!this.useEval) {
+        return Value.Parse(schema, newValue);
+      }
       return this.getValidator(schema).Parse(newValue) as Static<T>;
     } catch (error: any) {
       if (error.cause?.errors?.[0]) {
@@ -130,6 +136,22 @@ export class SchemaValidator {
     }
     return false;
   };
+
+  protected onConfigure = $hook({
+    on: "configure",
+    handler: () => {
+      this.useEval = this.canEval();
+    },
+  });
+
+  protected canEval(): boolean {
+    try {
+      Compile(t.object({ test: t.string() })).Parse({ test: "value" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
 }
 
 export interface ValidateOptions {

package/src/mcp/errors/McpError.ts

@@ -0,0 +1,72 @@
+import { JsonRpcErrorCodes } from "../helpers/jsonrpc.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export class McpError extends Error {
+  name = "McpError";
+  code: number;
+
+  constructor(
+    message: string,
+    code: number = JsonRpcErrorCodes.INTERNAL_ERROR,
+  ) {
+    super(message);
+    this.code = code;
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export class McpMethodNotFoundError extends McpError {
+  name = "McpMethodNotFoundError";
+
+  constructor(method: string) {
+    super(`Method not found: ${method}`, JsonRpcErrorCodes.METHOD_NOT_FOUND);
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export class McpToolNotFoundError extends McpError {
+  name = "McpToolNotFoundError";
+  tool: string;
+
+  constructor(tool: string) {
+    super(`Tool not found: ${tool}`, JsonRpcErrorCodes.METHOD_NOT_FOUND);
+    this.tool = tool;
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export class McpResourceNotFoundError extends McpError {
+  name = "McpResourceNotFoundError";
+  uri: string;
+
+  constructor(uri: string) {
+    super(`Resource not found: ${uri}`, JsonRpcErrorCodes.METHOD_NOT_FOUND);
+    this.uri = uri;
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export class McpPromptNotFoundError extends McpError {
+  name = "McpPromptNotFoundError";
+  prompt: string;
+
+  constructor(prompt: string) {
+    super(`Prompt not found: ${prompt}`, JsonRpcErrorCodes.METHOD_NOT_FOUND);
+    this.prompt = prompt;
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+
+export class McpInvalidParamsError extends McpError {
+  name = "McpInvalidParamsError";
+
+  constructor(message: string) {
+    super(message, JsonRpcErrorCodes.INVALID_PARAMS);
+  }
+}