alepha 0.6.7 → 0.6.9

package/server/metrics.d.ts

@@ -1 +1,14 @@
-export * from '@alepha/server-metrics';
+import * as _alepha_server from '@alepha/server';
+
+declare class ServerMetricsProvider {
+    private readonly register;
+    private cpuUsage;
+    private memoryUsage;
+    private gcDuration;
+    private heapUsage;
+    readonly metrics: _alepha_server.RouteDescriptor<_alepha_server.RequestConfigSchema>;
+    constructor();
+    private collectMetrics;
+}
+
+export { ServerMetricsProvider };

package/server/proxy.d.ts

@@ -1 +1,34 @@
-export * from '@alepha/server-proxy';
+import * as _alepha_core from '@alepha/core';
+import { Async, KIND, OPTIONS, Alepha } from '@alepha/core';
+import { ServerRequest, ServerRouterProvider } from '@alepha/server';
+
+type ProxyDescriptorOptions = {
+    path: string;
+    target: string;
+    beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
+    afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
+    disabled?: boolean;
+};
+interface ProxyDescriptor {
+    [KIND]: "PROXY";
+    [OPTIONS]: ProxyDescriptorOptions;
+}
+declare const $proxy: {
+    (options: ProxyDescriptorOptions): ProxyDescriptor;
+    [KIND]: string;
+};
+
+declare class ServerProxyProvider {
+    protected readonly routerProvider: ServerRouterProvider;
+    protected readonly alepha: Alepha;
+    readonly configure: _alepha_core.HookDescriptor<"configure">;
+    proxy(options: ProxyDescriptorOptions): Promise<void>;
+    private getRawRequestBody;
+}
+
+declare class ServerProxyModule {
+    protected readonly alepha: Alepha;
+    constructor();
+}
+
+export { $proxy, type ProxyDescriptor, type ProxyDescriptorOptions, ServerProxyModule, ServerProxyProvider };

package/server/static.d.ts

@@ -1 +1,103 @@
-export * from '@alepha/server-static';
+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';
+
+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;
+    /**
+     * 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;
+}
+interface ServeDescriptor {
+    [KIND]: typeof KEY;
+    [OPTIONS]: ServeDescriptorOptions;
+    list(): string[];
+}
+declare const $serve: {
+    (options?: ServeDescriptorOptions): ServeDescriptor;
+    [KIND]: string;
+};
+
+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 getCacheControl(filename: string, options: ServeDescriptorOptions): {
+        maxAge: number;
+        immutable: boolean;
+    } | undefined;
+    getAllFiles(dir: string, ignoreDotEnvFiles?: boolean): Promise<string[]>;
+}
+interface ServeDirectory {
+    options: ServeDescriptorOptions;
+    files: string[];
+}
+
+export { $serve, type CacheControlOptions, type ServeDescriptor, type ServeDescriptorOptions, type ServeDirectory, ServerStaticProvider };

package/server/swagger.d.ts

@@ -1 +1,102 @@
-export * from '@alepha/server-swagger';
+import * as _alepha_core from '@alepha/core';
+import { KIND, OPTIONS, Alepha, TObject } from '@alepha/core';
+import { OpenAPIV3 } from 'openapi-types';
+import { ServerActionDescriptorProvider, ServerRouterProvider, ServerRouteAction } from '@alepha/server';
+import { ServerStaticProvider } from '@alepha/server-static';
+
+interface SwaggerDescriptorOptions {
+    info: OpenAPIV3.InfoObject;
+    /**
+     * @default: "/docs"
+     */
+    prefix?: string;
+    /**
+     * If true, docs will be disabled.
+     */
+    disabled?: boolean;
+    excludeTags?: string[];
+    ui?: boolean | SwaggerUiOptions;
+    rewrite?: (doc: OpenAPIV3.Document) => void;
+}
+interface SwaggerUiOptions {
+    initOAuth?: {
+        /**
+         * Default clientId.
+         */
+        clientId?: string;
+        /**
+         * realm query parameter (for oauth1) added to authorizationUrl and tokenUrl.
+         */
+        realm?: string;
+        /**
+         * application name, displayed in authorization popup.
+         */
+        appName?: string;
+        /**
+         * scope separator for passing scopes, encoded before calling, default
+         * value is a space (encoded value %20).
+         *
+         * @default ' '
+         */
+        scopeSeparator?: string;
+        /**
+         * string array or scope separator (i.e. space) separated string of
+         * initially selected oauth scopes
+         *
+         * @default []
+         */
+        scopes?: string | string[];
+        /**
+         * Additional query parameters added to authorizationUrl and tokenUrl.
+         * MUST be an object
+         */
+        additionalQueryStringParams?: {
+            [key: string]: any;
+        };
+        /**
+         * Only activated for the accessCode flow. During the authorization_code
+         * request to the tokenUrl, pass the Client Password using the HTTP Basic
+         * Authentication scheme (Authorization header with Basic
+         * base64encode(client_id + client_secret)).
+         *
+         * @default false
+         */
+        useBasicAuthenticationWithAccessCodeGrant?: boolean;
+        /**
+         * Only applies to Authorization Code flows. Proof Key for Code Exchange
+         * brings enhanced security for OAuth public clients.
+         *
+         * @default false
+         */
+        usePkceWithAuthorizationCodeGrant?: boolean;
+    };
+}
+interface SwaggerDescriptor {
+    [KIND]: "SWAGGER";
+    [OPTIONS]: SwaggerDescriptorOptions;
+    json(): OpenAPIV3.Document;
+}
+declare const $swagger: {
+    (options: SwaggerDescriptorOptions): SwaggerDescriptor;
+    [KIND]: string;
+};
+
+declare class ServerSwaggerProvider {
+    protected readonly serverActionProvider: ServerActionDescriptorProvider;
+    protected readonly serverStaticProvider: ServerStaticProvider;
+    protected readonly serverRouterProvider: ServerRouterProvider;
+    protected readonly alepha: Alepha;
+    protected readonly configure: _alepha_core.HookDescriptor<"configure">;
+    protected configureOpenApi(doc: SwaggerDescriptorOptions): any;
+    isBodyMultipart(schema: TObject): boolean;
+    replacePathParams(url: string): string;
+    getResponseSchema(route: ServerRouteAction): {
+        type?: string;
+        schema?: any;
+        status: number;
+    } | undefined;
+    protected configureSwaggerApi(prefix: string, json: OpenAPIV3.Document): Promise<void>;
+    protected configureSwaggerUi(prefix: string, options: SwaggerDescriptorOptions): Promise<void>;
+}
+
+export { $swagger, ServerSwaggerProvider, type SwaggerDescriptor, type SwaggerDescriptorOptions, type SwaggerUiOptions };