alepha 0.13.6 → 0.13.8

package/src/{api-verifications → api/verifications}/index.ts

@@ -1,12 +1,15 @@
 import { $module } from "alepha";
 import { VerificationController } from "./controllers/VerificationController.ts";
 import { VerificationJobs } from "./jobs/VerificationJobs.ts";
+import { VerificationParameters } from "./parameters/VerificationParameters.ts";
 import { VerificationService } from "./services/VerificationService.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
 export * from "./controllers/VerificationController.ts";
 export * from "./entities/verifications.ts";
+export * from "./jobs/VerificationJobs.ts";
+export * from "./parameters/VerificationParameters.ts";
 export * from "./schemas/requestVerificationCodeResponseSchema.ts";
 export * from "./schemas/validateVerificationCodeResponseSchema.ts";
 export * from "./schemas/verificationTypeEnumSchema.ts";
@@ -25,5 +28,10 @@ export * from "./services/VerificationService.ts";
  */
 export const AlephaApiVerification = $module({
   name: "alepha.api.verifications",
-  services: [VerificationController, VerificationJobs, VerificationService],
+  services: [
+    VerificationController,
+    VerificationJobs,
+    VerificationService,
+    VerificationParameters,
+  ],
 });

package/src/bin/index.ts

@@ -5,6 +5,7 @@ import { AlephaCli, version } from "alepha/cli";
 
 const alepha = Alepha.create({
   env: {
+    APP_NAME: "CLI",
     LOG_LEVEL: "alepha.core:warn,info",
     LOG_FORMAT: "raw",
     CLI_NAME: "alepha",

package/src/cli/apps/AlephaPackageBuilderCli.ts

@@ -37,8 +37,10 @@ export class AlephaPackageBuilderCli {
       pkgData.exports = {};
 
       for (const item of modules) {
-        const path =
-          item.name === "core" ? "." : `./${item.name.replace("-", "/")}`;
+        let m = `./${item.name.replace("core", "")}`;
+        if (m.endsWith("/")) m = m.slice(0, -1);
+        const path = m;
+
         pkgData.exports[path] = {};
         // order is important here for compatibility
         pkgData.exports[path].types = `./src/${item.name}/index.ts`;
@@ -81,7 +83,8 @@ export class AlephaPackageBuilderCli {
         "alepha",
         packageName,
         ...modules.map(
-          (item) => `${packageName}/${item.name.replace("-", "/")}`,
+          (item) =>
+            `${packageName}/${item.name.replace("-", "/").replace("/core", "")}`,
         ),
       ];
 
@@ -124,13 +127,16 @@ export class AlephaPackageBuilderCli {
           });
         }
 
-        const config = join(tmpDir, `tsdown-${item.name}.config.js`);
+        const config = join(
+          tmpDir,
+          `tsdown-${item.name.replace("/", "-")}.config.js`,
+        );
         await this.fs.writeFile(
           config,
           `export default ${JSON.stringify(entries, null, 2)};`,
         );
         await run(`npx tsdown -c=${config}`);
-        await this.fs.rm(config);
+        //await this.fs.rm(config);
       };
 
       const concurrency = Math.ceil(os.cpus().length / 2);
@@ -257,57 +263,76 @@ export async function analyzeModules(
   packageName: string,
 ): Promise<Module[]> {
   const modules: Module[] = [];
-  const entries = await readdir(srcDir, { withFileTypes: true });
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const moduleName = entry.name;
-      const modulePath = join(srcDir, moduleName);
-      const dependencies = new Set<string>();
-
-      // Check for browser/node entry points
-      const hasBrowser = await fileExists(join(modulePath, "index.browser.ts"));
-      const hasNative = await fileExists(join(modulePath, "index.native.ts"));
-      const hasNode = await fileExists(join(modulePath, "index.node.ts"));
-
-      // Get all .ts/.tsx files in this module
-      const files = await getAllFiles(modulePath);
-
-      for (const file of files) {
-        const content = await readFile(file, "utf-8");
-        const deps = extractAlephaDependencies(
-          content,
-          packageName,
-          moduleName,
-        );
-        for (const dep of deps) {
-          if (dep.endsWith(".ts")) {
-            throw new Error(
-              `Invalid dependency '${dep}' in module '${moduleName}'. Do not include file extensions in Alepha module imports.`,
-            );
-          }
-          if (dep.includes("-")) {
-            throw new Error(
-              `Invalid dependency '${dep}' in module '${moduleName}'. Use '/' instead of '-' in Alepha module imports.`,
+
+  async function scanDirectory(dir: string, prefix: string): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const moduleName = prefix ? `${prefix}/${entry.name}` : entry.name;
+        const modulePath = join(dir, entry.name);
+
+        // Check if this directory has an index.ts (is a module)
+        const hasIndex = await fileExists(join(modulePath, "index.ts"));
+
+        if (hasIndex) {
+          // This is a module
+          const dependencies = new Set<string>();
+
+          // Check for browser/node entry points
+          const hasBrowser = await fileExists(
+            join(modulePath, "index.browser.ts"),
+          );
+          const hasNative = await fileExists(
+            join(modulePath, "index.native.ts"),
+          );
+          const hasNode = await fileExists(join(modulePath, "index.node.ts"));
+
+          // Get all .ts/.tsx files in this module
+          const files = await getAllFiles(modulePath);
+
+          for (const file of files) {
+            const content = await readFile(file, "utf-8");
+            const deps = extractAlephaDependencies(
+              content,
+              packageName,
+              moduleName,
             );
+            for (const dep of deps) {
+              if (dep.endsWith(".ts")) {
+                throw new Error(
+                  `Invalid dependency '${dep}' in module '${moduleName}'. Do not include file extensions in Alepha module imports.`,
+                );
+              }
+              if (dep.includes("-")) {
+                throw new Error(
+                  `Invalid dependency '${dep}' in module '${moduleName}'. Use '/' instead of '-' in Alepha module imports.`,
+                );
+              }
+              dependencies.add(dep);
+            }
           }
-          dependencies.add(dep);
-        }
-      }
 
-      const module: Module = {
-        name: moduleName,
-        dependencies: Array.from(dependencies),
-      };
+          const module: Module = {
+            name: moduleName,
+            dependencies: Array.from(dependencies),
+          };
 
-      if (hasNative) module.native = true;
-      if (hasBrowser) module.browser = true;
-      if (hasNode) module.node = true;
+          if (hasNative) module.native = true;
+          if (hasBrowser) module.browser = true;
+          if (hasNode) module.node = true;
 
-      modules.push(module);
+          modules.push(module);
+        } else {
+          // No index.ts, check subdirectories for modules
+          await scanDirectory(modulePath, moduleName);
+        }
+      }
     }
   }
 
+  await scanDirectory(srcDir, "");
+
   // Check for circular dependencies
   detectCircularDependencies(modules);
 

package/src/cli/assets/appRouterTs.ts

@@ -6,4 +6,4 @@ export class AppRouter {
     component: () => "Hello World",
   });
 }
-`.trim()
+`.trim();

package/src/cli/assets/biomeJson.ts

@@ -11,7 +11,7 @@ export const biomeJson = `
   },
   "formatter": {
     "enabled": true,
-    "indentStyle": "space"
+    "useEditorconfig": true
   },
   "linter": {
     "enabled": true,
@@ -30,4 +30,4 @@ export const biomeJson = `
     }
   }
 }
-`.trim()
+`.trim();

package/src/cli/assets/dummySpecTs.ts

@@ -0,0 +1,7 @@
+export const dummySpecTs = () => `
+import { test, expect } from "vitest";
+
+test("dummy test", () => {
+  expect(1 + 1).toBe(2);
+});
+`.trim();

package/src/cli/assets/editorconfig.ts

@@ -0,0 +1,13 @@
+export const editorconfig = `
+# https://editorconfig.org
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 2
+`.trim();

package/src/cli/assets/indexHtml.ts

@@ -12,4 +12,4 @@ export const indexHtml = (
 <script type="module" src="${browserEntry}"></script>
 </body>
 </html>
-`.trim()
+`.trim();

package/src/cli/assets/mainBrowserTs.ts

@@ -7,4 +7,4 @@ const alepha = Alepha.create();
 alepha.with(AppRouter);
 
 run(alepha);
-`.trim()
+`.trim();

package/src/cli/assets/mainTs.ts

@@ -0,0 +1,14 @@
+export const mainTs = () => `
+import { Alepha, run } from "alepha";
+import { $logger } from "alepha/logger";
+
+const alepha = Alepha.create();
+
+alepha.with(() => {
+  const log = $logger();
+
+  log.info("Hello from Alepha!");
+});
+
+run(alepha);
+`.trim();

package/src/cli/assets/viteConfigTs.ts

@@ -11,4 +11,4 @@ export default {
     globals: true,
   },
 };
-`.trim()
+`.trim();

package/src/cli/commands/BiomeCommands.ts

@@ -12,6 +12,7 @@ export class BiomeCommands {
     description: "Format the codebase using Biome",
     handler: async ({ root }) => {
       await this.utils.ensureConfig(root, { biomeJson: true });
+      await this.utils.ensureDependency(root, "@biomejs/biome");
       await this.utils.exec(`biome format --fix`);
     },
   });
@@ -21,6 +22,7 @@ export class BiomeCommands {
     description: "Run linter across the codebase using Biome",
     handler: async ({ root }) => {
       await this.utils.ensureConfig(root, { biomeJson: true });
+      await this.utils.ensureDependency(root, "@biomejs/biome");
       await this.utils.exec(`biome check --formatter-enabled=false --fix`);
     },
   });

package/src/cli/commands/CoreCommands.ts

@@ -51,13 +51,11 @@ export class CoreCommands {
     name: "init",
     description: "Add missing Alepha configuration files to the project",
     flags: t.object({
-      // TODO:
-      // force: t.boolean({
-      //   description: "If true, all config files will be overwritten",
-      // }),
       // choose package manager
       yarn: t.optional(t.boolean({ description: "Use Yarn package manager" })),
       pnpm: t.optional(t.boolean({ description: "Use pnpm package manager" })),
+      npm: t.optional(t.boolean({ description: "Use npm package manager" })),
+      bun: t.optional(t.boolean({ description: "Use Bun package manager" })),
       // choose which dependencies to add
       react: t.optional(
         t.boolean({ description: "Include Alepha React dependencies" }),
@@ -65,38 +63,63 @@ export class CoreCommands {
       ui: t.optional(
         t.boolean({ description: "Include Alepha UI dependencies" }),
       ),
+      test: t.optional(
+        t.boolean({ description: "Include Vitest and create test directory" }),
+      ),
     }),
     handler: async ({ run, flags, root }) => {
       if (flags.ui) {
         flags.react = true;
       }
 
+      const isExpo = await this.utils.hasExpo(root);
+
       await run({
-        name: "Ensuring configuration files",
+        name: "ensuring configuration files",
         handler: async () => {
           await this.utils.ensureConfig(root, {
             tsconfigJson: true,
             packageJson: flags,
             biomeJson: true,
-            viteConfigTs: true,
-            indexHtml: !!flags.react,
+            viteConfigTs: !isExpo,
+            editorconfig: true,
+            indexHtml: !!flags.react && !isExpo,
           });
+
+          // Create src/main.ts if src directory is empty or doesn't exist
+          if (!flags.react) {
+            await this.utils.ensureSrcMain(root);
+          }
         },
       });
 
       // TODO: check if all alepha dependencies are same version
 
-      const guessedPm = await this.utils.getPackageManager(root);
-
-      if (flags.yarn || guessedPm === "yarn") {
+      const pm = await this.utils.getPackageManager(root, flags);
+      if (pm === "yarn") {
         await this.utils.ensureYarn(root);
         await run("yarn set version stable");
-        await run("yarn install", {
-          alias: "Installing dependencies with Yarn",
-        });
+      } else if (pm === "pnpm") {
+        await this.utils.ensurePnpm(root);
       } else {
-        await run("npm install", {
-          alias: "Installing dependencies with npm",
+        await this.utils.ensureNpm(root);
+      }
+
+      await run(`${pm} install`, {
+        alias: `installing dependencies with ${pm}`,
+      });
+
+      if (!isExpo) {
+        await this.utils.ensureDependency(root, "vite", { run });
+      }
+
+      await this.utils.ensureDependency(root, "@biomejs/biome", { run });
+
+      // Install vitest and create test directory if --test flag is set
+      if (flags.test) {
+        await this.utils.ensureTestDir(root);
+        await run(`${pm} ${pm === "yarn" ? "add" : "install"} -D vitest`, {
+          alias: "setup testing with Vitest",
         });
       }
     },

package/src/cli/commands/VerifyCommands.ts

@@ -37,7 +37,10 @@ export class VerifyCommands {
         await run("alepha db:check-migrations");
       }
 
-      await run("alepha build");
+      const isExpo = await this.utils.hasExpo(root);
+      if (!isExpo) {
+        await run("alepha build");
+      }
       await run("alepha clean");
     },
   });
@@ -48,7 +51,8 @@ export class VerifyCommands {
   public readonly typecheck = $command({
     name: "typecheck",
     description: "Check TypeScript types across the codebase",
-    handler: async () => {
+    handler: async ({ root }) => {
+      await this.utils.ensureDependency(root, "typescript");
       await this.utils.exec("tsc --noEmit");
     },
   });

package/src/cli/commands/ViteCommands.ts

@@ -29,6 +29,7 @@ export class ViteCommands {
 
   public readonly run = $command({
     name: "run",
+    hide: true,
     description: "Run a TypeScript file directly",
     flags: t.object({
       watch: t.optional(
@@ -54,11 +55,18 @@ export class ViteCommands {
     description: "Run the project in development mode",
     args: t.optional(t.text({ title: "path", description: "Filepath to run" })),
     handler: async ({ args, root }) => {
+      const expo = await this.utils.hasExpo(root);
+
       await this.utils.ensureConfig(root, {
-        viteConfigTs: true,
+        viteConfigTs: !expo,
         tsconfigJson: true,
       });
 
+      if (expo) {
+        await this.utils.exec(`expo start`);
+        return;
+      }
+
       const entry = await boot.getServerEntry(root, args);
       this.log.trace("Entry file found", { entry });
 
@@ -75,6 +83,8 @@ export class ViteCommands {
         return;
       }
 
+      // Ensure vite is installed before running
+      await this.utils.ensureDependency(root, "vite");
       await this.utils.exec(`vite`);
     },
   });
@@ -121,6 +131,12 @@ export class ViteCommands {
       // Tell viteAlephaBuild plugin to skip - CLI handles all tasks
       process.env.ALEPHA_BUILD_MODE = "cli";
 
+      if (await this.utils.hasExpo(root)) {
+        // will coming soon
+        // 1. ensure "expo prebuild" is run
+        return;
+      }
+
       await this.utils.ensureConfig(root, {
         viteConfigTs: true,
         tsconfigJson: true,
@@ -132,6 +148,10 @@ export class ViteCommands {
       const distDir = "dist";
       const clientDir = "public";
 
+      await this.utils.ensureDependency(root, "vite", {
+        run,
+      });
+
       await run.rm("dist", {
         alias: "clean dist",
       });
@@ -195,14 +215,11 @@ export class ViteCommands {
       });
 
       // Copy assets
-      // TODO: only copy if assets are found? Currently will always run
-      await run({
-        name: "copy assets",
-        handler: () =>
-          copyAssets({
-            entry: `${distDir}/index.js`,
-            distDir,
-          }),
+      await copyAssets({
+        root,
+        entry: `${distDir}/index.js`,
+        distDir,
+        run,
       });
 
       if (hasClient) {
@@ -301,15 +318,8 @@ export class ViteCommands {
         viteConfigTs: true,
       });
 
-      // check if vitest is installed
-      try {
-        await import("vitest");
-      } catch {
-        this.log.error(
-          "Vitest is not installed. Please install it with `npm install -D vitest` or `yarn add -D vitest`.",
-        );
-        process.exit(1);
-      }
+      // Ensure vitest is installed before running
+      await this.utils.ensureDependency(root, "vitest");
 
       await this.utils.exec(`vitest run ${this.env.VITEST_ARGS}`);
     },