alepha 0.13.6 → 0.13.8

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

@@ -0,0 +1,244 @@
+import {
+  $env,
+  $hook,
+  $inject,
+  Alepha,
+  type Static,
+  type TSchema,
+  t,
+} from "alepha";
+import { DateTimeProvider } from "alepha/datetime";
+import { $logger } from "alepha/logger";
+import { $consumer } from "../primitives/$consumer.ts";
+import {
+  $queue,
+  type QueueMessage,
+  type QueuePrimitive,
+} from "../primitives/$queue.ts";
+import { QueueProvider } from "./QueueProvider.ts";
+
+const envSchema = t.object({
+  /**
+   * The interval in milliseconds to wait before checking for new messages.
+   */
+  QUEUE_WORKER_INTERVAL: t.integer({
+    default: 1000,
+  }),
+  /**
+   * The maximum interval in milliseconds to wait before checking for new messages.
+   */
+  QUEUE_WORKER_MAX_INTERVAL: t.integer({
+    default: 32000,
+  }),
+  /**
+   * The number of workers to run concurrently. Defaults to 1.
+   * Useful only if you are doing a lot of I/O.
+   */
+  QUEUE_WORKER_CONCURRENCY: t.integer({
+    default: 1,
+  }),
+});
+
+declare module "alepha" {
+  interface Env extends Partial<Static<typeof envSchema>> {}
+}
+
+export class WorkerProvider {
+  protected readonly log = $logger();
+  protected readonly env = $env(envSchema);
+  protected readonly alepha = $inject(Alepha);
+  protected readonly queueProvider = $inject(QueueProvider);
+  protected readonly dateTimeProvider = $inject(DateTimeProvider);
+
+  protected workerPromises: Array<Promise<void>> = [];
+  protected workersRunning = 0;
+  protected abortController = new AbortController();
+  protected workerIntervals: Record<number, number> = {};
+  protected consumers: Array<Consumer> = [];
+
+  public get isRunning(): boolean {
+    return this.workersRunning > 0;
+  }
+
+  protected readonly start = $hook({
+    on: "start",
+    priority: "last",
+    handler: () => {
+      for (const queue of this.alepha.primitives($queue)) {
+        const handler = queue.options.handler;
+        if (handler) {
+          this.consumers.push({
+            handler,
+            queue,
+          });
+        }
+      }
+
+      for (const consumer of this.alepha.primitives($consumer)) {
+        this.consumers.push(consumer.options);
+      }
+
+      if (this.consumers.length > 0) {
+        this.startWorkers();
+        this.log.debug(
+          `Watching for ${this.consumers.length} queue${this.consumers.length > 1 ? "s" : ""} with ${this.env.QUEUE_WORKER_CONCURRENCY} worker${
+            this.env.QUEUE_WORKER_CONCURRENCY > 1 ? "s" : ""
+          }.`,
+        );
+      }
+    },
+  });
+
+  // -------------------------------------------------------------------------------------------------------------------
+
+  // Engine part - this is the part that will run the workers and process the messages
+
+  /**
+   * Start the workers.
+   * This method will create an endless loop that will check for new messages!
+   */
+  protected startWorkers(): void {
+    const workerToStart =
+      this.env.QUEUE_WORKER_CONCURRENCY - this.workersRunning;
+
+    for (let i = 0; i < workerToStart; i++) {
+      this.workersRunning += 1;
+      this.log.debug(`Starting worker n-${i}`);
+
+      const workerLoop = async () => {
+        while (this.workersRunning > 0) {
+          this.log.trace(`Worker n-${i} is checking for new messages`);
+          const next = await this.getNextMessage();
+          if (next) {
+            this.workerIntervals[i] = 0;
+            await this.processMessage(next);
+          } else {
+            await this.waitForNextMessage(i);
+          }
+        }
+        this.log.info(`Worker n-${i} has stopped`);
+        // Only decrement if we're not already at 0 (shutdown case)
+        if (this.workersRunning > 0) {
+          this.workersRunning -= 1;
+        }
+      };
+
+      this.workerPromises.push(
+        workerLoop().catch((e) => {
+          this.log.error(`Worker n-${i} has crashed`, e);
+          // Always decrement on crash, regardless of shutdown state
+          this.workersRunning -= 1;
+        }),
+      );
+    }
+  }
+
+  protected readonly stop = $hook({
+    on: "stop",
+    handler: async () => {
+      if (this.consumers.length > 0) {
+        await this.stopWorkers();
+      }
+    },
+  });
+
+  /**
+   * Wait for the next message, where `n` is the worker number.
+   *
+   * This method will wait for a certain amount of time, increasing the wait time again if no message is found.
+   */
+  protected async waitForNextMessage(n: number): Promise<void> {
+    const intervals = this.workerIntervals;
+    const milliseconds = intervals[n] || this.env.QUEUE_WORKER_INTERVAL;
+
+    this.log.trace(`Worker n-${n} is waiting for ${milliseconds}ms.`);
+
+    if (this.abortController.signal.aborted) {
+      this.log.warn(`Worker n-${n} aborted.`);
+      return;
+    }
+
+    await this.dateTimeProvider.wait(milliseconds, {
+      signal: this.abortController.signal,
+    });
+
+    if (intervals[n]) {
+      if (intervals[n] < this.env.QUEUE_WORKER_MAX_INTERVAL) {
+        intervals[n] = intervals[n] * 2;
+      }
+    } else {
+      intervals[n] = milliseconds;
+    }
+  }
+
+  /**
+   * Get the next message.
+   */
+  protected async getNextMessage(): Promise<undefined | NextMessage> {
+    for (const consumer of this.consumers) {
+      const provider = consumer.queue.provider;
+      const message = await provider.pop(consumer.queue.name);
+      if (message) {
+        return { message, consumer };
+      }
+    }
+  }
+
+  /**
+   * Process a message from a queue.
+   */
+  protected async processMessage(response: {
+    message: any;
+    consumer: Consumer;
+  }) {
+    const { message, consumer } = response;
+
+    try {
+      const json = JSON.parse(message);
+      const payload = this.alepha.codec.decode(
+        consumer.queue.options.schema,
+        json.payload,
+      );
+      await this.alepha.context.run(() => consumer.handler({ payload }));
+    } catch (e) {
+      this.log.error("Failed to process message", e);
+    }
+  }
+
+  /**
+   * Stop the workers.
+   *
+   * This method will stop the workers and wait for them to finish processing.
+   */
+  protected async stopWorkers() {
+    this.workersRunning = 0;
+
+    this.log.trace("Stopping workers...");
+    this.abortController.abort();
+
+    this.log.trace("Waiting for workers to finish...");
+    await Promise.all(this.workerPromises);
+  }
+
+  /**
+   * Force the workers to get back to work.
+   */
+  public wakeUp(): void {
+    this.log.debug("Waking up workers...");
+    this.abortController.abort();
+    this.abortController = new AbortController();
+
+    // if no workers are running, start them, (should not happen, but just in case)
+    this.startWorkers();
+  }
+}
+
+export interface Consumer<T extends TSchema = TSchema> {
+  queue: QueuePrimitive<T>;
+  handler: (message: QueueMessage<T>) => Promise<void>;
+}
+
+export interface NextMessage {
+  consumer: Consumer;
+  message: string;
+}

package/src/queue/redis/providers/RedisQueueProvider.ts

@@ -0,0 +1,31 @@
+import { $env, $inject, type Static, t } from "alepha";
+import type { QueueProvider } from "alepha/queue";
+import { RedisProvider } from "alepha/redis";
+
+const envSchema = t.object({
+  REDIS_QUEUE_PREFIX: t.text({
+    default: "queue",
+  }),
+});
+
+export class RedisQueueProvider implements QueueProvider {
+  protected readonly env: Static<typeof envSchema> = $env(envSchema);
+  protected readonly redisProvider: RedisProvider = $inject(RedisProvider);
+
+  public prefix(queue: string): string {
+    return `${this.env.REDIS_QUEUE_PREFIX}:${queue}`;
+  }
+
+  public async push(queue: string, message: string): Promise<void> {
+    await this.redisProvider.publisher.LPUSH(this.prefix(queue), message);
+  }
+
+  public async pop(queue: string): Promise<string | undefined> {
+    const value = await this.redisProvider.publisher.RPOP(this.prefix(queue));
+    if (value == null) {
+      return undefined;
+    }
+
+    return String(value);
+  }
+}

package/src/{server-auth → server/auth}/primitives/$auth.ts

@@ -261,6 +261,13 @@ export class AuthPrimitive extends Primitive<AuthPrimitiveOptions> {
     return this.options.name ?? this.config.propertyKey;
   }
 
+  public get realm(): RealmPrimitive | undefined {
+    if ("realm" in this.options) {
+      return this.options.realm;
+    }
+    return undefined;
+  }
+
   public get jwks_uri(): string {
     const jwks = this.oauth?.serverMetadata().jwks_uri;
     if (!jwks) {

package/src/{server-auth → server/auth}/providers/ServerAuthProvider.ts

@@ -41,6 +41,7 @@ export class ServerAuthProvider {
     httpOnly: true,
     schema: t.object({
       provider: t.text(),
+      realm: t.optional(t.text()),
       codeVerifier: t.optional(t.text({ size: "long" })),
       redirectUri: t.optional(t.text({ size: "long" })),
       state: t.optional(t.text()),
@@ -163,7 +164,7 @@ export class ServerAuthProvider {
   protected async cookiesToTokens(
     cookies: Cookies,
   ): Promise<Tokens | undefined> {
-    const tokens = this.tokens.get({ cookies });
+    const tokens = this.getTokens(cookies);
     if (!tokens) {
       // no cookie, no tokens
       this.log.trace("No tokens found in cookies");
@@ -247,7 +248,7 @@ export class ServerAuthProvider {
       response: userinfoResponseSchema,
     },
     handler: async ({ user, headers, cookies }) => {
-      const tokens = this.tokens.get({ cookies });
+      const tokens = this.getTokens(cookies);
       if (tokens) {
         const provider = this.provider(tokens);
         if (!("realm" in provider.options)) {
@@ -323,6 +324,9 @@ export class ServerAuthProvider {
     schema: {
       query: t.object({
         provider: t.text(),
+        realm: t.optional(
+          t.text({ description: "Realm name for multi-realm setups" }),
+        ),
       }),
       body: t.object({
         username: t.text(),
@@ -331,7 +335,11 @@ export class ServerAuthProvider {
       response: tokenResponseSchema,
     },
     handler: async ({ query, body, cookies }) => {
-      const provider = this.provider(query);
+      const provider = this.provider({
+        provider: query.provider,
+        realm: query.realm,
+      });
+
       const realm = "realm" in provider.options && provider.options.realm;
       if (!realm) {
         throw new SecurityError(
@@ -348,6 +356,8 @@ export class ServerAuthProvider {
         );
       }
 
+      console.log("->", body);
+
       let user: UserAccount | undefined;
       try {
         user = await credentials.account(body);
@@ -392,11 +402,17 @@ export class ServerAuthProvider {
     schema: {
       query: t.object({
         provider: t.text(),
+        realm: t.optional(
+          t.text({ description: "Realm name for multi-realm setups" }),
+        ),
         redirect_uri: t.optional(t.text({ size: "rich" })),
       }),
     },
     handler: async ({ query, url, reply }) => {
-      const provider = this.provider(query);
+      const provider = this.provider({
+        provider: query.provider,
+        realm: query.realm,
+      });
       const oauth = provider.oauth;
       if (!oauth) {
         throw new SecurityError(
@@ -433,6 +449,7 @@ export class ServerAuthProvider {
           nonce: parameters.nonce,
           redirectUri: query.redirect_uri ?? "/",
           provider: query.provider,
+          realm: query.realm,
         });
 
         reply.redirect(buildAuthorizationUrl(oauth, parameters).toString());
@@ -456,6 +473,7 @@ export class ServerAuthProvider {
         codeVerifier,
         redirectUri: query.redirect_uri ?? "/",
         provider: query.provider,
+        realm: query.realm,
       });
 
       reply.redirect(buildAuthorizationUrl(oauth, parameters).toString());
@@ -543,7 +561,7 @@ export class ServerAuthProvider {
     },
     handler: async ({ query, reply, cookies }) => {
       const redirect = query.post_logout_redirect_uri ?? "/";
-      const tokens = this.tokens.get({ cookies });
+      const tokens = this.getTokens(cookies);
       if (!tokens) {
         reply.redirect(redirect);
         return;
@@ -603,17 +621,42 @@ export class ServerAuthProvider {
     },
   });
 
-  protected provider(opts: string | { provider: string }): AuthPrimitive {
+  /**
+   * Find an auth provider by name and optionally by realm.
+   * When realm is specified, it filters providers by both name and realm.
+   * This enables multi-realm setups where multiple providers share the same name (e.g., "credentials").
+   */
+  protected provider(
+    opts: string | { provider: string; realm?: string },
+  ): AuthPrimitive {
     const name = typeof opts === "string" ? opts : opts.provider;
-    const identity = this.identities.find((identity) => identity.name === name);
+    const realmName = typeof opts === "string" ? undefined : opts.realm;
+
+    const identity = this.identities.find((identity) => {
+      if (identity.name !== name) {
+        return false;
+      }
+
+      // If realm filter is specified, match against provider's realm
+      if (realmName && identity.realm?.name !== realmName) {
+        return false;
+      }
+
+      return true;
+    });
 
     if (!identity) {
-      throw new SecurityError(`Auth provider '${name}' not found`);
+      const realmInfo = realmName ? ` for realm '${realmName}'` : "";
+      throw new SecurityError(`Auth provider '${name}'${realmInfo} not found`);
     }
 
     return identity;
   }
 
+  protected getTokens(cookies?: Cookies): Tokens | undefined {
+    return this.tokens.get({ cookies });
+  }
+
   protected setTokens(tokens: Tokens, cookies?: Cookies): void {
     const exp =
       tokens.refresh_token_expires_in ||

package/src/{server-cookies → server/cookies}/index.ts

@@ -2,6 +2,7 @@ import { $module } from "alepha";
 import { AlephaServer } from "alepha/server";
 import { $cookie, type Cookies } from "./primitives/$cookie.ts";
 import { ServerCookiesProvider } from "./providers/ServerCookiesProvider.ts";
+import { CookieParser } from "./services/CookieParser.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -29,5 +30,5 @@ declare module "alepha/server" {
 export const AlephaServerCookies = $module({
   name: "alepha.server.cookies",
   primitives: [$cookie],
-  services: [AlephaServer, ServerCookiesProvider],
+  services: [AlephaServer, ServerCookiesProvider, CookieParser],
 });

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

@@ -22,9 +22,12 @@ import { ServerBodyParserProvider } from "./providers/ServerBodyParserProvider.t
 import { ServerLoggerProvider } from "./providers/ServerLoggerProvider.ts";
 import { ServerNotReadyProvider } from "./providers/ServerNotReadyProvider.ts";
 import { ServerProvider } from "./providers/ServerProvider.ts";
+import { ServerRouterProvider } from "./providers/ServerRouterProvider.ts";
 import { ServerTimingProvider } from "./providers/ServerTimingProvider.ts";
 import type { FetchOptions, HttpAction } from "./services/HttpClient.ts";
 import { HttpClient } from "./services/HttpClient.ts";
+import { ServerRequestParser } from "./services/ServerRequestParser.ts";
+import { UserAgentParser } from "./services/UserAgentParser.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -106,6 +109,7 @@ export * from "./providers/ServerNotReadyProvider.ts";
 export * from "./providers/ServerProvider.ts";
 export * from "./providers/ServerRouterProvider.ts";
 export * from "./providers/ServerTimingProvider.ts";
+export * from "./services/UserAgentParser.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
@@ -132,6 +136,9 @@ export const AlephaServer = $module({
     ServerNotReadyProvider,
     ServerTimingProvider,
     HttpClient,
+    UserAgentParser,
+    ServerRequestParser,
+    ServerRouterProvider,
   ],
   register: (alepha: Alepha) => {
     if (!alepha.isServerless() && !alepha.isViteDev()) {

package/src/server/{primitives → core/primitives}/$action.ts

@@ -44,7 +44,16 @@ import {
  * - Automatic content-type handling (JSON, form-data, plain text)
  *
  * **URL Generation**
- * Actions are prefixed with `/api` by default (configurable via `SERVER_API_PREFIX`).
+ *
+ * **Important:** All `$action` paths are automatically prefixed with `/api`.
+ *
+ * ```ts
+ * $action({ path: "/users" })     // → GET /api/users
+ * $action({ path: "/users/:id" }) // → GET /api/users/:id
+ * $action({ path: "/hello" })     // → GET /api/hello
+ * ```
+ *
+ * This prefix is configurable via the `SERVER_API_PREFIX` environment variable.
  * HTTP method defaults to GET, or POST if body schema is provided.
  *
  * **Common Use Cases**

package/src/server/{providers → core/providers}/ServerBodyParserProvider.ts

@@ -1,5 +1,6 @@
 import { ReadableStream as WebStream } from "node:stream/web";
 import { createBrotliDecompress, createGunzip, createInflate } from "node:zlib";
+import type { TSchema } from "alepha";
 import { $env, $hook, $inject, Alepha, t } from "alepha";
 import { $logger } from "alepha/logger";
 import { HttpError } from "../errors/HttpError.ts";
@@ -44,7 +45,11 @@ export class ServerBodyParserProvider {
 
       if (route.schema?.body) {
         try {
-          const body = await this.parse(stream, request.headers);
+          const body = await this.parse(
+            stream,
+            request.headers,
+            route.schema.body,
+          );
           if (body) {
             request.body = body;
           }
@@ -68,18 +73,19 @@ export class ServerBodyParserProvider {
   public async parse(
     stream: ReadableStream,
     headers: Record<string, string>,
+    schema: TSchema,
   ): Promise<object | string | undefined> {
     const contentType = headers["content-type"];
     const contentEncoding = headers["content-encoding"];
 
     if (!contentType) return undefined;
 
-    if (contentType.startsWith("application/json")) {
-      return this.parseJson(stream, contentEncoding);
+    if (contentType.startsWith("text/plain") || t.schema.isString(schema)) {
+      return this.parseText(stream, contentEncoding);
     }
 
-    if (contentType.startsWith("text/plain")) {
-      return this.parseText(stream, contentEncoding);
+    if (contentType.startsWith("application/json")) {
+      return this.parseJson(stream, contentEncoding);
     }
 
     if (contentType.startsWith("application/x-www-form-urlencoded")) {

package/src/server/{providers → core/providers}/ServerRouterProvider.ts

@@ -391,13 +391,19 @@ export class ServerRouterProvider extends RouterProvider<ServerRouteMatcher> {
     }
 
     if (route.schema?.body) {
-      try {
-        request.body = this.alepha.codec.decode(
-          route.schema.body,
-          request.body,
-        );
-      } catch (error) {
-        throw new ValidationError("Invalid request body", error);
+      if (t.schema.isString(route.schema.body)) {
+        if (typeof request.body !== "string") {
+          throw new ValidationError("Request body is not a string");
+        }
+      } else {
+        try {
+          request.body = this.alepha.codec.decode(
+            route.schema.body,
+            request.body,
+          );
+        } catch (error) {
+          throw new ValidationError("Invalid request body", error);
+        }
       }
     }
   }

package/src/{server-rate-limit → server/rate-limit}/index.ts

@@ -54,7 +54,7 @@ export interface RateLimitOptions {
  *
  * @example
  * ```ts
- * import { $rateLimit, AlephaServerRateLimit } from "alepha/server-rate-limit";
+ * import { $rateLimit, AlephaServerRateLimit } from "alepha/server/rate-limit";
  *
  * class ApiService {
  *   // Path-specific rate limiting

package/src/{server-swagger → server/swagger}/providers/ServerSwaggerProvider.ts

@@ -393,6 +393,7 @@ window.onload = function() {
       join(dirname, "../../assets/swagger-ui"),
       join(dirname, "../../../assets/swagger-ui"),
       join(dirname, "../../../../assets/swagger-ui"),
+      join(dirname, "../../../../../assets/swagger-ui"),
     );
 
     if (!root) {

package/src/thread/primitives/$thread.ts

@@ -1,7 +1,7 @@
 import { cpus } from "node:os";
 import { MessageChannel, type MessagePort, Worker } from "node:worker_threads";
 import type { TSchema } from "alepha";
-import { createPrimitive, KIND, Primitive, TypeBoxValue } from "alepha";
+import { createPrimitive, KIND, Primitive, Value } from "alepha";
 
 /**
  * Creates a worker thread primitive for offloading CPU-intensive tasks to separate threads.
@@ -244,7 +244,7 @@ export class ThreadPrimitive extends Primitive<ThreadPrimitiveOptions> {
   public async execute<T = any>(data?: any, schema?: TSchema): Promise<T> {
     if (schema && data) {
       try {
-        TypeBoxValue.Decode(schema, data);
+        Value.Decode(schema, data);
       } catch (error) {
         throw new Error(
           `Invalid data: ${error instanceof Error ? error.message : error}`,

package/src/vite/index.ts

@@ -1,7 +1,5 @@
 import type { Alepha } from "alepha";
 
-// Vite re-exports
-export { defineConfig } from "vite";
 // Helpers (for advanced use)
 export * from "./helpers/boot.ts";
 export * from "./helpers/createBufferedLogger.ts";

package/src/vite/tasks/buildServer.ts

@@ -85,6 +85,7 @@ export async function buildServer(
       noExternal: true,
     },
     build: {
+      sourcemap: true, // or "hidden" if you don't want to expose source maps
       ssr: opts.entry,
       outDir: `${opts.distDir}/server`,
       minify: true,
@@ -133,7 +134,7 @@ export async function buildServer(
       `${opts.distDir}/${opts.clientDir}/index.html`,
       "utf-8",
     );
-    template = `process.env.REACT_SERVER_TEMPLATE ??= \`${index.replace(/>\s*</g, "><").trim()}\`;\n`;
+    template = `__alepha.set("alepha.react.server.template", \`${index.replace(/>\s*</g, "><").trim()}\`);\n`;
   }
 
   const warning =
@@ -141,11 +142,9 @@ export async function buildServer(
     "\n" +
     "// Changes to this file will be lost when the code is regenerated.\n";
 
-  const forceProduction = "process.env.NODE_ENV ??= 'production';\n";
-
   await writeFile(
     `${opts.distDir}/index.js`,
-    `${warning}\n${forceProduction}${template}\nawait import('./server/${entryFile}');`.trim(),
+    `${warning}\nimport './server/${entryFile}';${template}`.trim(),
   );
 
   return { entryFile };