alepha 0.11.10 → 0.11.11

package/package.json

@@ -1,6 +1,7 @@
 {
 	"name": "alepha",
-	"version": "0.11.10",
+	"description": "Easy-to-use modern TypeScript framework for building many kind of applications.",
+	"version": "0.11.11",
 	"type": "module",
 	"engines": {
 		"node": ">=22.0.0"
@@ -15,7 +16,7 @@
 	],
 	"bin": "./dist/index.js",
 	"dependencies": {
-		"@alepha/postgres": "^0.11.10",
+		"@alepha/orm": "^0.11.11",
 		"@biomejs/biome": "^2.3.5",
 		"drizzle-kit": "^0.31.7",
 		"tar": "^7.5.2",
@@ -25,9 +26,9 @@
 		"vitest": "^4.0.9"
 	},
 	"devDependencies": {
-		"@alepha/command": "^0.11.10",
-		"@alepha/core": "^0.11.10",
-		"@alepha/logger": "^0.11.10"
+		"@alepha/command": "^0.11.11",
+		"@alepha/core": "^0.11.11",
+		"@alepha/logger": "^0.11.11"
 	},
 	"scripts": {
 		"lint": "biome check --fix",
@@ -40,7 +41,12 @@
 		"url": "git+https://github.com/feunard/alepha.git"
 	},
 	"keywords": [
-		"alepha"
+		"alepha",
+		"aleph",
+		"framework",
+		"serverless",
+		"react",
+		"api"
 	],
 	"module": "./dist/index.js",
 	"exports": {

package/src/assets/tsconfigJson.ts

@@ -10,6 +10,7 @@ export const tsconfigJson = `
     "moduleDetection": "force",
     "skipLibCheck": true,
     "resolveJsonModule": true,
+    "noEmit": true,
     "allowImportingTsExtensions": true
   },
   "exclude": ["node_modules", "dist"]

package/src/commands/BiomeCommands.ts

@@ -1,14 +1,14 @@
-import { access } from "node:fs/promises";
-import { join } from "node:path";
 import { $command } from "@alepha/command";
 import { $inject, t } from "@alepha/core";
 import { $logger } from "@alepha/logger";
-import { biomeJson } from "../assets/biomeJson.ts";
 import { ProcessRunner } from "../services/ProcessRunner.ts";
+import { ProjectUtils } from "../services/ProjectUtils.ts";
 
 export class BiomeCommands {
   protected readonly log = $logger();
   protected readonly runner = $inject(ProcessRunner);
+  protected readonly utils = $inject(ProjectUtils);
+
   protected readonly biomeFlags = t.object({
     config: t.optional(
       t.text({
@@ -22,7 +22,7 @@ export class BiomeCommands {
     description: "Format the codebase using Biome",
     flags: this.biomeFlags,
     handler: async ({ flags }) => {
-      const configPath = await this.configPath(flags.config);
+      const configPath = await this.utils.getBiomeConfigPath(flags.config);
       await this.runner.exec(`biome format --fix --config-path=${configPath}`);
     },
   });
@@ -32,29 +32,10 @@ export class BiomeCommands {
     description: "Run linter across the codebase using Biome",
     flags: this.biomeFlags,
     handler: async ({ flags }) => {
-      const configPath = await this.configPath(flags.config);
+      const configPath = await this.utils.getBiomeConfigPath(flags.config);
       await this.runner.exec(
         `biome check --formatter-enabled=false --fix --config-path=${configPath}`,
       );
     },
   });
-
-  protected async configPath(maybePath?: string): Promise<string> {
-    const root = process.cwd();
-    if (maybePath) {
-      try {
-        const path = join(root, maybePath);
-        await access(path);
-        return path;
-      } catch {}
-    }
-
-    try {
-      const path = join(root, "biome.json");
-      await access(path);
-      return path;
-    } catch {
-      return await this.runner.writeConfigFile("biome.json", biomeJson);
-    }
-  }
 }

package/src/commands/CoreCommands.ts

@@ -1,18 +1,19 @@
-import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { access, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { Readable } from "node:stream";
 import { $command, CliProvider } from "@alepha/command";
-import { $inject, AlephaError, t } from "@alepha/core";
+import { $inject, t } from "@alepha/core";
 import { $logger } from "@alepha/logger";
-import { pipeline } from "stream/promises";
-import * as tar from "tar";
-import { tsconfigJson } from "../assets/tsconfigJson.ts";
+import { ProjectUtils } from "../services/ProjectUtils.ts";
 import { version } from "../version.ts";
 
 export class CoreCommands {
   protected readonly log = $logger();
   protected readonly cli = $inject(CliProvider);
+  protected readonly utils = $inject(ProjectUtils);
 
+  /**
+   * Called when no command is provided
+   */
   public readonly root = $command({
     root: true,
     flags: t.object({
@@ -33,6 +34,9 @@ export class CoreCommands {
     },
   });
 
+  /**
+   * Create a new Alepha project based on one of the sample projects (for now, only one sample project is available)
+   */
   public readonly create = $command({
     name: "create",
     description: "Create a new Alepha project",
@@ -45,9 +49,8 @@ export class CoreCommands {
       pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" })),
     }),
     summary: false,
-    handler: async ({ run, args, flags }) => {
+    handler: async ({ run, args, flags, root }) => {
       const name = args;
-      const root = process.cwd();
       const dest = join(root, name);
 
       try {
@@ -73,11 +76,11 @@ export class CoreCommands {
       await mkdir(dest, { recursive: true }).catch(() => null);
 
       await run("Downloading sample project", () =>
-        this.downloadSampleProject(dest),
+        this.utils.downloadSampleProject(dest),
       );
 
       if (flags.yarn) {
-        await this.ensureYarn(dest);
+        await this.utils.ensureYarn(dest);
         await run(`cd ${name} && yarn set version stable`, {
           alias: "Setting Yarn to stable version",
         });
@@ -109,6 +112,9 @@ export class CoreCommands {
     },
   });
 
+  /**
+   * Clean the project, removing the "dist" directory
+   */
   public readonly clean = $command({
     name: "clean",
     description: "Clean the project",
@@ -117,6 +123,10 @@ export class CoreCommands {
     },
   });
 
+  /**
+   * Ensure the project has the necessary Alepha configuration files.
+   * Add the correct dependencies to package.json and install them.
+   */
   public readonly init = $command({
     name: "init",
     description: "Add missing Alepha configuration files to the project",
@@ -125,18 +135,30 @@ export class CoreCommands {
       // force: t.boolean({
       //   description: "If true, all config files will be overwritten",
       // }),
-      yarn: t.boolean({ description: "Use Yarn package manager" }),
-      api: t.boolean({ description: "Include Alepha Server dependencies" }),
-      react: t.boolean({ description: "Include Alepha React dependencies" }),
+      // choose package manager
+      yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
+      // choose which dependencies to add
+      api: t.optional(
+        t.boolean({ description: "Include Alepha Server dependencies" }),
+      ),
+      react: t.optional(
+        t.boolean({ description: "Include Alepha React dependencies" }),
+      ),
+      orm: t.optional(
+        t.boolean({ description: "Include Alepha ORM dependencies" }),
+      ),
     }),
-    handler: async ({ run, flags }) => {
-      const root = process.cwd();
-
-      await this.ensureTsConfig(root);
-      await this.ensurePackageJson(root, flags);
+    handler: async ({ run, flags, root }) => {
+      await run("Ensuring Alepha configuration files", async () => {
+        await this.utils.ensureTsConfig(root);
+        await this.utils.ensurePackageJson(root, flags);
+      });
 
       if (flags.yarn) {
-        await this.ensureYarn(root);
+        await this.utils.ensureYarn(root);
+        await run("yarn install", {
+          alias: "Installing dependencies with Yarn",
+        });
       } else {
         await run("npm install", {
           alias: "Installing dependencies with npm",
@@ -144,123 +166,4 @@ export class CoreCommands {
       }
     },
   });
-
-  public async ensureYarn(root: string) {
-    const tsconfigPath = join(root, ".yarnrc.yml");
-    try {
-      await access(tsconfigPath);
-    } catch {
-      await writeFile(tsconfigPath, "nodeLinker: node-modules");
-    }
-  }
-
-  public generatePackageJsonContent(modes: { api?: boolean; react?: boolean }) {
-    const dependencies: Record<string, string> = {
-      "@alepha/core": `^${version}`,
-      "@alepha/logger": `^${version}`,
-      "@alepha/datetime": `^${version}`,
-    };
-
-    const devDependencies: Record<string, string> = {
-      alepha: `^${version}`,
-      "@alepha/vite": `^${version}`,
-    };
-
-    if (modes.api) {
-      dependencies["@alepha/server"] = `^${version}`;
-      dependencies["@alepha/server-swagger"] = `^${version}`;
-      dependencies["@alepha/server-multipart"] = `^${version}`;
-    }
-
-    if (modes.react) {
-      dependencies["@alepha/server"] = `^${version}`;
-      dependencies["@alepha/server-links"] = `^${version}`;
-      dependencies["@alepha/react"] = `^${version}`;
-      dependencies.react = "^19.2.0";
-      devDependencies["@types/react"] = "^19.0.0";
-    }
-
-    return {
-      dependencies,
-      devDependencies,
-      scripts: {
-        dev: "alepha dev",
-        build: "alepha build",
-      },
-    };
-  }
-
-  public async ensurePackageJson(
-    root: string,
-    modes: { api?: boolean; react?: boolean },
-  ) {
-    const packageJsonPath = join(root, "package.json");
-    try {
-      await access(packageJsonPath);
-    } catch (error) {
-      this.log.info("No package.json found. Creating one...");
-      await writeFile(
-        packageJsonPath,
-        JSON.stringify(this.generatePackageJsonContent(modes), null, 2),
-      );
-      return;
-    }
-
-    const content = await readFile(packageJsonPath, "utf8");
-    const packageJson = JSON.parse(content);
-    if (!packageJson.type || packageJson.type !== "module") {
-      packageJson.type = "module";
-    }
-    const newPackageJson = this.generatePackageJsonContent(modes);
-
-    packageJson.type = "module";
-    packageJson.dependencies ??= {};
-    packageJson.devDependencies ??= {};
-    packageJson.scripts ??= {};
-
-    Object.assign(packageJson.dependencies, newPackageJson.dependencies);
-    Object.assign(packageJson.devDependencies, newPackageJson.devDependencies);
-    Object.assign(packageJson.scripts, newPackageJson.scripts);
-
-    await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));
-  }
-
-  public async ensureTsConfig(root = process.cwd()) {
-    const tsconfigPath = join(root, "tsconfig.json");
-    try {
-      await access(tsconfigPath);
-    } catch {
-      this.log.info("Missing tsconfig.json detected. Creating one...");
-      await writeFile(tsconfigPath, tsconfigJson);
-    }
-  }
-
-  public async downloadSampleProject(targetDir: string) {
-    const url = "https://api.github.com/repos/feunard/alepha/tarball/main";
-    const response = await fetch(url, {
-      headers: {
-        "User-Agent": "Alepha-CLI", // GitHub API requires User-Agent
-      },
-    });
-
-    if (!response.ok) {
-      throw new AlephaError(`Failed to download: ${response.statusText}`);
-    }
-
-    const tarStream = Readable.fromWeb(response.body as any);
-    await pipeline(
-      tarStream,
-      tar.extract({
-        cwd: targetDir, // Extract to target directory
-        strip: 3, // Remove feunard-alepha-<hash>/apps/starter prefix
-        filter: (path) => {
-          // Only extract files from apps/starter/
-          const parts = path.split("/");
-          return (
-            parts.length >= 3 && parts[1] === "apps" && parts[2] === "starter"
-          );
-        },
-      }),
-    );
-  }
 }

package/src/commands/DrizzleCommands.ts

@@ -2,19 +2,15 @@ import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { join } from "node:path";
 import { $command } from "@alepha/command";
-import { $inject, Alepha, AlephaError, boot, t } from "@alepha/core";
+import { $inject, AlephaError, t } from "@alepha/core";
 import { $logger } from "@alepha/logger";
-import type { RepositoryProvider } from "@alepha/postgres";
-import { tsImport } from "tsx/esm/api";
 import { ProcessRunner } from "../services/ProcessRunner.ts";
+import { ProjectUtils } from "../services/ProjectUtils.ts";
 
 export class DrizzleCommands {
   log = $logger();
   runner = $inject(ProcessRunner);
-
-  flags = t.object({
-    root: t.text({ description: "Project root", default: "." }),
-  });
+  utils = $inject(ProjectUtils);
 
   /**
    * Check if database migrations are up to date
@@ -29,17 +25,16 @@ export class DrizzleCommands {
   check = $command({
     name: "db:check-migrations",
     description: "Verify database migration files are up to date",
-    flags: this.flags,
     args: t.optional(
       t.text({
         title: "path",
         description: "Path to the Alepha server entry file",
       }),
     ),
-    handler: async ({ flags, args }) => {
-      const rootDir = join(process.cwd(), flags.root);
+    handler: async ({ args, root }) => {
+      const rootDir = root;
       this.log.debug(`Using project root: ${rootDir}`);
-      const { alepha } = await this.loadAlephaFromServerEntryFile(
+      const { alepha } = await this.utils.loadAlephaFromServerEntryFile(
         rootDir,
         args,
       );
@@ -127,16 +122,15 @@ export class DrizzleCommands {
     name: "db:generate",
     description: "Generate migration files based on current database schema",
     summary: false,
-    flags: this.flags,
     args: t.optional(
       t.text({
         title: "path",
         description: "Path to the Alepha server entry file",
       }),
     ),
-    handler: async ({ flags, args }) => {
-      await this.runDrizzleKitCommand({
-        flags,
+    handler: async ({ args, root }) => {
+      await this.utils.runDrizzleKitCommand({
+        root,
         args,
         command: "generate",
         logMessage: (providerName, dialect) =>
@@ -157,16 +151,15 @@ export class DrizzleCommands {
     name: "db:push",
     description: "Push database schema changes directly to the database",
     summary: false,
-    flags: this.flags,
     args: t.optional(
       t.text({
         title: "path",
         description: "Path to the Alepha server entry file",
       }),
     ),
-    handler: async ({ flags, args }) => {
-      await this.runDrizzleKitCommand({
-        flags,
+    handler: async ({ root, args }) => {
+      await this.utils.runDrizzleKitCommand({
+        root,
         args,
         command: "push",
         logMessage: (providerName, dialect) =>
@@ -187,16 +180,15 @@ export class DrizzleCommands {
     name: "db:migrate",
     description: "Apply pending database migrations",
     summary: false,
-    flags: this.flags,
     args: t.optional(
       t.text({
         title: "path",
         description: "Path to the Alepha server entry file",
       }),
     ),
-    handler: async ({ flags, args }) => {
-      await this.runDrizzleKitCommand({
-        flags,
+    handler: async ({ root, args }) => {
+      await this.utils.runDrizzleKitCommand({
+        root,
         args,
         command: "migrate",
         logMessage: (providerName, dialect) =>
@@ -217,16 +209,15 @@ export class DrizzleCommands {
     name: "db:studio",
     description: "Launch Drizzle Studio database browser",
     summary: false,
-    flags: this.flags,
     args: t.optional(
       t.text({
         title: "path",
         description: "Path to the Alepha server entry file",
       }),
     ),
-    handler: async ({ flags, args }) => {
-      await this.runDrizzleKitCommand({
-        flags,
+    handler: async ({ root, args }) => {
+      await this.utils.runDrizzleKitCommand({
+        root,
         args,
         command: "studio",
         logMessage: (providerName, dialect) =>
@@ -234,170 +225,4 @@ export class DrizzleCommands {
       });
     },
   });
-
-  /**
-   * Run a drizzle-kit command for all database providers
-   */
-  protected async runDrizzleKitCommand(options: {
-    flags: { root: string };
-    args?: string;
-    command: string;
-    logMessage: (providerName: string, dialect: string) => string;
-  }): Promise<void> {
-    const rootDir = join(process.cwd(), options.flags.root);
-    this.log.debug(`Using project root: ${rootDir}`);
-
-    const { alepha, entry } = await this.loadAlephaFromServerEntryFile(
-      rootDir,
-      options.args,
-    );
-
-    const kit = this.getKitFromAlepha(alepha);
-    const repositoryProvider =
-      alepha.inject<RepositoryProvider>("RepositoryProvider");
-    const accepted = new Set<string>([]);
-
-    for (const descriptor of repositoryProvider.getRepositories()) {
-      const provider = descriptor.provider;
-      const providerName = provider.name;
-      const dialect = provider.dialect;
-
-      if (accepted.has(providerName)) {
-        continue;
-      }
-      accepted.add(providerName);
-
-      this.log.info("");
-      this.log.info(options.logMessage(providerName, dialect));
-
-      const drizzleConfigJsPath = await this.prepareDrizzleConfig({
-        kit,
-        provider,
-        providerName,
-        providerUrl: provider.url,
-        dialect,
-        entry,
-        rootDir,
-      });
-
-      await this.runner.exec(
-        `drizzle-kit ${options.command} --config=${drizzleConfigJsPath}`,
-      );
-    }
-  }
-
-  /**
-   * Prepare Drizzle configuration files for a provider
-   */
-  protected 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.runner.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 === "pglite") {
-      config.driver = "pglite";
-    }
-
-    const drizzleConfigJs = "export default " + JSON.stringify(config, null, 2);
-
-    return await this.runner.writeConfigFile(
-      "drizzle.config.js",
-      drizzleConfigJs,
-      options.rootDir,
-    );
-  }
-
-  /**
-   * Get DrizzleKitProvider from Alepha instance
-   */
-  protected getKitFromAlepha(alepha: Alepha): any {
-    // biome-ignore lint/complexity/useLiteralKeys: private key
-    return alepha["registry"]
-      .values()
-      .find((it: any) => it.instance.constructor.name === "DrizzleKitProvider")
-      ?.instance;
-  }
-
-  public async loadAlephaFromServerEntryFile(
-    rootDir?: string,
-    explicitEntry?: string,
-  ): Promise<{
-    alepha: Alepha;
-    entry: string;
-  }> {
-    process.env.ALEPHA_SKIP_START = "true";
-
-    const entry = await boot.getServerEntry(rootDir, explicitEntry);
-    const mod = await tsImport(entry, {
-      parentURL: import.meta.url,
-    });
-
-    this.log.debug(`Load entry: ${entry}`);
-
-    // check if alepha is correctly exported
-    if (mod.default instanceof Alepha) {
-      return {
-        alepha: mod.default,
-        entry,
-      };
-    }
-
-    // else, try with global variable
-    const g: any = global;
-    if (g.__alepha) {
-      return {
-        alepha: g.__alepha,
-        entry,
-      };
-    }
-
-    throw new AlephaError(
-      `Could not find Alepha instance in entry file: ${entry}`,
-    );
-  }
-
-  protected generateEntitiesJs(
-    entry: string,
-    provider: string,
-    models: string[] = [],
-  ) {
-    return `
-import "${entry}";
-import { DrizzleKitProvider, Repository } from "@alepha/postgres";
-
-const alepha = globalThis.__alepha;
-const kit = alepha.inject(DrizzleKitProvider);
-const provider = alepha.services(Repository).find((it) => it.provider.name === "${provider}").provider;
-const models = kit.getModels(provider);
-
-${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")}
-
-`.trim();
-  }
 }

package/src/commands/VerifyCommands.ts

@@ -3,7 +3,7 @@ import { $inject } from "@alepha/core";
 import { ProcessRunner } from "../services/ProcessRunner.ts";
 
 export class VerifyCommands {
-  runner = $inject(ProcessRunner);
+  protected readonly processRunner = $inject(ProcessRunner);
 
   /**
    * Run a series of verification commands to ensure code quality and correctness.
@@ -26,10 +26,6 @@ export class VerifyCommands {
       await run("alepha lint");
       await run("alepha test");
       await run("alepha typecheck");
-
-      // run only if migrations dir is present ?
-      //await run("alepha db:check-migrations");
-
       await run("alepha build");
       await run("alepha clean");
     },
@@ -42,7 +38,7 @@ export class VerifyCommands {
     name: "typecheck",
     description: "Check TypeScript types across the codebase",
     handler: async () => {
-      await this.runner.exec("tsc --noEmit");
+      await this.processRunner.exec("tsc --noEmit");
     },
   });
 }