alepha 0.12.1 → 0.13.1

package/src/cli/services/ProjectUtils.ts

@@ -3,11 +3,13 @@ import { join } from "node:path";
 import { $inject, Alepha, AlephaError } from "alepha";
 import { FileSystemProvider } from "alepha/file";
 import { $logger } from "alepha/logger";
-import type { RepositoryProvider } from "alepha/orm";
+import type { DrizzleKitProvider, RepositoryProvider } from "alepha/orm";
 import { boot } from "alepha/vite";
 import { tsImport } from "tsx/esm/api";
+import { appRouterTs } from "../assets/appRouterTs.ts";
 import { biomeJson } from "../assets/biomeJson.ts";
 import { indexHtml } from "../assets/indexHtml.ts";
+import { mainBrowserTs } from "../assets/mainBrowserTs.ts";
 import { tsconfigJson } from "../assets/tsconfigJson.ts";
 import { viteConfigTs } from "../assets/viteConfigTs.ts";
 import { version } from "../version.ts";
@@ -40,18 +42,16 @@ export class ProjectUtils {
    * @param root - The root directory of the project
    */
   public async ensureYarn(root: string): Promise<void> {
-    const yarnrcPath = join(root, ".yarnrc.yml");
-    try {
-      await access(yarnrcPath);
-    } catch {
-      await writeFile(yarnrcPath, "nodeLinker: node-modules");
-    }
+    await this.ensureFileExists(
+      root,
+      ".yarnrc.yml",
+      "nodeLinker: node-modules",
+      false,
+    );
 
     // remove lock files from other package managers
-    const npmLockPath = join(root, "package-lock.json");
-    const pnpmLockPath = join(root, "pnpm-lock.yaml");
-    await this.fs.rm(npmLockPath, { force: true });
-    await this.fs.rm(pnpmLockPath, { force: true });
+    await this.fs.rm(join(root, "package-lock.json"), { force: true });
+    await this.fs.rm(join(root, "pnpm-lock.yaml"), { force: true });
   }
 
   /**
@@ -74,8 +74,13 @@ export class ProjectUtils {
 
     if (modes.react) {
       dependencies["@alepha/react"] = `^${version}`;
-      dependencies.react = "19.1.0";
-      devDependencies["@types/react"] = "19.1.0";
+      dependencies.react = "^19.2.0";
+      dependencies["react-dom"] = "^19.2.0";
+      devDependencies["@types/react"] = "^19.2.0";
+    }
+
+    if (modes.admin) {
+      dependencies["@alepha/ui"] = `^${version}`;
     }
 
     return {
@@ -85,6 +90,7 @@ export class ProjectUtils {
       scripts: {
         dev: "alepha dev",
         build: "alepha build",
+        verify: "alepha verify",
       },
     };
   }
@@ -353,22 +359,6 @@ export class ProjectUtils {
     );
   }
 
-  /**
-   * Get DrizzleKitProvider from an Alepha instance.
-   *
-   * Searches the Alepha registry for the DrizzleKitProvider instance.
-   *
-   * @param alepha - The Alepha instance to search
-   * @returns The DrizzleKitProvider instance
-   */
-  public getKitFromAlepha(alepha: Alepha): any {
-    // biome-ignore lint/complexity/useLiteralKeys: private key
-    return alepha["registry"]
-      .values()
-      .find((it: any) => it.instance.constructor.name === "DrizzleKitProvider")
-      ?.instance;
-  }
-
   /**
    * Generate JavaScript code for Drizzle entities export.
    *
@@ -476,7 +466,8 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
       options.args,
     );
 
-    const kit = this.getKitFromAlepha(alepha);
+    const drizzleKitProvider =
+      alepha.inject<DrizzleKitProvider>("DrizzleKitProvider");
     const repositoryProvider =
       alepha.inject<RepositoryProvider>("RepositoryProvider");
     const accepted = new Set<string>([]);
@@ -503,7 +494,7 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
       this.log.info(options.logMessage(providerName, dialect));
 
       const drizzleConfigJsPath = await this.prepareDrizzleConfig({
-        kit,
+        kit: drizzleKitProvider,
         provider,
         providerName,
         providerUrl: provider.url,
@@ -536,11 +527,27 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
       return;
     }
 
-    const entry = await boot.getServerEntry(root).catch(() => null);
-    await this.fs.writeFile(
-      join(root, "index.html"),
-      indexHtml(entry ? entry.replace(root, "") : undefined),
-    );
+    const serverEntry = "src/main.server.ts";
+    const browserEntry = "src/main.browser.ts";
+    const appRouter = "src/AppRouter.ts";
+
+    await this.fs.writeFile(join(root, "index.html"), indexHtml(browserEntry));
+
+    try {
+      await this.fs.mkdir(join(root, "src"), { recursive: true });
+    } catch {}
+
+    if (!(await this.fs.exists(join(root, browserEntry)))) {
+      await this.fs.writeFile(join(root, browserEntry), mainBrowserTs());
+    }
+
+    if (!(await this.fs.exists(join(root, serverEntry)))) {
+      await this.fs.writeFile(join(root, serverEntry), mainBrowserTs());
+    }
+
+    if (!(await this.fs.exists(join(root, appRouter)))) {
+      await this.fs.writeFile(join(root, appRouter), appRouterTs());
+    }
   }
 
   public async hasDir(root: string, dirName: string): Promise<boolean> {
@@ -559,6 +566,5 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
 
 export interface DependencyModes {
   react?: boolean;
-  // testing?: boolean;
-  // ui?: boolean;
+  admin?: boolean;
 }

package/src/orm/providers/DrizzleKitProvider.ts

@@ -297,7 +297,7 @@ export class DrizzleKitProvider {
    * Try to load the official Drizzle Kit API.
    * If not available, fallback to the local kit import.
    */
-  protected importDrizzleKit(): typeof DrizzleKit {
+  public importDrizzleKit(): typeof DrizzleKit {
     try {
       return createRequire(import.meta.url)("drizzle-kit/api");
     } catch (_) {

package/src/retry/descriptors/$retry.ts

@@ -76,18 +76,20 @@ export class RetryDescriptor<
   T extends (...args: any[]) => any,
 > extends Descriptor<RetryDescriptorOptions<T>> {
   protected readonly retryProvider = $inject(RetryProvider);
-  protected appAbortController: AbortController;
+  protected appAbortController?: AbortController;
 
   constructor(args: DescriptorArgs<RetryDescriptorOptions<T>>) {
     super(args);
 
-    this.appAbortController = new AbortController();
     this.alepha.events.on("stop", () => {
-      this.appAbortController.abort();
+      this.appAbortController?.abort();
     });
   }
 
   async run(...args: Parameters<T>): Promise<ReturnType<T>> {
+    // Nov 25: Cloudflare does not like 'new AbortController' outside main handler, we can't pre-create it in the constructor.
+    this.appAbortController ??= new AbortController();
+
     return this.retryProvider.retry(
       {
         ...this.options,

package/src/server/providers/NodeHttpServerProvider.ts

@@ -67,7 +67,7 @@ export class NodeHttpServerProvider extends ServerProvider {
     return createServer(
       {
         // nov 25 - keep connections alive for better performance, cuz we http/1.1 by default
-        keepAlive: true,
+        keepAlive: this.alepha.isProduction(),
       },
       func,
     );

package/src/vite/helpers/boot.ts

@@ -43,10 +43,8 @@ const getServerEntry = async (
   }
 
   const maybeEntry = [
-    "src/index.server.ts",
     "src/main.server.ts",
     "src/server-entry.ts",
-    "src/index.server.tsx",
     "src/main.server.tsx",
     "src/server-entry.tsx",
     "src/main.ts",
@@ -68,7 +66,9 @@ const getServerEntry = async (
     return clientEntry;
   }
 
-  throw new AlephaError(`Could not find a server entry file.`);
+  throw new AlephaError(
+    `Could not find a server entry file. List of supported entry file: ${maybeEntry.join(", ")}`,
+  );
 };
 
 /**