alepha 0.7.4 → 0.7.6

package/security.js

@@ -1 +1 @@
-export * from '@alepha/security';
+export * from '@alepha/security'

package/server/cache.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var serverCache = require('@alepha/server-cache');
-
-
-
-Object.keys(serverCache).forEach(function (k) {
+var m = require('@alepha/server-cache');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return serverCache[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});

package/server/cache.d.ts

@@ -1,51 +1,85 @@
-import * as _alepha_core from '@alepha/core';
-import { Alepha, OPTIONS, Module } from '@alepha/core';
-import { CacheDescriptorOptions, CacheDescriptorProvider, Cache } from '@alepha/cache';
-import { DurationLike, DateTimeProvider } from '@alepha/datetime';
-import { ServerHandler, ServerRequestConfig } from '@alepha/server';
+import { Cache, CacheDescriptorOptions, CacheDescriptorProvider } from "@alepha/cache";
+import { ServerHandler, ServerRequestConfig } from "@alepha/server";
+import * as _alepha_core1 from "@alepha/core";
+import { Alepha, Module, OPTIONS } from "@alepha/core";
+import { DateTimeProvider, DurationLike } from "@alepha/datetime";
 
+//#region src/providers/ServerCacheProvider.d.ts
 declare module "alepha/server" {
-    interface ServerRoute {
-        cache?: ServiceRouteCache;
-    }
-    interface ActionDescriptor {
-        invalidate: () => Promise<void>;
-    }
+  interface ServerRoute {
+    cache?: ServerRouteCache;
+  }
+  interface ActionDescriptor {
+    invalidate: () => Promise<void>;
+  }
 }
 declare class ServerCacheProvider {
-    protected readonly log: _alepha_core.Logger;
-    protected readonly alepha: Alepha;
-    protected readonly cacheProvider: CacheDescriptorProvider;
-    protected readonly time: DateTimeProvider;
-    protected readonly caches: Map<ServerHandler, RouteCache>;
-    readonly onConfigure: _alepha_core.HookDescriptor<"configure">;
-    readonly onRoute: _alepha_core.HookDescriptor<"server:onRoute">;
-    readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    readonly onSend: _alepha_core.HookDescriptor<"server:onResponse">;
-    generateETag(content: string): string;
-    invalidate(route: RouteLike): Promise<void>;
-    protected getCacheByRoute(route: RouteLike): RouteCache | undefined;
-    protected createCacheKey(args: ServerRequestConfig): string;
+  protected readonly log: _alepha_core1.Logger;
+  protected readonly alepha: Alepha;
+  protected readonly cacheProvider: CacheDescriptorProvider;
+  protected readonly time: DateTimeProvider;
+  protected readonly caches: Map<ServerHandler, RouteCache>;
+  readonly onConfigure: _alepha_core1.HookDescriptor<"configure">;
+  readonly onRoute: _alepha_core1.HookDescriptor<"server:onRoute">;
+  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  readonly onSend: _alepha_core1.HookDescriptor<"server:onResponse">;
+  generateETag(content: string): string;
+  invalidate(route: RouteLike): Promise<void>;
+  protected getCacheByRoute(route: RouteLike): RouteCache | undefined;
+  protected createCacheKey(args: ServerRequestConfig): string;
 }
-type ServiceRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
+type ServerRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
 type RouteCache = Cache<{
-    contentType?: string;
-    body: string;
-    status?: number;
-    lastModified: string;
-    hash: string;
+  contentType?: string;
+  body: string;
+  status?: number;
+  lastModified: string;
+  hash: string;
 }>;
 type RouteLike = {
-    [OPTIONS]: {
-        handler?: ServerHandler;
-    };
-} | {
+  [OPTIONS]: {
     handler?: ServerHandler;
+  };
+} | {
+  handler?: ServerHandler;
 };
-
+//#endregion
+//#region src/index.d.ts
+/**
+ * # Alepha Server Cache Module
+ *
+ * @description
+ * 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/core";
+ * 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 class AlephaServerCache implements Module {
-    readonly name = "alepha.server.cache";
-    readonly $services: (alepha: Alepha) => Alepha;
+  readonly name = "alepha.server.cache";
+  readonly $services: (alepha: Alepha) => Alepha;
 }
-
-export { AlephaServerCache, ServerCacheProvider, type ServiceRouteCache };
+//#endregion
+export { AlephaServerCache, ServerCacheProvider, ServerRouteCache };
+//# sourceMappingURL=index.d.ts.map

package/server/cache.js

@@ -1 +1 @@
-export * from '@alepha/server-cache';
+export * from '@alepha/server-cache'

package/server/cookies.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var serverCookies = require('@alepha/server-cookies');
-
-
-
-Object.keys(serverCookies).forEach(function (k) {
+var m = require('@alepha/server-cookies');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return serverCookies[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});

package/server/cookies.d.ts

@@ -1,56 +1,61 @@
-import * as _alepha_core from '@alepha/core';
-import { TSchema, KIND, OPTIONS, Static } from '@alepha/core';
-import { DurationLike } from '@alepha/datetime';
+import * as _alepha_core1 from "@alepha/core";
+import { KIND, OPTIONS, Static, TSchema } from "@alepha/core";
+import { DurationLike } from "@alepha/datetime";
+import "@alepha/server";
 
+//#region src/descriptors/$cookie.d.ts
 interface CookieDescriptorOptions<T extends TSchema> {
-    schema: T;
-    name: string;
-    path?: string;
-    ttl?: DurationLike;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: "strict" | "lax" | "none";
-    domain?: string;
-    compress?: boolean;
-    encrypt?: boolean;
-    sign?: boolean;
+  schema: T;
+  name: string;
+  path?: string;
+  ttl?: DurationLike;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: "strict" | "lax" | "none";
+  domain?: string;
+  compress?: boolean;
+  encrypt?: boolean;
+  sign?: boolean;
 }
 interface CookieDescriptor<T extends TSchema> {
-    [KIND]: "COOKIE";
-    [OPTIONS]: CookieDescriptorOptions<T>;
-    set: (cookies: Cookies, value: Static<T>) => void;
-    get: (cookies: Cookies) => Static<T> | undefined;
-    del: (cookies: Cookies) => void;
+  [KIND]: "COOKIE";
+  [OPTIONS]: CookieDescriptorOptions<T>;
+  set: (cookies: Cookies, value: Static<T>) => void;
+  get: (cookies: Cookies) => Static<T> | undefined;
+  del: (cookies: Cookies) => void;
 }
 declare const $cookie: {
-    <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
-    [KIND]: string;
+  <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
+  [KIND]: string;
 };
 interface Cookies {
-    req: Record<string, string>;
-    res: Record<string, Cookie | null>;
+  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;
+  value: string;
+  path?: string;
+  maxAge?: number;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: "strict" | "lax" | "none";
+  domain?: string;
 }
-
+//#endregion
+//#region src/providers/ServerCookiesProvider.d.ts
 declare class ServerCookiesProvider {
-    readonly onRequest: _alepha_core.HookDescriptor<"server:onRequest">;
-    readonly onSend: _alepha_core.HookDescriptor<"server:onSend">;
-    fromHeader(header: string): Record<string, string>;
-    toHeader(cookies: Record<string, Cookie | null>, isHttps?: boolean): string[];
+  readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  readonly onSend: _alepha_core1.HookDescriptor<"server:onSend">;
+  fromHeader(header: string): Record<string, string>;
+  toHeader(cookies: Record<string, Cookie | null>, isHttps?: boolean): string[];
 }
-
+//#endregion
+//#region src/index.d.ts
 declare module "alepha/server" {
-    interface ServerRequest {
-        cookies: Cookies;
-    }
+  interface ServerRequest {
+    cookies: Cookies;
+  }
 }
-
-export { $cookie, type Cookie, type CookieDescriptor, type CookieDescriptorOptions, type Cookies, ServerCookiesProvider };
+//#endregion
+export { $cookie, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/cookies.js

@@ -1 +1 @@
-export * from '@alepha/server-cookies';
+export * from '@alepha/server-cookies'

package/server/static.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var serverStatic = require('@alepha/server-static');
-
-
-
-Object.keys(serverStatic).forEach(function (k) {
+var m = require('@alepha/server-static');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return serverStatic[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});

package/server/static.d.ts

@@ -1,109 +1,112 @@
-import * as _alepha_core from '@alepha/core';
-import { KIND, OPTIONS, Alepha } from '@alepha/core';
-import { DurationLike, DateTimeProvider } from '@alepha/datetime';
-import { ServerRouterProvider, ServerHandler } from '@alepha/server';
+import * as _alepha_core0 from "@alepha/core";
+import { Alepha, KIND, OPTIONS } from "@alepha/core";
+import { DateTimeProvider, DurationLike } from "@alepha/datetime";
+import { ServerHandler, ServerRouterProvider } from "@alepha/server";
 
+//#region src/descriptors/$serve.d.ts
 declare const KEY = "SERVE";
 interface ServeDescriptorOptions {
-    /**
-     * Prefix for the served path.
-     *
-     * @default "/"
-     */
-    path?: string;
-    /**
-     * Path to the directory to serve.
-     *
-     * @default process.cwd()
-     */
-    root?: string;
-    /**
-     * If true, descriptor will be ignored.
-     *
-     * @default false
-     */
-    disabled?: boolean;
-    /**
-     * Whether to keep dot files (e.g. `.gitignore`, `.env`) in the served directory.
-     *
-     * @default true
-     */
-    ignoreDotEnvFiles?: boolean;
-    /**
-     * Whether to use the index.html file when the path is a directory.
-     *
-     * @default true
-     */
-    indexFallback?: boolean;
-    /**
-     * Force all requests "not found" to be served with the index.html file.
-     * This is useful for single-page applications (SPAs) that use client-side only routing.
-     */
-    historyApiFallback?: boolean;
-    /**
-     * Optional name of the descriptor.
-     * This is used for logging and debugging purposes.
-     *
-     * @default Key name.
-     */
-    name?: string;
-    /**
-     * Whether to use cache control headers.
-     *
-     * @default {}
-     */
-    cacheControl?: Partial<CacheControlOptions> | false;
+  /**
+   * Prefix for the served path.
+   *
+   * @default "/"
+   */
+  path?: string;
+  /**
+   * Path to the directory to serve.
+   *
+   * @default process.cwd()
+   */
+  root?: string;
+  /**
+   * If true, descriptor will be ignored.
+   *
+   * @default false
+   */
+  disabled?: boolean;
+  /**
+   * Whether to keep dot files (e.g. `.gitignore`, `.env`) in the served directory.
+   *
+   * @default true
+   */
+  ignoreDotEnvFiles?: boolean;
+  /**
+   * Whether to use the index.html file when the path is a directory.
+   *
+   * @default true
+   */
+  indexFallback?: boolean;
+  /**
+   * Force all requests "not found" to be served with the index.html file.
+   * This is useful for single-page applications (SPAs) that use client-side only routing.
+   */
+  historyApiFallback?: boolean;
+  /**
+   * Optional name of the descriptor.
+   * This is used for logging and debugging purposes.
+   *
+   * @default Key name.
+   */
+  name?: string;
+  /**
+   * Whether to use cache control headers.
+   *
+   * @default {}
+   */
+  cacheControl?: Partial<CacheControlOptions> | false;
 }
 interface CacheControlOptions {
-    /**
-     * Whether to use cache control headers.
-     *
-     * @default [.js, .css]
-     */
-    fileTypes: string[];
-    /**
-     * The maximum age of the cache in seconds.
-     *
-     * @default 60 * 60 * 24 * 2 // 2 days
-     */
-    maxAge: DurationLike;
-    /**
-     * Whether to use immutable cache control headers.
-     *
-     * @default true
-     */
-    immutable: boolean;
+  /**
+   * Whether to use cache control headers.
+   *
+   * @default [.js, .css]
+   */
+  fileTypes: string[];
+  /**
+   * The maximum age of the cache in seconds.
+   *
+   * @default 60 * 60 * 24 * 2 // 2 days
+   */
+  maxAge: DurationLike;
+  /**
+   * Whether to use immutable cache control headers.
+   *
+   * @default true
+   */
+  immutable: boolean;
 }
 interface ServeDescriptor {
-    [KIND]: typeof KEY;
-    [OPTIONS]: ServeDescriptorOptions;
-    list(): string[];
+  [KIND]: typeof KEY;
+  [OPTIONS]: ServeDescriptorOptions;
+  list(): string[];
 }
 declare const $serve: {
-    (options?: ServeDescriptorOptions): ServeDescriptor;
-    [KIND]: string;
+  (options?: ServeDescriptorOptions): ServeDescriptor;
+  [KIND]: string;
 };
-
+//#endregion
+//#region src/providers/ServerStaticProvider.d.ts
 declare class ServerStaticProvider {
-    protected readonly alepha: Alepha;
-    protected readonly routerProvider: ServerRouterProvider;
-    protected readonly dateTimeProvider: DateTimeProvider;
-    protected readonly log: _alepha_core.Logger;
-    protected readonly directories: ServeDirectory[];
-    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
-    list(name: string): string[];
-    serve(options: ServeDescriptorOptions): Promise<void>;
-    createFileHandler(filepath: string, options: ServeDescriptorOptions): Promise<ServerHandler>;
-    protected getCacheFileTypes(): string[];
-    protected getCacheControl(filename: string, options: ServeDescriptorOptions): {
-        maxAge: number;
-        immutable: boolean;
-    } | undefined;
-    getAllFiles(dir: string, ignoreDotEnvFiles?: boolean): Promise<string[]>;
+  protected readonly alepha: Alepha;
+  protected readonly routerProvider: ServerRouterProvider;
+  protected readonly dateTimeProvider: DateTimeProvider;
+  protected readonly log: _alepha_core0.Logger;
+  protected readonly directories: ServeDirectory[];
+  protected readonly configure: _alepha_core0.HookDescriptor<"configure">;
+  list(name: string): string[];
+  serve(options: ServeDescriptorOptions): Promise<void>;
+  createFileHandler(filepath: string, options: ServeDescriptorOptions): Promise<ServerHandler>;
+  protected getCacheFileTypes(): string[];
+  protected getCacheControl(filename: string, options: ServeDescriptorOptions): {
+    maxAge: number;
+    immutable: boolean;
+  } | undefined;
+  getAllFiles(dir: string, ignoreDotEnvFiles?: boolean): Promise<string[]>;
 }
 interface ServeDirectory {
-    options: ServeDescriptorOptions;
-    files: string[];
+  options: ServeDescriptorOptions;
+  files: string[];
 }
-
-export { $serve, type CacheControlOptions, type ServeDescriptor, type ServeDescriptorOptions, type ServeDirectory, ServerStaticProvider };
+//#endregion
+export { $serve, CacheControlOptions, ServeDescriptor, ServeDescriptorOptions, ServeDirectory, ServerStaticProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/static.js

@@ -1 +1 @@
-export * from '@alepha/server-static';
+export * from '@alepha/server-static'

package/server/swagger.cjs

@@ -1,12 +1,8 @@
 'use strict';
-
-var serverSwagger = require('@alepha/server-swagger');
-
-
-
-Object.keys(serverSwagger).forEach(function (k) {
+var m = require('@alepha/server-swagger');
+Object.keys(m).forEach(function (k) {
 	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
 		enumerable: true,
-		get: function () { return serverSwagger[k]; }
+		get: function () { return m[k]; }
 	});
-});
+});