alepha 0.13.7 → 0.13.8

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

@@ -30,4 +30,4 @@ export const biomeJson = `
     }
   }
 }
-`.trim()
+`.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/viteConfigTs.ts

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

package/src/cli/commands/CoreCommands.ts

@@ -51,10 +51,6 @@ 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" })),
@@ -76,6 +72,8 @@ export class CoreCommands {
         flags.react = true;
       }
 
+      const isExpo = await this.utils.hasExpo(root);
+
       await run({
         name: "ensuring configuration files",
         handler: async () => {
@@ -83,9 +81,9 @@ export class CoreCommands {
             tsconfigJson: true,
             packageJson: flags,
             biomeJson: true,
-            viteConfigTs: true,
+            viteConfigTs: !isExpo,
             editorconfig: true,
-            indexHtml: !!flags.react,
+            indexHtml: !!flags.react && !isExpo,
           });
 
           // Create src/main.ts if src directory is empty or doesn't exist
@@ -111,6 +109,12 @@ export class CoreCommands {
         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);

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");
     },
   });

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 });
 
@@ -123,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,
@@ -201,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) {

package/src/cli/services/AlephaCliUtils.ts

@@ -196,6 +196,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 +220,7 @@ export class AlephaCliUtils {
       type: "module",
       dependencies,
       devDependencies,
-      scripts: {
-        dev: "alepha dev",
-        build: "alepha build",
-        verify: "alepha verify",
-      },
+      scripts,
     };
   }
 
@@ -234,16 +238,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 +263,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 +277,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 +304,7 @@ export class AlephaCliUtils {
       tasks.push(this.ensureEditorConfig(root));
     }
 
-    await Promise.all(tasks);
+    return await Promise.all(tasks);
   }
 
   /**
@@ -789,6 +793,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 +853,5 @@ ${models.map((it: string) => `export const ${it} = models["${it}"];`).join("\n")
 export interface DependencyModes {
   react?: boolean;
   ui?: boolean;
+  expo?: boolean;
 }

package/src/core/providers/SchemaValidator.ts

@@ -23,7 +23,7 @@ export class SchemaValidator {
     });
 
     try {
-      return this.getValidator(schema).Parse(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]);

package/src/queue/{index.ts → core/index.ts}

@@ -7,7 +7,6 @@ import { WorkerProvider } from "./providers/WorkerProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export * from "./interfaces/QueueJob.ts";
 export * from "./primitives/$consumer.ts";
 export * from "./primitives/$queue.ts";
 export * from "./providers/MemoryQueueProvider.ts";
@@ -17,9 +16,9 @@ export * from "./providers/WorkerProvider.ts";
 // ---------------------------------------------------------------------------------------------------------------------
 
 /**
- * Provides asynchronous message queuing and processing capabilities through declarative queue primitives.
+ * Provides asynchronous message queuing and processing capabilities through declarative queue descriptors.
  *
- * The queue module enables reliable background job processing and message passing using the `$queue` primitive
+ * The queue module enables reliable background job processing and message passing using the `$queue` descriptor
  * on class properties. It supports schema validation, automatic retries, and multiple queue backends for
  * building scalable, decoupled applications with robust error handling.
  *

package/src/queue/{primitives → core/primitives}/$queue.ts

@@ -1,4 +1,5 @@
 import {
+  $inject,
   createPrimitive,
   KIND,
   Primitive,
@@ -7,12 +8,9 @@ import {
   type TSchema,
 } from "alepha";
 import { $logger } from "alepha/logger";
-import type {
-  QueueAddJobOptions,
-  QueueJobBackoff,
-} from "../interfaces/QueueJob.ts";
 import { MemoryQueueProvider } from "../providers/MemoryQueueProvider.ts";
 import { QueueProvider } from "../providers/QueueProvider.ts";
+import { WorkerProvider } from "../providers/WorkerProvider.ts";
 
 /**
  * Creates a queue primitive for asynchronous message processing with background workers.
@@ -256,83 +254,6 @@ export interface QueuePrimitiveOptions<T extends TSchema> {
    * ```
    */
   handler?: (message: QueueMessage<T>) => Promise<void>;
-
-  // ===========================================
-  // Job Options (for crash recovery and retries)
-  // ===========================================
-
-  /**
-   * Maximum number of processing attempts before the job is marked as failed.
-   * Includes the initial attempt.
-   *
-   * Set this to enable automatic retries on failure.
-   *
-   * @default 1 (no retries)
-   * @example 3 // Allows 2 retries after initial failure
-   */
-  maxAttempts?: number;
-
-  /**
-   * Backoff configuration for retries.
-   * Controls the delay between retry attempts.
-   *
-   * @example
-   * ```ts
-   * backoff: {
-   *   type: "exponential",
-   *   delay: 1000,      // Initial delay: 1 second
-   *   maxDelay: 60000   // Maximum delay: 1 minute
-   * }
-   * ```
-   */
-  backoff?: QueueJobBackoff;
-
-  /**
-   * Maximum time in milliseconds a job can be processed before it's considered stalled.
-   * If the worker doesn't complete or extend the lock within this time, the job
-   * can be picked up by another worker.
-   *
-   * Increase this for long-running jobs.
-   *
-   * @default 30000 (30 seconds)
-   */
-  lockDuration?: number;
-
-  /**
-   * Automatically remove jobs when they complete successfully.
-   * - `true`: Remove immediately after completion
-   * - `false`: Keep in completed list (default)
-   * - `number`: Keep this many most recent completed jobs, remove older ones
-   *
-   * @default false
-   * @example
-   * ```ts
-   * // Remove immediately after completion
-   * removeOnComplete: true
-   *
-   * // Keep only the last 100 completed jobs
-   * removeOnComplete: 100
-   * ```
-   */
-  removeOnComplete?: boolean | number;
-
-  /**
-   * Automatically remove jobs when they fail permanently (after all retries exhausted).
-   * - `true`: Remove immediately after failure
-   * - `false`: Keep in failed list (default)
-   * - `number`: Keep this many most recent failed jobs, remove older ones
-   *
-   * @default false
-   * @example
-   * ```ts
-   * // Remove immediately after failure
-   * removeOnFail: true
-   *
-   * // Keep only the last 50 failed jobs for debugging
-   * removeOnFail: 50
-   * ```
-   */
-  removeOnFail?: boolean | number;
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -341,90 +262,24 @@ export class QueuePrimitive<T extends TSchema> extends Primitive<
   QueuePrimitiveOptions<T>
 > {
   protected readonly log = $logger();
+  protected readonly workerProvider = $inject(WorkerProvider);
   public readonly provider = this.$provider();
 
-  /**
-   * Push one or more payloads to the queue for background processing.
-   *
-   * Jobs will be processed with crash recovery, retries (if configured),
-   * and proper lifecycle management.
-   *
-   * @param payloads - One or more payloads to queue
-   */
-  public async push(...payloads: Array<Static<T>>): Promise<void>;
-  /**
-   * Push a payload to the queue with specific options.
-   *
-   * @param payload - The payload to queue
-   * @param options - Job options (priority, delay)
-   */
-  public async push(
-    payload: Static<T>,
-    options: QueueAddJobOptions,
-  ): Promise<void>;
-
-  public async push(
-    payloadOrFirst: Static<T>,
-    optionsOrSecond?: QueueAddJobOptions | Static<T>,
-    ...rest: Array<Static<T>>
-  ): Promise<void> {
-    // Check if second argument is options object
-    const isOptions =
-      optionsOrSecond != null &&
-      typeof optionsOrSecond === "object" &&
-      ("priority" in optionsOrSecond || "delay" in optionsOrSecond);
-
-    if (isOptions) {
-      // Single payload with options
-      const payload = this.alepha.codec.decode(
-        this.options.schema,
-        payloadOrFirst,
-      );
-      await this.provider.addJob(this.name, payload, {
-        ...this.getDefaultJobOptions(),
-        priority: (optionsOrSecond as QueueAddJobOptions).priority,
-        delay: (optionsOrSecond as QueueAddJobOptions).delay,
-      });
-      this.log.debug(`Pushed job to queue ${this.name}`, {
-        payload,
-        options: optionsOrSecond,
-      });
-    } else {
-      // Multiple payloads without per-job options
-      const payloads =
-        optionsOrSecond != null
-          ? [payloadOrFirst, optionsOrSecond as Static<T>, ...rest]
-          : [payloadOrFirst, ...rest];
+  public async push(...payloads: Array<Static<T>>) {
+    await Promise.all(
+      payloads.map((payload) =>
+        this.provider.push(
+          this.name,
+          JSON.stringify({
+            headers: {},
+            payload: this.alepha.codec.decode(this.options.schema, payload),
+          }),
+        ),
+      ),
+    );
 
-      await Promise.all(
-        payloads.map((p) => {
-          const payload = this.alepha.codec.decode(this.options.schema, p);
-          return this.provider.addJob(
-            this.name,
-            payload,
-            this.getDefaultJobOptions(),
-          );
-        }),
-      );
-
-      this.log.debug(
-        `Pushed ${payloads.length} job(s) to queue ${this.name}`,
-        payloads,
-      );
-    }
-  }
-
-  /**
-   * Get default job options from primitive configuration.
-   */
-  protected getDefaultJobOptions() {
-    return {
-      maxAttempts: this.options.maxAttempts,
-      backoff: this.options.backoff,
-      lockDuration: this.options.lockDuration,
-      removeOnComplete: this.options.removeOnComplete,
-      removeOnFail: this.options.removeOnFail,
-    };
+    this.log.debug(`Pushed to queue ${this.name}`, payloads);
+    this.workerProvider.wakeUp();
   }
 
   public get name() {

package/src/queue/core/providers/MemoryQueueProvider.ts

@@ -0,0 +1,19 @@
+import { $logger } from "alepha/logger";
+import type { QueueProvider } from "./QueueProvider.ts";
+
+export class MemoryQueueProvider implements QueueProvider {
+  protected readonly log = $logger();
+  protected queueList: Record<string, string[]> = {};
+
+  public async push(queue: string, ...messages: string[]): Promise<void> {
+    if (this.queueList[queue] == null) {
+      this.queueList[queue] = [];
+    }
+
+    this.queueList[queue].push(...messages);
+  }
+
+  public async pop(queue: string): Promise<string | undefined> {
+    return this.queueList[queue]?.shift();
+  }
+}