alepha 0.13.7 → 0.14.0

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";
@@ -196,6 +195,14 @@ export class AlephaCliUtils {
 
     const devDependencies: Record<string, string> = {};
 
+    const scripts: Record<string, string> = {
+      dev: "alepha dev",
+      build: "alepha build",
+      lint: "alepha lint",
+      typecheck: "alepha typecheck",
+      verify: "alepha verify",
+    };
+
     if (modes.ui) {
       dependencies["@alepha/ui"] = `^${version}`;
       modes.react = true;
@@ -212,11 +219,7 @@ export class AlephaCliUtils {
       type: "module",
       dependencies,
       devDependencies,
-      scripts: {
-        dev: "alepha dev",
-        build: "alepha build",
-        verify: "alepha verify",
-      },
+      scripts,
     };
   }
 
@@ -234,16 +237,14 @@ export class AlephaCliUtils {
   public async ensurePackageJson(
     root: string,
     modes: DependencyModes,
-  ): Promise<void> {
+  ): Promise<object> {
     const packageJsonPath = join(root, "package.json");
     try {
       await access(packageJsonPath);
     } catch (error) {
-      await writeFile(
-        packageJsonPath,
-        JSON.stringify(this.generatePackageJsonContent(modes), null, 2),
-      );
-      return;
+      const obj = this.generatePackageJsonContent(modes);
+      await writeFile(packageJsonPath, JSON.stringify(obj, null, 2));
+      return obj;
     }
 
     const content = await readFile(packageJsonPath, "utf8");
@@ -261,6 +262,8 @@ export class AlephaCliUtils {
     Object.assign(packageJson.scripts, newPackageJson.scripts);
 
     await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
+
+    return packageJson;
   }
 
   public async ensureConfig(
@@ -273,8 +276,8 @@ export class AlephaCliUtils {
       biomeJson?: boolean;
       editorconfig?: boolean;
     },
-  ) {
-    const tasks: Promise<void>[] = [];
+  ): Promise<Array<void | object>> {
+    const tasks: Promise<void | object>[] = [];
 
     if (opts.packageJson) {
       tasks.push(
@@ -300,7 +303,7 @@ export class AlephaCliUtils {
       tasks.push(this.ensureEditorConfig(root));
     }
 
-    await Promise.all(tasks);
+    return await Promise.all(tasks);
   }
 
   /**
@@ -491,159 +494,33 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
   }
 
   /**
-   * 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.
+   * Load environment variables from a .env file.
    *
-   * @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",
-          },
-        },
-      );
     }
   }
 
@@ -789,6 +666,16 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
     }
   }
 
+  /**
+   * Check if Expo is present in the project.
+   *
+   * @param root - The root directory of the project
+   * @returns True if expo is in dependencies or devDependencies
+   */
+  async hasExpo(root: string): Promise<boolean> {
+    return this.hasDependency(root, "expo");
+  }
+
   /**
    * Install a dependency if it's missing from the project.
    *
@@ -839,4 +726,5 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
 export interface DependencyModes {
   react?: boolean;
   ui?: boolean;
+  expo?: boolean;
 }

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,7 +25,11 @@ export class SchemaValidator {
     });
 
     try {
-      return this.getValidator(schema).Parse(newValue);
+      //
+      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]) {
         throw new TypeBoxError(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);
+  }
+}

package/src/mcp/helpers/jsonrpc.ts

@@ -0,0 +1,163 @@
+import { AlephaError } from "alepha";
+import type {
+  JsonRpcError,
+  JsonRpcNotification,
+  JsonRpcRequest,
+  JsonRpcResponse,
+} from "../interfaces/McpTypes.ts";
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------------------------------------------------
+
+export const JSONRPC_VERSION = "2.0" as const;
+
+export const MCP_PROTOCOL_VERSION = "2024-11-05" as const;
+
+export const JsonRpcErrorCodes = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+} as const;
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Response Builders
+// ---------------------------------------------------------------------------------------------------------------------
+
+export function createResponse(
+  id: string | number,
+  result: unknown,
+): JsonRpcResponse {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    result,
+  };
+}
+
+export function createErrorResponse(
+  id: string | number,
+  error: JsonRpcError,
+): JsonRpcResponse {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    id,
+    error,
+  };
+}
+
+export function createNotification(
+  method: string,
+  params?: Record<string, unknown>,
+): JsonRpcNotification {
+  return {
+    jsonrpc: JSONRPC_VERSION,
+    method,
+    params,
+  };
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Error Builders
+// ---------------------------------------------------------------------------------------------------------------------
+
+export function createParseError(message = "Parse error"): JsonRpcError {
+  return {
+    code: JsonRpcErrorCodes.PARSE_ERROR,
+    message,
+  };
+}
+
+export function createInvalidRequestError(
+  message = "Invalid request",
+): JsonRpcError {
+  return {
+    code: JsonRpcErrorCodes.INVALID_REQUEST,
+    message,
+  };
+}
+
+export function createMethodNotFoundError(method: string): JsonRpcError {
+  return {
+    code: JsonRpcErrorCodes.METHOD_NOT_FOUND,
+    message: `Method not found: ${method}`,
+  };
+}
+
+export function createInvalidParamsError(message: string): JsonRpcError {
+  return {
+    code: JsonRpcErrorCodes.INVALID_PARAMS,
+    message,
+  };
+}
+
+export function createInternalError(message: string): JsonRpcError {
+  return {
+    code: JsonRpcErrorCodes.INTERNAL_ERROR,
+    message,
+  };
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Message Parsing
+// ---------------------------------------------------------------------------------------------------------------------
+
+export function parseMessage(data: string): JsonRpcRequest {
+  let parsed: unknown;
+
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    throw new JsonRpcParseError("Invalid JSON");
+  }
+
+  if (!isValidJsonRpcRequest(parsed)) {
+    throw new JsonRpcParseError("Invalid JSON-RPC request");
+  }
+
+  return parsed;
+}
+
+export function isValidJsonRpcRequest(value: unknown): value is JsonRpcRequest {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+
+  const obj = value as Record<string, unknown>;
+
+  if (obj.jsonrpc !== JSONRPC_VERSION) {
+    return false;
+  }
+
+  if (typeof obj.method !== "string") {
+    return false;
+  }
+
+  if (
+    obj.id !== undefined &&
+    typeof obj.id !== "string" &&
+    typeof obj.id !== "number"
+  ) {
+    return false;
+  }
+
+  if (obj.params !== undefined && typeof obj.params !== "object") {
+    return false;
+  }
+
+  return true;
+}
+
+export function isNotification(request: JsonRpcRequest): boolean {
+  return request.id === undefined;
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Errors
+// ---------------------------------------------------------------------------------------------------------------------
+
+export class JsonRpcParseError extends AlephaError {
+  name = "JsonRpcParseError";
+}