alepha 0.13.0 → 0.13.1

package/dist/server-cache/index.cjs

@@ -1,252 +0,0 @@
-let alepha = require("alepha");
-let alepha_cache = require("alepha/cache");
-let node_crypto = require("node:crypto");
-let alepha_datetime = require("alepha/datetime");
-let alepha_logger = require("alepha/logger");
-let alepha_server = require("alepha/server");
-
-//#region src/server-cache/providers/ServerCacheProvider.ts
-alepha_server.ActionDescriptor.prototype.invalidate = async function() {
-	await this.alepha.inject(ServerCacheProvider).invalidate(this.route);
-};
-var ServerCacheProvider = class {
-	log = (0, alepha_logger.$logger)();
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	time = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	cache = (0, alepha_cache.$cache)({ provider: "memory" });
-	generateETag(content) {
-		return `"${(0, node_crypto.createHash)("md5").update(content).digest("hex")}"`;
-	}
-	async invalidate(route) {
-		if (!route.cache) return;
-		await this.cache.invalidate(this.createCacheKey(route));
-	}
-	onActionRequest = (0, alepha.$hook)({
-		on: "action:onRequest",
-		handler: async ({ action, request }) => {
-			const cache = action.route.cache;
-			if (this.shouldStore(cache)) {
-				const key = this.createCacheKey(action.route, request);
-				const cached = await this.cache.get(key);
-				if (cached) {
-					const body = cached.contentType === "application/json" ? JSON.parse(cached.body) : cached.body;
-					this.log.trace("Cache hit for action", {
-						key,
-						action: action.name
-					});
-					request.reply.body = body;
-				} else this.log.trace("Cache miss for action", {
-					key,
-					action: action.name
-				});
-			}
-		}
-	});
-	onActionResponse = (0, alepha.$hook)({
-		on: "action:onResponse",
-		handler: async ({ action, request, response }) => {
-			const cache = action.route.cache;
-			if (!this.shouldStore(cache) || !response) return;
-			if (request.reply.status && request.reply.status >= 400) return;
-			const contentType = typeof response === "string" ? "text/plain" : "application/json";
-			const body = contentType === "text/plain" ? response : JSON.stringify(response);
-			const generatedEtag = this.generateETag(body);
-			const lastModified = this.time.toISOString();
-			const key = this.createCacheKey(action.route, request);
-			this.log.trace("Storing response", {
-				key,
-				action: action.name
-			});
-			await this.cache.set(key, {
-				body,
-				lastModified,
-				contentType,
-				hash: generatedEtag
-			});
-			const cacheControl = this.buildCacheControlHeader(cache);
-			if (cacheControl) request.reply.setHeader("cache-control", cacheControl);
-		}
-	});
-	onRequest = (0, alepha.$hook)({
-		on: "server:onRequest",
-		handler: async ({ route, request }) => {
-			const cache = route.cache;
-			const shouldStore = this.shouldStore(cache);
-			const shouldUseEtag = this.shouldUseEtag(cache);
-			if (!shouldStore && !shouldUseEtag) return;
-			const key = this.createCacheKey(route, request);
-			const cached = await this.cache.get(key);
-			if (cached) {
-				if (request.headers["if-none-match"] === cached.hash || request.headers["if-modified-since"] === cached.lastModified) {
-					request.reply.status = 304;
-					request.reply.setHeader("etag", cached.hash);
-					request.reply.setHeader("last-modified", cached.lastModified);
-					this.log.trace("ETag match, returning 304", {
-						route: route.path,
-						etag: cached.hash
-					});
-					return;
-				}
-				if (shouldStore) {
-					this.log.trace("Cache hit for route", {
-						key,
-						route: route.path
-					});
-					request.reply.body = cached.body;
-					request.reply.status = cached.status ?? 200;
-					if (cached.contentType) request.reply.setHeader("Content-Type", cached.contentType);
-					request.reply.setHeader("etag", cached.hash);
-					request.reply.setHeader("last-modified", cached.lastModified);
-				}
-			} else if (shouldStore) this.log.trace("Cache miss for route", {
-				key,
-				route: route.path
-			});
-		}
-	});
-	onSend = (0, alepha.$hook)({
-		on: "server:onSend",
-		handler: async ({ route, request }) => {
-			const cache = route.cache;
-			const shouldStore = this.shouldStore(cache);
-			const shouldUseEtag = this.shouldUseEtag(cache);
-			if (request.reply.headers.etag) return;
-			if (!shouldStore && shouldUseEtag && request.reply.body != null && (typeof request.reply.body === "string" || Buffer.isBuffer(request.reply.body))) {
-				const generatedEtag = this.generateETag(request.reply.body);
-				if (request.headers["if-none-match"] === generatedEtag) {
-					request.reply.status = 304;
-					request.reply.body = void 0;
-					request.reply.setHeader("etag", generatedEtag);
-					this.log.trace("ETag match on send, returning 304", {
-						route: route.path,
-						etag: generatedEtag
-					});
-					return;
-				}
-			}
-		}
-	});
-	onResponse = (0, alepha.$hook)({
-		on: "server:onResponse",
-		priority: "first",
-		handler: async ({ route, request, response }) => {
-			const cache = route.cache;
-			const cacheControl = this.buildCacheControlHeader(cache);
-			if (cacheControl) response.headers["cache-control"] = cacheControl;
-			const shouldStore = this.shouldStore(cache);
-			const shouldUseEtag = this.shouldUseEtag(cache);
-			if (!shouldStore && !shouldUseEtag) return;
-			if (typeof response.body !== "string") return;
-			if (response.status && response.status >= 400) return;
-			const key = this.createCacheKey(route, request);
-			const generatedEtag = this.generateETag(response.body);
-			const lastModified = this.time.toISOString();
-			response.headers ??= {};
-			if (shouldStore) {
-				this.log.trace("Storing response", {
-					key,
-					route: route.path,
-					cache: !!cache,
-					etag: shouldUseEtag
-				});
-				await this.cache.set(key, {
-					body: response.body,
-					status: response.status,
-					contentType: response.headers?.["content-type"],
-					lastModified,
-					hash: generatedEtag
-				});
-			}
-			if (shouldUseEtag) {
-				response.headers.etag = generatedEtag;
-				response.headers["last-modified"] = lastModified;
-			}
-		}
-	});
-	buildCacheControlHeader(cache) {
-		if (!cache) return;
-		if (cache === true || typeof cache === "string" || typeof cache === "number") return;
-		const control = cache.control;
-		if (!control) return;
-		if (typeof control === "string") return control;
-		if (control === true) return "public, max-age=300";
-		const directives = [];
-		if (control.public) directives.push("public");
-		if (control.private) directives.push("private");
-		if (control.noCache) directives.push("no-cache");
-		if (control.noStore) directives.push("no-store");
-		if (control.maxAge !== void 0) {
-			const maxAgeSeconds = this.durationToSeconds(control.maxAge);
-			directives.push(`max-age=${maxAgeSeconds}`);
-		}
-		if (control.sMaxAge !== void 0) {
-			const sMaxAgeSeconds = this.durationToSeconds(control.sMaxAge);
-			directives.push(`s-maxage=${sMaxAgeSeconds}`);
-		}
-		if (control.mustRevalidate) directives.push("must-revalidate");
-		if (control.proxyRevalidate) directives.push("proxy-revalidate");
-		if (control.immutable) directives.push("immutable");
-		return directives.length > 0 ? directives.join(", ") : void 0;
-	}
-	durationToSeconds(duration) {
-		if (typeof duration === "number") return duration;
-		return this.time.duration(duration).asSeconds();
-	}
-	shouldStore(cache) {
-		if (!cache) return false;
-		if (cache === true) return true;
-		if (typeof cache === "object" && cache.store) return true;
-		return false;
-	}
-	shouldUseEtag(cache) {
-		if (cache === true) return true;
-		if (typeof cache === "object" && cache.etag) return true;
-		return false;
-	}
-	createCacheKey(route, config) {
-		const params = [];
-		for (const [key, value] of Object.entries(config?.params ?? {})) params.push(`${key}=${value}`);
-		for (const [key, value] of Object.entries(config?.query ?? {})) params.push(`${key}=${value}`);
-		return `${route.method}:${route.path.replaceAll(":", "")}:${params.join(",").replaceAll(":", "")}`;
-	}
-};
-
-//#endregion
-//#region src/server-cache/index.ts
-/**
-* Plugin for Alepha Server that provides server-side caching capabilities.
-* It uses the Alepha Cache module to cache responses from server actions ($action).
-* It also provides a ETag-based cache invalidation mechanism.
-*
-* @example
-* ```ts
-* import { Alepha } from "alepha";
-* import { $action } from "alepha/server";
-* import { AlephaServerCache } from "alepha/server/cache";
-*
-* class ApiServer {
-*   hello = $action({
-*     cache: true,
-*     handler: () => "Hello, World!",
-*   });
-* }
-*
-* const alepha = Alepha.create()
-*   .with(AlephaServerCache)
-*   .with(ApiServer);
-*
-* run(alepha);
-* ```
-*
-* @see {@link ServerCacheProvider}
-* @module alepha.server.cache
-*/
-const AlephaServerCache = (0, alepha.$module)({
-	name: "alepha.server.cache",
-	services: [alepha_cache.AlephaCache, ServerCacheProvider]
-});
-
-//#endregion
-exports.AlephaServerCache = AlephaServerCache;
-exports.ServerCacheProvider = ServerCacheProvider;
-//# sourceMappingURL=index.cjs.map

package/dist/server-cache/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["Alepha","DateTimeProvider","directives: string[]","params: string[]","AlephaCache"],"sources":["../../src/server-cache/providers/ServerCacheProvider.ts","../../src/server-cache/index.ts"],"sourcesContent":["import type { BinaryLike } from \"node:crypto\";\nimport { createHash } from \"node:crypto\";\nimport { $hook, $inject, Alepha } from \"alepha\";\nimport { $cache, type CacheDescriptorOptions } from \"alepha/cache\";\nimport { DateTimeProvider, type DurationLike } from \"alepha/datetime\";\nimport { $logger } from \"alepha/logger\";\nimport {\n  ActionDescriptor,\n  type RequestConfigSchema,\n  type ServerRequest,\n  type ServerRoute,\n} from \"alepha/server\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\ndeclare module \"alepha/server\" {\n  interface ServerRoute {\n    /**\n     * Enable caching for this route.\n     * - If true: enables both store and etag\n     * - If object: fine-grained control over store, etag, and cache-control headers\n     *\n     * @default false\n     */\n    cache?: ServerRouteCache;\n  }\n\n  interface ActionDescriptor<TConfig extends RequestConfigSchema> {\n    invalidate: () => Promise<void>;\n  }\n}\n\nActionDescriptor.prototype.invalidate = async function (\n  this: ActionDescriptor<RequestConfigSchema>,\n) {\n  await this.alepha.inject(ServerCacheProvider).invalidate(this.route);\n};\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport class ServerCacheProvider {\n  protected readonly log = $logger();\n  protected readonly alepha = $inject(Alepha);\n  protected readonly time = $inject(DateTimeProvider);\n  protected readonly cache = $cache<RouteCacheEntry>({\n    provider: \"memory\",\n  });\n\n  public generateETag(content: BinaryLike): string {\n    return `\"${createHash(\"md5\").update(content).digest(\"hex\")}\"`;\n  }\n\n  public async invalidate(route: ServerRoute) {\n    const cache = route.cache;\n    if (!cache) {\n      return;\n    }\n\n    await this.cache.invalidate(this.createCacheKey(route));\n  }\n\n  protected readonly onActionRequest = $hook({\n    on: \"action:onRequest\",\n    handler: async ({ action, request }) => {\n      const cache = action.route.cache;\n\n      const shouldStore = this.shouldStore(cache);\n\n      // Only check cache if storing is enabled\n      if (shouldStore) {\n        const key = this.createCacheKey(action.route, request);\n        const cached = await this.cache.get(key);\n\n        if (cached) {\n          const body =\n            cached.contentType === \"application/json\"\n              ? JSON.parse(cached.body)\n              : cached.body;\n\n          this.log.trace(\"Cache hit for action\", {\n            key,\n            action: action.name,\n          });\n\n          request.reply.body = body; // just re-use, full trust\n        } else {\n          this.log.trace(\"Cache miss for action\", {\n            key,\n            action: action.name,\n          });\n        }\n      }\n    },\n  });\n\n  protected readonly onActionResponse = $hook({\n    on: \"action:onResponse\",\n    handler: async ({ action, request, response }) => {\n      const cache = action.route.cache;\n\n      const shouldStore = this.shouldStore(cache);\n\n      if (!shouldStore || !response) {\n        return;\n      }\n\n      // Don't cache error responses (status >= 400)\n      if (request.reply.status && request.reply.status >= 400) {\n        return;\n      }\n\n      // TODO: serialize the response body, exactly like in the server response hook\n      // this is bad\n      const contentType =\n        typeof response === \"string\" ? \"text/plain\" : \"application/json\";\n      const body =\n        contentType === \"text/plain\" ? response : JSON.stringify(response);\n\n      const generatedEtag = this.generateETag(body);\n      const lastModified = this.time.toISOString();\n\n      // Store response for cached actions\n      const key = this.createCacheKey(action.route, request);\n\n      this.log.trace(\"Storing response\", {\n        key,\n        action: action.name,\n      });\n\n      await this.cache.set(key, {\n        body: body,\n        lastModified,\n        contentType: contentType,\n        hash: generatedEtag,\n      });\n\n      // Set Cache-Control header if configured (for HTTP responses)\n      const cacheControl = this.buildCacheControlHeader(cache);\n      if (cacheControl) {\n        request.reply.setHeader(\"cache-control\", cacheControl);\n      }\n    },\n  });\n\n  protected readonly onRequest = $hook({\n    on: \"server:onRequest\",\n    handler: async ({ route, request }) => {\n      const cache = route.cache;\n\n      const shouldStore = this.shouldStore(cache);\n      const shouldUseEtag = this.shouldUseEtag(cache);\n\n      // Check for cached response or ETag\n      if (!shouldStore && !shouldUseEtag) {\n        return;\n      }\n\n      const key = this.createCacheKey(route, request);\n      const cached = await this.cache.get(key);\n\n      if (cached) {\n        // Check if client has matching ETag - return 304 for both cached and etag-only routes\n        if (\n          request.headers[\"if-none-match\"] === cached.hash ||\n          request.headers[\"if-modified-since\"] === cached.lastModified\n        ) {\n          request.reply.status = 304;\n          request.reply.setHeader(\"etag\", cached.hash);\n          request.reply.setHeader(\"last-modified\", cached.lastModified);\n          this.log.trace(\"ETag match, returning 304\", {\n            route: route.path,\n            etag: cached.hash,\n          });\n          return;\n        }\n\n        // Only serve cached content if storing is enabled (not for etag-only routes)\n        if (shouldStore) {\n          this.log.trace(\"Cache hit for route\", {\n            key,\n            route: route.path,\n          });\n\n          // if the cache is found, we can skip the request processing\n          // and return the cached response\n          request.reply.body = cached.body;\n          request.reply.status = cached.status ?? 200;\n\n          if (cached.contentType) {\n            request.reply.setHeader(\"Content-Type\", cached.contentType);\n          }\n\n          request.reply.setHeader(\"etag\", cached.hash);\n          request.reply.setHeader(\"last-modified\", cached.lastModified);\n        }\n      } else if (shouldStore) {\n        this.log.trace(\"Cache miss for route\", {\n          key,\n          route: route.path,\n        });\n      }\n    },\n  });\n\n  protected readonly onSend = $hook({\n    on: \"server:onSend\",\n    handler: async ({ route, request }) => {\n      // before sending the response, check if the ETag matches\n      // and if so, return a 304 Not Modified response\n      // -> this is only relevant for etag-only routes, not cached routes <-\n      const cache = route.cache;\n\n      const shouldStore = this.shouldStore(cache);\n      const shouldUseEtag = this.shouldUseEtag(cache);\n\n      if (request.reply.headers.etag) {\n        // ETag already set, skip\n        return;\n      }\n\n      if (\n        !shouldStore &&\n        shouldUseEtag &&\n        request.reply.body != null &&\n        (typeof request.reply.body === \"string\" ||\n          Buffer.isBuffer(request.reply.body))\n      ) {\n        const generatedEtag = this.generateETag(request.reply.body);\n\n        if (request.headers[\"if-none-match\"] === generatedEtag) {\n          request.reply.status = 304;\n          request.reply.body = undefined;\n          request.reply.setHeader(\"etag\", generatedEtag);\n          this.log.trace(\"ETag match on send, returning 304\", {\n            route: route.path,\n            etag: generatedEtag,\n          });\n          return;\n        }\n      }\n    },\n  });\n\n  protected readonly onResponse = $hook({\n    on: \"server:onResponse\",\n    priority: \"first\",\n    handler: async ({ route, request, response }) => {\n      const cache = route.cache;\n\n      // Set Cache-Control header if configured\n      const cacheControl = this.buildCacheControlHeader(cache);\n      if (cacheControl) {\n        response.headers[\"cache-control\"] = cacheControl;\n      }\n\n      const shouldStore = this.shouldStore(cache);\n      const shouldUseEtag = this.shouldUseEtag(cache);\n\n      // Skip if neither cache nor etag is enabled\n      if (!shouldStore && !shouldUseEtag) {\n        return;\n      }\n\n      // Only process string responses (text, html, json, etc.)\n      // Buffer is not supported by alepha/cache for now\n      if (typeof response.body !== \"string\") {\n        return;\n      }\n\n      // Don't cache error responses (status >= 400)\n      if (response.status && response.status >= 400) {\n        return;\n      }\n\n      const key = this.createCacheKey(route, request);\n      const generatedEtag = this.generateETag(response.body);\n      const lastModified = this.time.toISOString();\n\n      // Initialize headers if not present\n      response.headers ??= {};\n\n      // Store response if storing is enabled\n      if (shouldStore) {\n        this.log.trace(\"Storing response\", {\n          key,\n          route: route.path,\n          cache: !!cache,\n          etag: shouldUseEtag,\n        });\n\n        await this.cache.set(key, {\n          body: response.body,\n          status: response.status,\n          contentType: response.headers?.[\"content-type\"],\n          lastModified,\n          hash: generatedEtag,\n        });\n      }\n\n      // Set ETag headers if etag is enabled\n      if (shouldUseEtag) {\n        response.headers.etag = generatedEtag;\n        response.headers[\"last-modified\"] = lastModified;\n      }\n    },\n  });\n\n  public buildCacheControlHeader(cache?: ServerRouteCache): string | undefined {\n    if (!cache) {\n      return undefined;\n    }\n\n    // If cache is true or a DurationLike, no Cache-Control header is set\n    if (\n      cache === true ||\n      typeof cache === \"string\" ||\n      typeof cache === \"number\"\n    ) {\n      return undefined;\n    }\n\n    const control = cache.control;\n    if (!control) {\n      return undefined;\n    }\n\n    // If control is a string, return it directly\n    if (typeof control === \"string\") {\n      return control;\n    }\n\n    // If control is true, return default Cache-Control\n    if (control === true) {\n      return \"public, max-age=300\";\n    }\n\n    // Build Cache-Control from object directives\n    const directives: string[] = [];\n\n    if (control.public) {\n      directives.push(\"public\");\n    }\n    if (control.private) {\n      directives.push(\"private\");\n    }\n    if (control.noCache) {\n      directives.push(\"no-cache\");\n    }\n    if (control.noStore) {\n      directives.push(\"no-store\");\n    }\n    if (control.maxAge !== undefined) {\n      const maxAgeSeconds = this.durationToSeconds(control.maxAge);\n      directives.push(`max-age=${maxAgeSeconds}`);\n    }\n    if (control.sMaxAge !== undefined) {\n      const sMaxAgeSeconds = this.durationToSeconds(control.sMaxAge);\n      directives.push(`s-maxage=${sMaxAgeSeconds}`);\n    }\n    if (control.mustRevalidate) {\n      directives.push(\"must-revalidate\");\n    }\n    if (control.proxyRevalidate) {\n      directives.push(\"proxy-revalidate\");\n    }\n    if (control.immutable) {\n      directives.push(\"immutable\");\n    }\n\n    return directives.length > 0 ? directives.join(\", \") : undefined;\n  }\n\n  protected durationToSeconds(duration: number | DurationLike): number {\n    if (typeof duration === \"number\") {\n      return duration;\n    }\n\n    return this.time.duration(duration).asSeconds();\n  }\n\n  protected shouldStore(cache?: ServerRouteCache): boolean {\n    if (!cache) return false;\n    if (cache === true) return true;\n    if (typeof cache === \"object\" && cache.store) return true;\n    return false;\n  }\n\n  protected shouldUseEtag(cache?: ServerRouteCache): boolean {\n    // cache: true enables etag\n    if (cache === true) return true;\n    // Check object form\n    if (typeof cache === \"object\" && cache.etag) return true;\n    return false;\n  }\n\n  protected createCacheKey(route: ServerRoute, config?: ServerRequest): string {\n    const params: string[] = [];\n    for (const [key, value] of Object.entries(config?.params ?? {})) {\n      params.push(`${key}=${value}`);\n    }\n    for (const [key, value] of Object.entries(config?.query ?? {})) {\n      params.push(`${key}=${value}`);\n    }\n\n    return `${route.method}:${route.path.replaceAll(\":\", \"\")}:${params.join(\",\").replaceAll(\":\", \"\")}`;\n  }\n}\n\nexport type ServerRouteCache =\n  /**\n   * If true, enables caching with:\n   * - store: true\n   * - etag: true\n   */\n  | boolean\n  /**\n   * Object configuration for fine-grained cache control.\n   *\n   * If empty, no caching will be applied.\n   */\n  | {\n      /**\n       * If true, enables storing cached responses. (in-memory, Redis, @see alepha/cache for other providers)\n       * If a DurationLike is provided, it will be used as the TTL for the cache.\n       * If CacheDescriptorOptions is provided, it will be used to configure the cache storage.\n       *\n       * @default false\n       */\n      store?: true | DurationLike | CacheDescriptorOptions;\n      /**\n       * If true, enables ETag support for the cached responses.\n       */\n      etag?: true;\n      /**\n       * - If true, sets Cache-Control to \"public, max-age=300\" (5 minutes).\n       * - If string, sets Cache-Control to the provided value directly.\n       * - If object, configures Cache-Control directives.\n       */\n      control?: /**\n       * If true, sets Cache-Control to \"public, max-age=300\" (5 minutes).\n       */\n        | true\n        /**\n         * If string, sets Cache-Control to the provided value directly.\n         */\n        | string\n        /**\n         * If object, configures Cache-Control directives.\n         */\n        | {\n            /**\n             * Indicates that the response may be cached by any cache.\n             */\n            public?: boolean;\n            /**\n             * Indicates that the response is intended for a single user and must not be stored by a shared cache.\n             */\n            private?: boolean;\n            /**\n             * Forces caches to submit the request to the origin server for validation before releasing a cached copy.\n             */\n            noCache?: boolean;\n            /**\n             * Instructs caches not to store the response.\n             */\n            noStore?: boolean;\n            /**\n             * Maximum amount of time a resource is considered fresh.\n             * Can be specified as a number (seconds) or as a DurationLike object.\n             *\n             * @example 300 // 5 minutes in seconds\n             * @example { minutes: 5 } // 5 minutes\n             * @example { hours: 1 } // 1 hour\n             */\n            maxAge?: number | DurationLike;\n            /**\n             * Overrides max-age for shared caches (e.g., CDNs).\n             * Can be specified as a number (seconds) or as a DurationLike object.\n             */\n            sMaxAge?: number | DurationLike;\n            /**\n             * Indicates that once a resource becomes stale, caches must not use it without successful validation.\n             */\n            mustRevalidate?: boolean;\n            /**\n             * Similar to must-revalidate, but only for shared caches.\n             */\n            proxyRevalidate?: boolean;\n            /**\n             * Indicates that the response can be stored but must be revalidated before each use.\n             */\n            immutable?: boolean;\n          };\n    };\n\ninterface RouteCacheEntry {\n  contentType?: string;\n  body: any;\n  status?: number;\n  lastModified: string;\n  hash: string;\n}\n","import { $module } from \"alepha\";\nimport { AlephaCache } from \"alepha/cache\";\nimport { ServerCacheProvider } from \"./providers/ServerCacheProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/ServerCacheProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Server that provides server-side caching capabilities.\n * It uses the Alepha Cache module to cache responses from server actions ($action).\n * It also provides a ETag-based cache invalidation mechanism.\n *\n * @example\n * ```ts\n * import { Alepha } from \"alepha\";\n * import { $action } from \"alepha/server\";\n * import { AlephaServerCache } from \"alepha/server/cache\";\n *\n * class ApiServer {\n *   hello = $action({\n *     cache: true,\n *     handler: () => \"Hello, World!\",\n *   });\n * }\n *\n * const alepha = Alepha.create()\n *   .with(AlephaServerCache)\n *   .with(ApiServer);\n *\n * run(alepha);\n * ```\n *\n * @see {@link ServerCacheProvider}\n * @module alepha.server.cache\n */\nexport const AlephaServerCache = $module({\n  name: \"alepha.server.cache\",\n  services: [AlephaCache, ServerCacheProvider],\n});\n"],"mappings":"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"}

package/dist/server-cache/index.d.cts

@@ -1,164 +0,0 @@
-import * as alepha1 from "alepha";
-import { Alepha } from "alepha";
-import * as alepha_logger0 from "alepha/logger";
-import * as alepha_cache0 from "alepha/cache";
-import { CacheDescriptorOptions } from "alepha/cache";
-import { BinaryLike } from "node:crypto";
-import { DateTimeProvider, DurationLike } from "alepha/datetime";
-import { RequestConfigSchema, ServerRequest, ServerRoute } from "alepha/server";
-
-//#region src/server-cache/providers/ServerCacheProvider.d.ts
-declare module "alepha/server" {
-  interface ServerRoute {
-    /**
-     * Enable caching for this route.
-     * - If true: enables both store and etag
-     * - If object: fine-grained control over store, etag, and cache-control headers
-     *
-     * @default false
-     */
-    cache?: ServerRouteCache;
-  }
-  interface ActionDescriptor<TConfig extends RequestConfigSchema> {
-    invalidate: () => Promise<void>;
-  }
-}
-declare class ServerCacheProvider {
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly alepha: Alepha;
-  protected readonly time: DateTimeProvider;
-  protected readonly cache: alepha_cache0.CacheDescriptorFn<RouteCacheEntry, any[]>;
-  generateETag(content: BinaryLike): string;
-  invalidate(route: ServerRoute): Promise<void>;
-  protected readonly onActionRequest: alepha1.HookDescriptor<"action:onRequest">;
-  protected readonly onActionResponse: alepha1.HookDescriptor<"action:onResponse">;
-  protected readonly onRequest: alepha1.HookDescriptor<"server:onRequest">;
-  protected readonly onSend: alepha1.HookDescriptor<"server:onSend">;
-  protected readonly onResponse: alepha1.HookDescriptor<"server:onResponse">;
-  buildCacheControlHeader(cache?: ServerRouteCache): string | undefined;
-  protected durationToSeconds(duration: number | DurationLike): number;
-  protected shouldStore(cache?: ServerRouteCache): boolean;
-  protected shouldUseEtag(cache?: ServerRouteCache): boolean;
-  protected createCacheKey(route: ServerRoute, config?: ServerRequest): string;
-}
-type ServerRouteCache =
-/**
- * If true, enables caching with:
- * - store: true
- * - etag: true
- */
-boolean
-/**
- * Object configuration for fine-grained cache control.
- *
- * If empty, no caching will be applied.
- */ | {
-  /**
-   * If true, enables storing cached responses. (in-memory, Redis, @see alepha/cache for other providers)
-   * If a DurationLike is provided, it will be used as the TTL for the cache.
-   * If CacheDescriptorOptions is provided, it will be used to configure the cache storage.
-   *
-   * @default false
-   */
-  store?: true | DurationLike | CacheDescriptorOptions;
-  /**
-   * If true, enables ETag support for the cached responses.
-   */
-  etag?: true;
-  /**
-   * - If true, sets Cache-Control to "public, max-age=300" (5 minutes).
-   * - If string, sets Cache-Control to the provided value directly.
-   * - If object, configures Cache-Control directives.
-   */
-  control?: true
-  /**
-   * If string, sets Cache-Control to the provided value directly.
-   */ | string
-  /**
-   * If object, configures Cache-Control directives.
-   */ | {
-    /**
-     * Indicates that the response may be cached by any cache.
-     */
-    public?: boolean;
-    /**
-     * Indicates that the response is intended for a single user and must not be stored by a shared cache.
-     */
-    private?: boolean;
-    /**
-     * Forces caches to submit the request to the origin server for validation before releasing a cached copy.
-     */
-    noCache?: boolean;
-    /**
-     * Instructs caches not to store the response.
-     */
-    noStore?: boolean;
-    /**
-     * Maximum amount of time a resource is considered fresh.
-     * Can be specified as a number (seconds) or as a DurationLike object.
-     *
-     * @example 300 // 5 minutes in seconds
-     * @example { minutes: 5 } // 5 minutes
-     * @example { hours: 1 } // 1 hour
-     */
-    maxAge?: number | DurationLike;
-    /**
-     * Overrides max-age for shared caches (e.g., CDNs).
-     * Can be specified as a number (seconds) or as a DurationLike object.
-     */
-    sMaxAge?: number | DurationLike;
-    /**
-     * Indicates that once a resource becomes stale, caches must not use it without successful validation.
-     */
-    mustRevalidate?: boolean;
-    /**
-     * Similar to must-revalidate, but only for shared caches.
-     */
-    proxyRevalidate?: boolean;
-    /**
-     * Indicates that the response can be stored but must be revalidated before each use.
-     */
-    immutable?: boolean;
-  };
-};
-interface RouteCacheEntry {
-  contentType?: string;
-  body: any;
-  status?: number;
-  lastModified: string;
-  hash: string;
-}
-//#endregion
-//#region src/server-cache/index.d.ts
-/**
- * Plugin for Alepha Server that provides server-side caching capabilities.
- * It uses the Alepha Cache module to cache responses from server actions ($action).
- * It also provides a ETag-based cache invalidation mechanism.
- *
- * @example
- * ```ts
- * import { Alepha } from "alepha";
- * import { $action } from "alepha/server";
- * import { AlephaServerCache } from "alepha/server/cache";
- *
- * class ApiServer {
- *   hello = $action({
- *     cache: true,
- *     handler: () => "Hello, World!",
- *   });
- * }
- *
- * const alepha = Alepha.create()
- *   .with(AlephaServerCache)
- *   .with(ApiServer);
- *
- * run(alepha);
- * ```
- *
- * @see {@link ServerCacheProvider}
- * @module alepha.server.cache
- */
-declare const AlephaServerCache: alepha1.Service<alepha1.Module>;
-//#endregion
-export { AlephaServerCache, ServerCacheProvider, ServerRouteCache };
-//# sourceMappingURL=index.d.cts.map

package/dist/server-compress/index.cjs

@@ -1,141 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let alepha = require("alepha");
-let alepha_server = require("alepha/server");
-let node_stream = require("node:stream");
-let node_stream_web = require("node:stream/web");
-let node_util = require("node:util");
-let node_zlib = require("node:zlib");
-node_zlib = __toESM(node_zlib);
-
-//#region src/server-compress/providers/ServerCompressProvider.ts
-const gzip = (0, node_util.promisify)(node_zlib.gzip);
-const createGzip = node_zlib.createGzip;
-const brotli = (0, node_util.promisify)(node_zlib.brotliCompress);
-const createBrotliCompress = node_zlib.createBrotliCompress;
-const zstd = node_zlib.zstdCompress ? (0, node_util.promisify)(node_zlib.zstdCompress) : void 0;
-const createZstdCompress = zstd ? node_zlib.createZstdCompress : void 0;
-var ServerCompressProvider = class ServerCompressProvider {
-	static compressors = {
-		gzip: {
-			compress: gzip,
-			stream: createGzip
-		},
-		br: {
-			compress: brotli,
-			stream: createBrotliCompress
-		},
-		zstd: zstd && createZstdCompress ? {
-			compress: zstd,
-			stream: createZstdCompress
-		} : void 0
-	};
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	get options() {
-		return {
-			allowedContentTypes: [
-				"application/json",
-				"text/html",
-				"application/javascript",
-				"text/plain",
-				"text/css"
-			],
-			...this.alepha.state.get("alepha.server.compress.options")
-		};
-	}
-	onResponse = (0, alepha.$hook)({
-		on: "server:onResponse",
-		handler: async ({ request, response }) => {
-			if (response.headers["content-encoding"]) return;
-			const acceptEncoding = request.headers["accept-encoding"];
-			if (!acceptEncoding) return;
-			if (!this.isAllowedContentType(response.headers["content-type"])) return;
-			for (const encoding of [
-				"zstd",
-				"br",
-				"gzip"
-			]) if (acceptEncoding.includes(encoding) && ServerCompressProvider.compressors[encoding]) {
-				await this.compress(encoding, response);
-				return;
-			}
-		}
-	});
-	isAllowedContentType(contentType) {
-		if (!contentType) return false;
-		const lowerContentType = contentType.toLowerCase();
-		return !!this.options.allowedContentTypes.find((it) => lowerContentType.includes(it));
-	}
-	async compress(encoding, response) {
-		const body = response.body;
-		const compressor = ServerCompressProvider.compressors[encoding];
-		if (!compressor) return;
-		const params = this.getParams(encoding);
-		if (typeof body === "string" || Buffer.isBuffer(body) || body instanceof ArrayBuffer) {
-			const compressed = await compressor.compress(body, { params });
-			this.setHeaders(response, encoding);
-			response.headers["content-length"] = compressed.length.toString();
-			response.body = compressed;
-		}
-		if (typeof body === "object" && body instanceof node_stream.Readable) {
-			this.setHeaders(response, encoding);
-			response.body = body.pipe(compressor.stream({ params }));
-		}
-		if (typeof body === "object" && body instanceof node_stream_web.ReadableStream) {
-			this.setHeaders(response, encoding);
-			response.body = node_stream.Readable.fromWeb(body).pipe(compressor.stream({ params }));
-		}
-	}
-	getParams(encoding) {
-		if (encoding === "zstd") return { [node_zlib.constants.ZSTD_c_compressionLevel]: 3 };
-		if (encoding === "br") return {};
-		if (encoding === "gzip") return {};
-		return {};
-	}
-	setHeaders(response, encoding) {
-		response.headers.vary = "content-encoding";
-		response.headers["content-encoding"] = encoding;
-		response.headers["cache-control"] = "no-cache";
-	}
-};
-
-//#endregion
-//#region src/server-compress/index.ts
-/**
-* Plugin for Alepha Server that provides server-side compression capabilities.
-*
-* Compresses responses using gzip, brotli, or zstd based on the `Accept-Encoding` header.
-*/
-const AlephaServerCompress = (0, alepha.$module)({
-	name: "alepha.server.compress",
-	services: [alepha_server.AlephaServer, ServerCompressProvider]
-});
-
-//#endregion
-exports.AlephaServerCompress = AlephaServerCompress;
-exports.ServerCompressProvider = ServerCompressProvider;
-//# sourceMappingURL=index.cjs.map

package/dist/server-compress/index.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.cjs","names":["zlib","Alepha","Readable","ReadableStream","AlephaServer"],"sources":["../../src/server-compress/providers/ServerCompressProvider.ts","../../src/server-compress/index.ts"],"sourcesContent":["import { Readable, type Transform } from \"node:stream\";\nimport { ReadableStream } from \"node:stream/web\";\nimport { promisify } from \"node:util\";\nimport * as zlib from \"node:zlib\";\nimport { $hook, $inject, Alepha, type HookDescriptor } from \"alepha\";\nimport type { ServerResponse } from \"alepha/server\";\n\nconst gzip = promisify(zlib.gzip);\nconst createGzip = zlib.createGzip;\nconst brotli = promisify(zlib.brotliCompress);\nconst createBrotliCompress = zlib.createBrotliCompress;\nconst zstd = zlib.zstdCompress ? promisify(zlib.zstdCompress) : undefined;\nconst createZstdCompress = zstd ? zlib.createZstdCompress : undefined;\n\ndeclare module \"alepha\" {\n  interface State {\n    \"alepha.server.compress.options\"?: ServerCompressProviderOptions;\n  }\n}\n\nexport class ServerCompressProvider {\n  static compressors: Record<\n    string,\n    | {\n        compress: (...args: any[]) => Promise<Buffer>;\n        stream: (options?: any) => Transform;\n      }\n    | undefined\n  > = {\n    gzip: {\n      compress: gzip,\n      stream: createGzip,\n    },\n    br: {\n      compress: brotli,\n      stream: createBrotliCompress,\n    },\n    zstd:\n      zstd && createZstdCompress\n        ? {\n            compress: zstd,\n            stream: createZstdCompress,\n          }\n        : undefined,\n  };\n\n  protected readonly alepha = $inject(Alepha);\n\n  protected get options(): ServerCompressProviderOptions {\n    return {\n      allowedContentTypes: [\n        \"application/json\",\n        \"text/html\",\n        \"application/javascript\",\n        \"text/plain\",\n        \"text/css\",\n      ],\n      ...this.alepha.state.get(\"alepha.server.compress.options\"),\n    };\n  }\n\n  public readonly onResponse: HookDescriptor<\"server:onResponse\"> = $hook({\n    on: \"server:onResponse\",\n    handler: async ({ request, response }) => {\n      // skip if already compressed\n      if (response.headers[\"content-encoding\"]) {\n        return;\n      }\n\n      const acceptEncoding = request.headers[\"accept-encoding\"]; // skip if no accept-encoding header\n      if (!acceptEncoding) {\n        return;\n      }\n\n      // skip if not json or html (for now)\n      if (!this.isAllowedContentType(response.headers[\"content-type\"])) {\n        return;\n      }\n\n      for (const encoding of [\"zstd\", \"br\", \"gzip\"] as const) {\n        if (\n          acceptEncoding.includes(encoding) &&\n          ServerCompressProvider.compressors[encoding]\n        ) {\n          await this.compress(encoding, response);\n          return;\n        }\n      }\n    },\n  });\n\n  protected isAllowedContentType(contentType: string | undefined): boolean {\n    if (!contentType) {\n      return false;\n    }\n\n    const lowerContentType = contentType.toLowerCase();\n\n    return !!this.options.allowedContentTypes.find((it) =>\n      lowerContentType.includes(it),\n    );\n  }\n\n  protected async compress(\n    encoding: keyof typeof ServerCompressProvider.compressors,\n    response: ServerResponse,\n  ): Promise<void> {\n    const body = response.body; // can be string or Buffer or ArrayBuffer or Readable\n\n    const compressor = ServerCompressProvider.compressors[encoding];\n    if (!compressor) {\n      return;\n    }\n\n    const params = this.getParams(encoding);\n\n    if (\n      typeof body === \"string\" ||\n      Buffer.isBuffer(body) ||\n      body instanceof ArrayBuffer\n    ) {\n      const compressed = await compressor.compress(body, {\n        params,\n      });\n      this.setHeaders(response, encoding);\n      response.headers[\"content-length\"] = compressed.length.toString();\n      response.body = compressed;\n    }\n\n    if (typeof body === \"object\" && body instanceof Readable) {\n      this.setHeaders(response, encoding);\n      response.body = body.pipe(compressor.stream({ params }));\n    }\n\n    if (typeof body === \"object\" && body instanceof ReadableStream) {\n      this.setHeaders(response, encoding);\n      response.body = Readable.fromWeb(body).pipe(\n        compressor.stream({ params }),\n      );\n    }\n  }\n\n  protected getParams(\n    encoding: keyof typeof ServerCompressProvider.compressors,\n  ): Record<number, any> {\n    if (encoding === \"zstd\") {\n      return {\n        [zlib.constants.ZSTD_c_compressionLevel]: 3, // default compression level for zstd\n      };\n    }\n    if (encoding === \"br\") {\n      return {};\n    }\n    if (encoding === \"gzip\") {\n      return {};\n    }\n    return {};\n  }\n\n  protected setHeaders(\n    response: ServerResponse,\n    encoding: keyof typeof ServerCompressProvider.compressors,\n  ): void {\n    response.headers.vary = \"content-encoding\";\n    response.headers[\"content-encoding\"] = encoding;\n    response.headers[\"cache-control\"] = \"no-cache\";\n  }\n}\n\nexport interface ServerCompressProviderOptions {\n  allowedContentTypes: string[];\n}\n","import { $module } from \"alepha\";\nimport { AlephaServer } from \"alepha/server\";\nimport { ServerCompressProvider } from \"./providers/ServerCompressProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\nexport * from \"./providers/ServerCompressProvider.ts\";\n\n// ---------------------------------------------------------------------------------------------------------------------\n\n/**\n * Plugin for Alepha Server that provides server-side compression capabilities.\n *\n * Compresses responses using gzip, brotli, or zstd based on the `Accept-Encoding` header.\n */\nexport const AlephaServerCompress = $module({\n  name: \"alepha.server.compress\",\n  services: [AlephaServer, ServerCompressProvider],\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOA,MAAM,gCAAiBA,UAAK,KAAK;AACjC,MAAM,aAAaA,UAAK;AACxB,MAAM,kCAAmBA,UAAK,eAAe;AAC7C,MAAM,uBAAuBA,UAAK;AAClC,MAAM,OAAOA,UAAK,wCAAyBA,UAAK,aAAa,GAAG;AAChE,MAAM,qBAAqB,OAAOA,UAAK,qBAAqB;AAQ5D,IAAa,yBAAb,MAAa,uBAAuB;CAClC,OAAO,cAOH;EACF,MAAM;GACJ,UAAU;GACV,QAAQ;GACT;EACD,IAAI;GACF,UAAU;GACV,QAAQ;GACT;EACD,MACE,QAAQ,qBACJ;GACE,UAAU;GACV,QAAQ;GACT,GACD;EACP;CAED,AAAmB,6BAAiBC,cAAO;CAE3C,IAAc,UAAyC;AACrD,SAAO;GACL,qBAAqB;IACnB;IACA;IACA;IACA;IACA;IACD;GACD,GAAG,KAAK,OAAO,MAAM,IAAI,iCAAiC;GAC3D;;CAGH,AAAgB,+BAAwD;EACtE,IAAI;EACJ,SAAS,OAAO,EAAE,SAAS,eAAe;AAExC,OAAI,SAAS,QAAQ,oBACnB;GAGF,MAAM,iBAAiB,QAAQ,QAAQ;AACvC,OAAI,CAAC,eACH;AAIF,OAAI,CAAC,KAAK,qBAAqB,SAAS,QAAQ,gBAAgB,CAC9D;AAGF,QAAK,MAAM,YAAY;IAAC;IAAQ;IAAM;IAAO,CAC3C,KACE,eAAe,SAAS,SAAS,IACjC,uBAAuB,YAAY,WACnC;AACA,UAAM,KAAK,SAAS,UAAU,SAAS;AACvC;;;EAIP,CAAC;CAEF,AAAU,qBAAqB,aAA0C;AACvE,MAAI,CAAC,YACH,QAAO;EAGT,MAAM,mBAAmB,YAAY,aAAa;AAElD,SAAO,CAAC,CAAC,KAAK,QAAQ,oBAAoB,MAAM,OAC9C,iBAAiB,SAAS,GAAG,CAC9B;;CAGH,MAAgB,SACd,UACA,UACe;EACf,MAAM,OAAO,SAAS;EAEtB,MAAM,aAAa,uBAAuB,YAAY;AACtD,MAAI,CAAC,WACH;EAGF,MAAM,SAAS,KAAK,UAAU,SAAS;AAEvC,MACE,OAAO,SAAS,YAChB,OAAO,SAAS,KAAK,IACrB,gBAAgB,aAChB;GACA,MAAM,aAAa,MAAM,WAAW,SAAS,MAAM,EACjD,QACD,CAAC;AACF,QAAK,WAAW,UAAU,SAAS;AACnC,YAAS,QAAQ,oBAAoB,WAAW,OAAO,UAAU;AACjE,YAAS,OAAO;;AAGlB,MAAI,OAAO,SAAS,YAAY,gBAAgBC,sBAAU;AACxD,QAAK,WAAW,UAAU,SAAS;AACnC,YAAS,OAAO,KAAK,KAAK,WAAW,OAAO,EAAE,QAAQ,CAAC,CAAC;;AAG1D,MAAI,OAAO,SAAS,YAAY,gBAAgBC,gCAAgB;AAC9D,QAAK,WAAW,UAAU,SAAS;AACnC,YAAS,OAAOD,qBAAS,QAAQ,KAAK,CAAC,KACrC,WAAW,OAAO,EAAE,QAAQ,CAAC,CAC9B;;;CAIL,AAAU,UACR,UACqB;AACrB,MAAI,aAAa,OACf,QAAO,GACJF,UAAK,UAAU,0BAA0B,GAC3C;AAEH,MAAI,aAAa,KACf,QAAO,EAAE;AAEX,MAAI,aAAa,OACf,QAAO,EAAE;AAEX,SAAO,EAAE;;CAGX,AAAU,WACR,UACA,UACM;AACN,WAAS,QAAQ,OAAO;AACxB,WAAS,QAAQ,sBAAsB;AACvC,WAAS,QAAQ,mBAAmB;;;;;;;;;;;ACtJxC,MAAa,2CAA+B;CAC1C,MAAM;CACN,UAAU,CAACI,4BAAc,uBAAuB;CACjD,CAAC"}

package/dist/server-compress/index.d.cts

@@ -1,38 +0,0 @@
-import * as alepha0 from "alepha";
-import { Alepha, HookDescriptor } from "alepha";
-import { Transform } from "node:stream";
-import { ServerResponse } from "alepha/server";
-
-//#region src/server-compress/providers/ServerCompressProvider.d.ts
-declare module "alepha" {
-  interface State {
-    "alepha.server.compress.options"?: ServerCompressProviderOptions;
-  }
-}
-declare class ServerCompressProvider {
-  static compressors: Record<string, {
-    compress: (...args: any[]) => Promise<Buffer>;
-    stream: (options?: any) => Transform;
-  } | undefined>;
-  protected readonly alepha: Alepha;
-  protected get options(): ServerCompressProviderOptions;
-  readonly onResponse: HookDescriptor<"server:onResponse">;
-  protected isAllowedContentType(contentType: string | undefined): boolean;
-  protected compress(encoding: keyof typeof ServerCompressProvider.compressors, response: ServerResponse): Promise<void>;
-  protected getParams(encoding: keyof typeof ServerCompressProvider.compressors): Record<number, any>;
-  protected setHeaders(response: ServerResponse, encoding: keyof typeof ServerCompressProvider.compressors): void;
-}
-interface ServerCompressProviderOptions {
-  allowedContentTypes: string[];
-}
-//#endregion
-//#region src/server-compress/index.d.ts
-/**
- * Plugin for Alepha Server that provides server-side compression capabilities.
- *
- * Compresses responses using gzip, brotli, or zstd based on the `Accept-Encoding` header.
- */
-declare const AlephaServerCompress: alepha0.Service<alepha0.Module>;
-//#endregion
-export { AlephaServerCompress, ServerCompressProvider, ServerCompressProviderOptions };
-//# sourceMappingURL=index.d.cts.map