alepha 0.7.6 → 0.8.0

package/server/links.d.ts

@@ -0,0 +1,179 @@
+import { Alepha, HookDescriptor, KIND, Logger, Module, OPTIONS, TAny, TArray, TObject, TOptional, TRecord, TString } from "alepha";
+import { ActionDescriptor, ActionDescriptorHelper, ApiLink, ApiLinksResponse, ClientRequestOptions, FetchResponse, HttpClient, RequestConfigSchema, RouteDescriptor, ServerActionDescriptorProvider, ServerHandler, ServerRemote, ServerRequestConfigEntry } from "alepha/server";
+import { RetryDescriptor } from "alepha/retry";
+import { ProxyDescriptorOptions, ProxyDescriptorProvider } from "alepha/server/proxy";
+import { ServiceAccountDescriptor, UserAccountToken } from "alepha/security";
+
+//#region src/providers/LinkProvider.d.ts
+declare class LinkProvider {
+  readonly URL_LINKS = "/api/_links";
+  protected readonly log: Logger;
+  protected readonly alepha: Alepha;
+  protected readonly httpClient: HttpClient;
+  links?: Array<HttpClientLink>;
+  pushLink(link: HttpClientLink): void;
+  getLinks(force?: boolean): Promise<HttpClientLink[]>;
+  client<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
+  /**
+  * Resolve a link by its name and call it.
+  * - If link is local, it will call the local handler.
+  * - If link is remote, it will make a fetch request to the remote server.
+  */
+  follow(name: string, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions & ClientScope): Promise<any>;
+  protected followRemote(link: HttpClientLink, config?: Partial<ServerRequestConfigEntry>, options?: ClientRequestOptions): Promise<FetchResponse>;
+  can(name: string): boolean;
+  protected getLinkByName(name: string, options?: ClientScope): Promise<HttpClientLink>;
+}
+// ---------------------------------------------------------------------------------------------------------------------
+interface HttpClientLink extends ApiLink {
+  secured?: boolean;
+  prefix?: string;
+  // -- server only --
+  // only for remote actions
+  host?: string;
+  service?: string;
+  // used only for local actions, not for remote actions
+  schema?: RequestConfigSchema;
+  handler?: ServerHandler;
+}
+interface ClientScope {
+  group?: string;
+  service?: string;
+}
+type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? T[K] & {
+  can: () => boolean;
+  schema: Schema;
+} : never };
+//#endregion
+//#region src/descriptors/$client.d.ts
+declare const $client: <T extends object>(scope?: ClientScope) => HttpVirtualClient<T>;
+//#endregion
+//#region src/descriptors/$remote.d.ts
+declare const KEY = "REMOTE";
+interface RemoteDescriptorOptions {
+  /**
+  * The URL of the remote service.
+  * You can use a function to generate the URL dynamically.
+  * You probably should use $inject(env) to get the URL from the environment.
+  *
+  * @example
+  * ```ts
+  * import { $remote } from "alepha/server";
+  * import { $inject, t } from "alepha";
+  *
+  * class App {
+  *   env = $inject(t.object({
+  *     REMOTE_URL: t.string({default: "http://localhost:3000"}),
+  *   }));
+  *   remote = $remote({
+  *     url: this.env.REMOTE_URL,
+  *   });
+  * }
+  * ```
+  */
+  url: string | (() => string);
+  /**
+  * The name of the remote service.
+  *
+  * @default Member of the class containing the remote service.
+  */
+  name?: string;
+  /**
+  * If true, all methods of the remote service will be exposed as actions in this context.
+  * > Note: Proxy will never use the service account, it just... proxies the request.
+  */
+  proxy?: boolean | Partial<ProxyDescriptorOptions & {
+    /**
+    * If true, the remote service won't be available internally, only through the proxy.
+    */
+    noInternal: boolean;
+  }>;
+  /**
+  * For communication between the server and the remote service with a security layer.
+  * This will be used for internal communication and will not be exposed to the client.
+  */
+  serviceAccount?: ServiceAccountDescriptor;
+}
+interface RemoteDescriptor {
+  [KIND]: typeof KEY;
+  [OPTIONS]: RemoteDescriptorOptions;
+}
+/**
+* $remote is a descriptor that allows you to define a remote service access.
+*
+* Use it only when you have 2 or more services that need to communicate with each other.
+*
+* All remote services can be exposed as actions, ... or not.
+*
+* You can add a service account if you want to use a security layer.
+*/
+declare const $remote: {
+  (options: RemoteDescriptorOptions): RemoteDescriptor;
+  [KIND]: string;
+};
+//#endregion
+//#region src/providers/RemoteDescriptorProvider.d.ts
+declare class RemoteDescriptorProvider {
+  static path: {
+    apiLinks: string;
+  };
+  protected readonly alepha: Alepha;
+  protected readonly client: LinkProvider;
+  protected readonly proxyProvider: ProxyDescriptorProvider;
+  protected readonly remotes: Array<ServerRemote>;
+  protected readonly log: Logger;
+  getRemotes(): ServerRemote[];
+  readonly configure: HookDescriptor<"configure">;
+  readonly start: HookDescriptor<"start">;
+  registerRemote(value: RemoteDescriptor, key: string): Promise<void>;
+  protected readonly fetchLinks: RetryDescriptor<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
+}
+interface FetchLinksOptions {
+  service: string;
+  url: string;
+  authorization?: string;
+}
+//#endregion
+//#region src/providers/ServerLinksProvider.d.ts
+declare class ServerLinksProvider {
+  protected readonly alepha: Alepha;
+  protected readonly client: LinkProvider;
+  protected readonly helper: ActionDescriptorHelper;
+  protected readonly remoteProvider: RemoteDescriptorProvider;
+  protected readonly serverActionDescriptorProvider: ServerActionDescriptorProvider;
+  readonly onRoute: HookDescriptor<"server:onRoute">;
+  readonly links: RouteDescriptor<{
+    response: TObject<{
+      prefix: TOptional<TString>;
+      links: TArray<TObject<{
+        name: TString;
+        path: TString;
+        method: TOptional<TString>;
+        group: TOptional<TString>;
+        requestBodyType: TOptional<TString>;
+        service: TOptional<TString>;
+      }>>;
+    }>;
+  }>;
+  readonly schema: RouteDescriptor<{
+    params: TObject<{
+      name: TString;
+    }>;
+    response: TRecord<TString, TAny>;
+  }>;
+  getLinks(options: GetLinksOptions): Promise<ApiLinksResponse>;
+}
+interface GetLinksOptions {
+  user?: UserAccountToken;
+  authorization?: string;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+declare class AlephaServerLinks implements Module {
+  readonly name = "alepha.server.links";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { $client, $remote, AlephaServerLinks, ClientScope, FetchLinksOptions, GetLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/links.js

@@ -0,0 +1 @@
+export * from '@alepha/server-links'

package/server/metrics.cjs

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

package/server/metrics.d.ts

@@ -0,0 +1,37 @@
+import { RouteDescriptor } from "alepha/server";
+import { Alepha, HookDescriptor, Module } from "alepha";
+import { Registry } from "prom-client";
+
+//#region src/providers/ServerMetricsProvider.d.ts
+interface ServerMetricsProviderOptions {
+  prefix?: string;
+  gcDurationBuckets?: number[];
+  eventLoopMonitoringPrecision?: number;
+  labels?: object;
+}
+declare class ServerMetricsProvider {
+  protected readonly register: Registry;
+  protected readonly alepha: Alepha;
+  readonly options: ServerMetricsProviderOptions;
+  readonly metrics: RouteDescriptor;
+  protected readonly onStart: HookDescriptor<"start">;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Server Metrics Module
+*
+* This module provides prometheus metrics for the Alepha server.
+* Metrics are exposed at the `/metrics` endpoint.
+*
+* @see {@link ServerMetricsProvider}
+* @module alepha.server.metrics
+*/
+declare class AlephaServerMetrics implements Module {
+  readonly name = "alepha.server.metrics";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerMetrics, ServerMetricsProvider, ServerMetricsProviderOptions };
+//# sourceMappingURL=index.d.ts.map

package/server/metrics.js

@@ -0,0 +1 @@
+export * from '@alepha/server-metrics'

package/server/multipart.cjs

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

package/server/multipart.d.ts

@@ -0,0 +1,48 @@
+import { ActionDescriptorHelper, ServerRoute } from "alepha/server";
+import { Alepha, FileLike, HookDescriptor, Module } from "alepha";
+import { BusboyConfig } from "@fastify/busboy";
+import { IncomingMessage } from "node:http";
+
+//#region src/providers/ServerMultipartProvider.d.ts
+declare class ServerMultipartProvider {
+  protected readonly helper: ActionDescriptorHelper;
+  protected readonly alepha: Alepha;
+  readonly onRequest: HookDescriptor<"server:onRequest">;
+  readonly onSend: HookDescriptor<"server:onResponse">;
+  handleMultipartBodyFromNode(route: ServerRoute, stream: IncomingMessage): Promise<{
+    body: Record<string, any>;
+    cleanup: () => Promise<void>;
+  }>;
+  parseMultipart(req: IncomingMessage, config?: Omit<BusboyConfig, "headers">): Promise<MultipartResult>;
+}
+interface MultipartResult {
+  fields: Record<string, string | string[]>;
+  files: Record<string, HybridFile>;
+}
+interface HybridFile extends FileLike {
+  cleanup(): Promise<void>;
+  _state: {
+    cleanup: boolean;
+    size: number;
+    tmpPath: string;
+  };
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Server Multipart Module
+*
+* This module provides support for handling multipart/form-data requests.
+* It allows to parse body data containing t.file().
+*
+* @see {@link ServerMultipartProvider}
+* @module alepha.server.multipart
+*/
+declare class AlephaServerMultipart implements Module {
+  readonly name = "alepha.server.multipart";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { AlephaServerMultipart, ServerMultipartProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/multipart.js

@@ -0,0 +1 @@
+export * from '@alepha/server-multipart'

package/server/proxy.cjs

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

package/server/proxy.d.ts

@@ -0,0 +1,41 @@
+import { Alepha, Async, HookDescriptor, KIND, Logger, Module, OPTIONS } from "alepha";
+import { ServerHandler, ServerRequest, ServerRouterProvider } from "alepha/server";
+
+//#region src/descriptors/$proxy.d.ts
+type ProxyDescriptorOptions = {
+  path: string;
+  target: string | (() => string);
+  disabled?: boolean;
+  beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
+  afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
+  rewrite?: (url: URL) => void;
+};
+interface ProxyDescriptor {
+  [KIND]: "PROXY";
+  [OPTIONS]: ProxyDescriptorOptions;
+}
+declare const $proxy: {
+  (options: ProxyDescriptorOptions): ProxyDescriptor;
+  [KIND]: string;
+};
+//#endregion
+//#region src/providers/ProxyDescriptorProvider.d.ts
+declare class ProxyDescriptorProvider {
+  protected readonly log: Logger;
+  protected readonly routerProvider: ServerRouterProvider;
+  protected readonly alepha: Alepha;
+  readonly configure: HookDescriptor<"configure">;
+  createProxyHandler(target: string, options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
+  proxy(options: ProxyDescriptorOptions): Promise<void>;
+  private getRawRequestBody;
+}
+//#endregion
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+declare class AlephaServerProxy implements Module {
+  readonly name = "alepha.server.proxy";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { $proxy, AlephaServerProxy, ProxyDescriptor, ProxyDescriptorOptions, ProxyDescriptorProvider };
+//# sourceMappingURL=index.d.ts.map

package/server/proxy.js

@@ -0,0 +1 @@
+export * from '@alepha/server-proxy'

package/server/static.d.ts

@@ -1,78 +1,77 @@
-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";
+import { Alepha, HookDescriptor, KIND, Logger, OPTIONS } from "alepha";
+import { ServerHandler, ServerRouterProvider } from "alepha/server";
+import { DateTimeProvider, DurationLike } from "alepha/datetime";
 
 //#region src/descriptors/$serve.d.ts
 declare const KEY = "SERVE";
 interface ServeDescriptorOptions {
   /**
-   * Prefix for the served path.
-   *
-   * @default "/"
-   */
+  * Prefix for the served path.
+  *
+  * @default "/"
+  */
   path?: string;
   /**
-   * Path to the directory to serve.
-   *
-   * @default process.cwd()
-   */
+  * Path to the directory to serve.
+  *
+  * @default process.cwd()
+  */
   root?: string;
   /**
-   * If true, descriptor will be ignored.
-   *
-   * @default false
-   */
+  * 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
-   */
+  * 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
-   */
+  * 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.
-   */
+  * 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.
-   */
+  * 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 {}
-   */
+  * Whether to use cache control headers.
+  *
+  * @default {}
+  */
   cacheControl?: Partial<CacheControlOptions> | false;
 }
 interface CacheControlOptions {
   /**
-   * Whether to use cache control headers.
-   *
-   * @default [.js, .css]
-   */
+  * 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
-   */
+  * 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
-   */
+  * Whether to use immutable cache control headers.
+  *
+  * @default true
+  */
   immutable: boolean;
 }
 interface ServeDescriptor {
@@ -90,9 +89,9 @@ declare class ServerStaticProvider {
   protected readonly alepha: Alepha;
   protected readonly routerProvider: ServerRouterProvider;
   protected readonly dateTimeProvider: DateTimeProvider;
-  protected readonly log: _alepha_core0.Logger;
+  protected readonly log: Logger;
   protected readonly directories: ServeDirectory[];
-  protected readonly configure: _alepha_core0.HookDescriptor<"configure">;
+  protected readonly configure: HookDescriptor<"configure">;
   list(name: string): string[];
   serve(options: ServeDescriptorOptions): Promise<void>;
   createFileHandler(filepath: string, options: ServeDescriptorOptions): Promise<ServerHandler>;
@@ -108,5 +107,18 @@ interface ServeDirectory {
   files: string[];
 }
 //#endregion
-export { $serve, CacheControlOptions, ServeDescriptor, ServeDescriptorOptions, ServeDirectory, ServerStaticProvider };
+//#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
+/**
+* Alepha Server Static Module
+*
+* @see {@link ServerStaticProvider}
+* @module alepha.server.static
+*/
+declare class AlephaServerStatic {
+  readonly name = "alepha.server.static";
+  readonly $services: (alepha: Alepha) => void;
+}
+//#endregion
+export { $serve, AlephaServerStatic, CacheControlOptions, ServeDescriptor, ServeDescriptorOptions, ServeDirectory, ServerStaticProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/swagger.d.ts

@@ -1,19 +1,18 @@
-import * as _alepha_core0 from "@alepha/core";
-import { Alepha, KIND, Module, OPTIONS, TObject } from "@alepha/core";
-import { ServerActionDescriptorProvider, ServerRouteAction, ServerRouterProvider } from "@alepha/server";
-import { ServerStaticProvider } from "@alepha/server-static";
+import { Alepha, HookDescriptor, KIND, Module, OPTIONS, TObject } from "alepha";
+import { ServerActionDescriptorProvider, ServerRouteAction, ServerRouterProvider } from "alepha/server";
+import { ServerStaticProvider } from "alepha/server/static";
 import { OpenAPIV3 } from "openapi-types";
 
 //#region src/descriptors/$swagger.d.ts
 interface SwaggerDescriptorOptions {
   info: OpenAPIV3.InfoObject;
   /**
-   * @default: "/docs"
-   */
+  * @default: "/docs"
+  */
   prefix?: string;
   /**
-   * If true, docs will be disabled.
-   */
+  * If true, docs will be disabled.
+  */
   disabled?: boolean;
   excludeTags?: string[];
   ui?: boolean | SwaggerUiOptions;
@@ -23,53 +22,53 @@ interface SwaggerUiOptions {
   root?: string;
   initOAuth?: {
     /**
-     * Default clientId.
-     */
+    * Default clientId.
+    */
     clientId?: string;
     /**
-     * realm query parameter (for oauth1) added to authorizationUrl and tokenUrl.
-     */
+    * realm query parameter (for oauth1) added to authorizationUrl and tokenUrl.
+    */
     realm?: string;
     /**
-     * application name, displayed in authorization popup.
-     */
+    * 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 ' '
-     */
+    * 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 []
-     */
+    * 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
-     */
+    * 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
-     */
+    * 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
-     */
+    * Only applies to Authorization Code flows. Proof Key for Code Exchange
+    * brings enhanced security for OAuth public clients.
+    *
+    * @default false
+    */
     usePkceWithAuthorizationCodeGrant?: boolean;
   };
 }
@@ -89,8 +88,8 @@ declare class ServerSwaggerProvider {
   protected readonly serverStaticProvider: ServerStaticProvider;
   protected readonly serverRouterProvider: ServerRouterProvider;
   protected readonly alepha: Alepha;
-  protected readonly configure: _alepha_core0.HookDescriptor<"configure">;
-  protected configureOpenApi(doc: SwaggerDescriptorOptions): any;
+  protected readonly configure: HookDescriptor<"configure">;
+  protected configureOpenApi(doc: SwaggerDescriptorOptions): OpenAPIV3.Document;
   isBodyMultipart(schema: TObject): boolean;
   replacePathParams(url: string): string;
   getResponseSchema(route: ServerRouteAction): {
@@ -103,16 +102,17 @@ declare class ServerSwaggerProvider {
 }
 //#endregion
 //#region src/index.d.ts
+// ---------------------------------------------------------------------------------------------------------------------
 /**
- * Alepha Server Swagger Module
- *
- * Plugin for Alepha Server that provides Swagger documentation capabilities.
- * It generates OpenAPI v3 documentation for the server's endpoints ($action).
- * It also provides a Swagger UI for interactive API documentation.
- *
- * @see {@link ServerSwaggerProvider}
- * @module alepha.server.swagger
- */
+* Alepha Server Swagger Module
+*
+* Plugin for Alepha Server that provides Swagger documentation capabilities.
+* It generates OpenAPI v3 documentation for the server's endpoints ($action).
+* It also provides a Swagger UI for interactive API documentation.
+*
+* @see {@link ServerSwaggerProvider}
+* @module alepha.server.swagger
+*/
 declare class AlephaServerSwagger implements Module {
   readonly name = "alepha.server.swagger";
   readonly $services: (alepha: Alepha) => Alepha;