alepha 0.11.2 → 0.11.4

package/server/cache.d.ts

@@ -1,163 +1 @@
-import * as _alepha_cache0 from "alepha/cache";
-import { CacheDescriptorOptions } from "alepha/cache";
-import * as _alepha_core1 from "alepha";
-import { Alepha } from "alepha";
-import { DateTimeProvider, DurationLike } from "alepha/datetime";
-import * as _alepha_logger0 from "alepha/logger";
-import { RequestConfigSchema, ServerRequest, ServerRoute } from "alepha/server";
-
-//#region src/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: string): string;
-  invalidate(route: ServerRoute): Promise<void>;
-  protected readonly onActionRequest: _alepha_core1.HookDescriptor<"action:onRequest">;
-  protected readonly onActionResponse: _alepha_core1.HookDescriptor<"action:onResponse">;
-  protected readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
-  protected readonly onSend: _alepha_core1.HookDescriptor<"server:onSend">;
-  protected readonly onResponse: _alepha_core1.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/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: _alepha_core1.Service<_alepha_core1.Module<{}>>;
-//#endregion
-export { AlephaServerCache, ServerCacheProvider, ServerRouteCache };
-//# sourceMappingURL=index.d.ts.map
+export * from '@alepha/server-cache';

package/server/compress.d.ts

@@ -1,32 +1 @@
-import * as _alepha_core0 from "alepha";
-import { HookDescriptor } from "alepha";
-import { ServerResponse } from "alepha/server";
-import { Transform } from "node:stream";
-
-//#region src/providers/ServerCompressProvider.d.ts
-declare class ServerCompressProvider {
-  static compressors: Record<string, {
-    compress: (...args: any[]) => Promise<Buffer>;
-    stream: (options?: any) => Transform;
-  } | undefined>;
-  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/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: _alepha_core0.Service<_alepha_core0.Module<{}>>;
-//#endregion
-export { AlephaServerCompress, ServerCompressProvider, ServerCompressProviderOptions };
-//# sourceMappingURL=index.d.ts.map
+export * from '@alepha/server-compress';

package/server/cookies.d.ts

@@ -1,144 +1 @@
-import * as _alepha_core1 from "alepha";
-import { Alepha, Descriptor, KIND, Static, TSchema } from "alepha";
-import { DateTimeProvider, DurationLike } from "alepha/datetime";
-import * as _alepha_logger0 from "alepha/logger";
-
-//#region src/services/CookieParser.d.ts
-declare class CookieParser {
-  parseRequestCookies(header: string): Record<string, string>;
-  serializeResponseCookies(cookies: Record<string, Cookie | null>, isHttps: boolean): string[];
-  cookieToString(name: string, cookie: Cookie, isHttps?: boolean): string;
-}
-//#endregion
-//#region src/providers/ServerCookiesProvider.d.ts
-declare class ServerCookiesProvider {
-  protected readonly alepha: Alepha;
-  protected readonly log: _alepha_logger0.Logger;
-  protected readonly cookieParser: CookieParser;
-  protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly env: {
-    APP_SECRET: string;
-  };
-  protected readonly ALGORITHM = "aes-256-gcm";
-  protected readonly IV_LENGTH = 16;
-  protected readonly AUTH_TAG_LENGTH = 16;
-  protected readonly SIGNATURE_LENGTH = 32;
-  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
-  readonly onAction: _alepha_core1.HookDescriptor<"action:onRequest">;
-  readonly onSend: _alepha_core1.HookDescriptor<"server:onSend">;
-  protected getCookiesFromContext(cookies?: Cookies): Cookies;
-  getCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, contextCookies?: Cookies): Static<T> | undefined;
-  setCookie<T extends TSchema>(name: string, options: CookieDescriptorOptions<T>, data: Static<T>, contextCookies?: Cookies): void;
-  deleteCookie<T extends TSchema>(name: string, contextCookies?: Cookies): void;
-  protected encrypt(text: string): string;
-  protected decrypt(encryptedText: string): string;
-  secretKey(): string;
-  protected sign(data: string): string;
-}
-//#endregion
-//#region src/descriptors/$cookie.d.ts
-/**
- * Declares a type-safe, configurable HTTP cookie.
- * This descriptor provides methods to get, set, and delete the cookie
- * within the server request/response cycle.
- */
-declare const $cookie: {
-  <T extends TSchema>(options: CookieDescriptorOptions<T>): AbstractCookieDescriptor<T>;
-  [KIND]: typeof CookieDescriptor;
-};
-interface CookieDescriptorOptions<T extends TSchema> {
-  /** The schema for the cookie's value, used for validation and type safety. */
-  schema: T;
-  /** The name of the cookie. */
-  name?: string;
-  /** The cookie's path. Defaults to "/". */
-  path?: string;
-  /** Time-to-live for the cookie. Maps to `Max-Age`. */
-  ttl?: DurationLike;
-  /** If true, the cookie is only sent over HTTPS. Defaults to true in production. */
-  secure?: boolean;
-  /** If true, the cookie cannot be accessed by client-side scripts. */
-  httpOnly?: boolean;
-  /** SameSite policy for the cookie. Defaults to "lax". */
-  sameSite?: "strict" | "lax" | "none";
-  /** The domain for the cookie. */
-  domain?: string;
-  /** If true, the cookie value will be compressed using zlib. */
-  compress?: boolean;
-  /** If true, the cookie value will be encrypted. Requires `COOKIE_SECRET` env var. */
-  encrypt?: boolean;
-  /** If true, the cookie will be signed to prevent tampering. Requires `COOKIE_SECRET` env var. */
-  sign?: boolean;
-}
-interface AbstractCookieDescriptor<T extends TSchema> {
-  readonly name: string;
-  readonly options: CookieDescriptorOptions<T>;
-  set(value: Static<T>, options?: {
-    cookies?: Cookies;
-    ttl?: DurationLike;
-  }): void;
-  get(options?: {
-    cookies?: Cookies;
-  }): Static<T> | undefined;
-  del(options?: {
-    cookies?: Cookies;
-  }): void;
-}
-declare class CookieDescriptor<T extends TSchema> extends Descriptor<CookieDescriptorOptions<T>> implements AbstractCookieDescriptor<T> {
-  protected readonly serverCookiesProvider: ServerCookiesProvider;
-  get schema(): T;
-  get name(): string;
-  /**
-   * Sets the cookie with the given value in the current request's response.
-   */
-  set(value: Static<T>, options?: {
-    cookies?: Cookies;
-    ttl?: DurationLike;
-  }): void;
-  /**
-   * Gets the cookie value from the current request. Returns undefined if not found or invalid.
-   */
-  get(options?: {
-    cookies?: Cookies;
-  }): Static<T> | undefined;
-  /**
-   * Deletes the cookie in the current request's response.
-   */
-  del(options?: {
-    cookies?: Cookies;
-  }): void;
-}
-interface Cookies {
-  req: Record<string, string>;
-  res: Record<string, Cookie | null>;
-}
-interface Cookie {
-  value: string;
-  path?: string;
-  maxAge?: number;
-  secure?: boolean;
-  httpOnly?: boolean;
-  sameSite?: "strict" | "lax" | "none";
-  domain?: string;
-}
-//#endregion
-//#region src/index.d.ts
-declare module "alepha/server" {
-  interface ServerRequest {
-    cookies: Cookies;
-  }
-}
-/**
- * Provides HTTP cookie management capabilities for server requests and responses with type-safe cookie descriptors.
- *
- * The server-cookies module enables declarative cookie handling using the `$cookie` descriptor on class properties.
- * It offers automatic cookie parsing, secure cookie configuration, and seamless integration with server routes
- * for managing user sessions, preferences, and authentication tokens.
- *
- * @see {@link $cookie}
- * @module alepha.server.cookies
- */
-declare const AlephaServerCookies: _alepha_core1.Service<_alepha_core1.Module<{}>>;
-//#endregion
-export { $cookie, AbstractCookieDescriptor, AlephaServerCookies, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
-//# sourceMappingURL=index.d.ts.map
+export * from '@alepha/server-cookies';

package/server/cors.d.ts

@@ -1,27 +1 @@
-import * as _alepha_core1 from "alepha";
-import { ServerRouterProvider } from "alepha/server";
-
-//#region src/providers/ServerCorsProvider.d.ts
-declare class ServerCorsProvider {
-  protected readonly serverRouterProvider: ServerRouterProvider;
-  options: ServerCorsProviderOptions;
-  protected readonly configure: _alepha_core1.HookDescriptor<"configure">;
-  protected readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
-  isOriginAllowed(origin: string | undefined, allowed: ServerCorsProviderOptions["origin"]): boolean;
-}
-interface ServerCorsProviderOptions {
-  origin?: string | string[] | ((origin: string | undefined) => boolean);
-  methods: string[];
-  headers: string[];
-  credentials?: boolean;
-  maxAge?: number;
-}
-//#endregion
-//#region src/index.d.ts
-/**
- * Plugin for configuring CORS on the Alepha server.
- */
-declare const AlephaServerCors: _alepha_core1.Service<_alepha_core1.Module<ServerCorsProviderOptions>>;
-//#endregion
-export { AlephaServerCors, ServerCorsProvider, ServerCorsProviderOptions };
-//# sourceMappingURL=index.d.ts.map
+export * from '@alepha/server-cors';

package/server/health.d.ts

@@ -1,59 +1 @@
-import * as _alepha_core0 from "alepha";
-import { Alepha } from "alepha";
-import * as _alepha_server0 from "alepha/server";
-import { DateTimeProvider } from "alepha/datetime";
-import * as typebox5 from "typebox";
-import * as dayjs0 from "dayjs";
-
-//#region src/providers/ServerHealthProvider.d.ts
-/**
- * Register `/health` & `/healthz` endpoint.
- *
- * - Provides basic health information about the server.
- */
-declare class ServerHealthProvider {
-  protected readonly time: DateTimeProvider;
-  protected readonly alepha: Alepha;
-  readonly health: _alepha_server0.RouteDescriptor<{
-    response: typebox5.TObject<{
-      message: typebox5.TString;
-      uptime: typebox5.TNumber;
-      date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
-      ready: typebox5.TBoolean;
-    }>;
-  }>;
-  readonly healthz: _alepha_server0.RouteDescriptor<{
-    response: typebox5.TObject<{
-      message: typebox5.TString;
-      uptime: typebox5.TNumber;
-      date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
-      ready: typebox5.TBoolean;
-    }>;
-  }>;
-  protected healthCheck(): {
-    message: string;
-    uptime: number;
-    date: dayjs0.Dayjs;
-    ready: boolean;
-  };
-}
-//#endregion
-//#region src/schemas/healthSchema.d.ts
-declare const healthSchema: typebox5.TObject<{
-  message: typebox5.TString;
-  uptime: typebox5.TNumber;
-  date: typebox5.TCodec<typebox5.TString, dayjs0.Dayjs>;
-  ready: typebox5.TBoolean;
-}>;
-//#endregion
-//#region src/index.d.ts
-/**
- * Plugin for Alepha Server that provides health-check endpoints.
- *
- * @see {@link ServerHealthProvider}
- * @module alepha.server.health
- */
-declare const AlephaServerHealth: _alepha_core0.Service<_alepha_core0.Module<{}>>;
-//#endregion
-export { AlephaServerHealth, ServerHealthProvider, healthSchema };
-//# sourceMappingURL=index.d.ts.map
+export * from '@alepha/server-health';

package/server/helmet.d.ts

@@ -1,69 +1 @@
-import * as _alepha_core1 from "alepha";
-import { Alepha } from "alepha";
-
-//#region src/providers/ServerHelmetProvider.d.ts
-type CspDirective = string | string[];
-interface CspDirectives {
-  "default-src"?: CspDirective;
-  "script-src"?: CspDirective;
-  "style-src"?: CspDirective;
-  "img-src"?: CspDirective;
-  "connect-src"?: CspDirective;
-  "font-src"?: CspDirective;
-  "object-src"?: CspDirective;
-  "media-src"?: CspDirective;
-  "frame-src"?: CspDirective;
-  sandbox?: CspDirective | boolean;
-  "report-uri"?: string;
-  "child-src"?: CspDirective;
-  "form-action"?: CspDirective;
-  "frame-ancestors"?: CspDirective;
-  "plugin-types"?: CspDirective;
-  "base-uri"?: CspDirective;
-  [key: string]: CspDirective | undefined | boolean;
-}
-interface CspOptions {
-  directives: CspDirectives;
-}
-interface HstsOptions {
-  maxAge?: number;
-  includeSubDomains?: boolean;
-  preload?: boolean;
-}
-interface HelmetOptions {
-  isSecure?: boolean;
-  strictTransportSecurity?: HstsOptions | false;
-  xContentTypeOptions?: false;
-  xFrameOptions?: "DENY" | "SAMEORIGIN" | false;
-  xXssProtection?: false;
-  contentSecurityPolicy?: CspOptions | false | "default";
-  referrerPolicy?: "no-referrer" | "no-referrer-when-downgrade" | "origin" | "origin-when-cross-origin" | "same-origin" | "strict-origin" | "strict-origin-when-cross-origin" | "unsafe-url" | false;
-}
-/**
- * Provides a configurable way to apply essential HTTP security headers
- * to every server response, without external dependencies.
- */
-declare class ServerHelmetProvider {
-  protected readonly alepha: Alepha;
-  /**
-   * The configuration options. These can be overridden during
-   * the application's configuration phase using `alepha.configure()`.
-   */
-  options: HelmetOptions;
-  protected defaultCspDirectives(): CspDirectives;
-  protected buildHeaders(): Record<string, string>;
-  protected readonly onResponse: _alepha_core1.HookDescriptor<"server:onResponse">;
-}
-//#endregion
-//#region src/index.d.ts
-/**
- * Automatically adds important HTTP security headers to every response
- * to help protect your application from common web vulnerabilities.
- *
- * @see {@link ServerHelmetProvider}
- * @module alepha.server.helmet
- */
-declare const AlephaServerHelmet: _alepha_core1.Service<_alepha_core1.Module<{}>>;
-//#endregion
-export { AlephaServerHelmet, CspDirectives, CspOptions, HelmetOptions, HstsOptions, ServerHelmetProvider };
-//# sourceMappingURL=index.d.ts.map
+export * from '@alepha/server-helmet';