alepha 0.9.2 → 0.9.4

package/server/cache.d.ts

@@ -1,9 +1,9 @@
 import * as _alepha_cache0 from "alepha/cache";
 import { CacheDescriptorOptions } from "alepha/cache";
-import * as _alepha_core0$1 from "alepha";
-import * as _alepha_core0 from "alepha";
+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
@@ -16,26 +16,28 @@ declare module "alepha/server" {
   }
 }
 declare class ServerCacheProvider {
-  protected readonly log: _alepha_core0$1.Logger;
+  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 onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
-  protected readonly onSend: _alepha_core0$1.HookDescriptor<"server:onResponse">;
+  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 onResponse: _alepha_core1.HookDescriptor<"server:onResponse">;
   protected getCacheOptions(cache: ServerRouteCache): {
-    provider?: (_alepha_core0$1.InstantiableClass<_alepha_cache0.CacheProvider> | "memory") | undefined;
+    provider?: (_alepha_core1.InstantiableClass<_alepha_cache0.CacheProvider> | "memory") | undefined;
     name?: string | undefined;
     ttl?: DurationLike | undefined;
     disabled?: boolean | undefined;
   };
-  protected createCacheKey(route: ServerRoute, args?: ServerRequest): string;
+  protected createCacheKey(route: ServerRoute, config?: ServerRequest): string;
 }
 type ServerRouteCache = boolean | DurationLike | Omit<CacheDescriptorOptions<any>, "handler" | "key">;
 interface RouteCacheEntry {
   contentType?: string;
-  body: string;
+  body: any;
   status?: number;
   lastModified: string;
   hash: string;
@@ -70,9 +72,7 @@ interface RouteCacheEntry {
  * @see {@link ServerCacheProvider}
  * @module alepha.server.cache
  */
-declare const AlephaServerCache: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaServerCache: _alepha_core1.Service<_alepha_core1.Module>;
 //#endregion
 export { AlephaServerCache, ServerCacheProvider, ServerRouteCache };
 //# sourceMappingURL=index.d.ts.map

package/server/compress.d.ts

@@ -19,7 +19,6 @@ declare class ServerCompressProvider {
 interface ServerCompressProviderOptions {
   allowedContentTypes: string[];
 }
-//# sourceMappingURL=ServerCompressProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
 /**
@@ -27,9 +26,7 @@ interface ServerCompressProviderOptions {
  *
  * Compresses responses using gzip, brotli, or zstd based on the `Accept-Encoding` header.
  */
-declare const AlephaServerCompress: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaServerCompress: _alepha_core0.Service<_alepha_core0.Module>;
 //#endregion
 export { AlephaServerCompress, ServerCompressProvider, ServerCompressProviderOptions };
 //# sourceMappingURL=index.d.ts.map

package/server/cookies.d.ts

@@ -1,31 +1,40 @@
-import * as _alepha_core0$1 from "alepha";
-import * as _alepha_core0 from "alepha";
+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 const envSchema: _alepha_core0$1.TObject<{
+declare const envSchema: _alepha_core1.TObject<{
   /**
    *  A 32-byte secret key used for cookie encryption and signing. MUST be set for `encrypt` or `sign` to work.
    */
-  COOKIE_SECRET: _alepha_core0$1.TOptional<_alepha_core0$1.TString>;
+  COOKIE_SECRET: _alepha_core1.TOptional<_alepha_core1.TString>;
 }>;
 declare module "alepha" {
   interface Env extends Partial<Static<typeof envSchema>> {}
 }
 declare class ServerCookiesProvider {
   protected readonly alepha: Alepha;
-  protected readonly log: _alepha_core0$1.Logger;
+  protected readonly log: _alepha_logger0.Logger;
   protected readonly env: {
     COOKIE_SECRET?: string | undefined;
   };
+  protected readonly cookieParser: CookieParser;
   protected readonly dateTimeProvider: DateTimeProvider;
   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_core0$1.HookDescriptor<"server:onRequest">;
-  readonly onSend: _alepha_core0$1.HookDescriptor<"server:onSend">;
+  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;
@@ -34,8 +43,6 @@ declare class ServerCookiesProvider {
   protected decrypt(encryptedText: string): string;
   secretKey(): string;
   protected sign(data: string): string;
-  protected parseRequestCookies(header: string): Record<string, string>;
-  protected serializeResponseCookies(cookies: Record<string, Cookie | null>, isHttps: boolean): string[];
 }
 //#endregion
 //#region src/descriptors/$cookie.d.ts
@@ -45,7 +52,7 @@ declare class ServerCookiesProvider {
  * within the server request/response cycle.
  */
 declare const $cookie: {
-  <T extends TSchema>(options: CookieDescriptorOptions<T>): CookieDescriptor<T>;
+  <T extends TSchema>(options: CookieDescriptorOptions<T>): AbstractCookieDescriptor<T>;
   [KIND]: typeof CookieDescriptor;
 };
 interface CookieDescriptorOptions<T extends TSchema> {
@@ -72,18 +79,40 @@ interface CookieDescriptorOptions<T extends TSchema> {
   /** If true, the cookie will be signed to prevent tampering. Requires `COOKIE_SECRET` env var. */
   sign?: boolean;
 }
-declare class CookieDescriptor<T extends TSchema> extends Descriptor<CookieDescriptorOptions<T>> {
+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. */
+  /**
+   * 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. */
+  /**
+   * 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. */
+  /**
+   * Deletes the cookie in the current request's response.
+   */
   del(options?: {
     cookies?: Cookies;
   }): void;
@@ -101,7 +130,6 @@ interface Cookie {
   sameSite?: "strict" | "lax" | "none";
   domain?: string;
 }
-//# sourceMappingURL=$cookie.d.ts.map
 //#endregion
 //#region src/index.d.ts
 declare module "alepha/server" {
@@ -119,9 +147,7 @@ declare module "alepha/server" {
  * @see {@link $cookie}
  * @module alepha.server.cookies
  */
-declare const AlephaServerCookies: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaServerCookies: _alepha_core1.Service<_alepha_core1.Module>;
 //#endregion
-export { $cookie, AlephaServerCookies, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
+export { $cookie, AbstractCookieDescriptor, AlephaServerCookies, Cookie, CookieDescriptor, CookieDescriptorOptions, Cookies, ServerCookiesProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/cors.d.ts

@@ -1,13 +1,12 @@
-import * as _alepha_core0$1 from "alepha";
-import * as _alepha_core0 from "alepha";
+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_core0$1.HookDescriptor<"configure">;
-  protected readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
+  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 {
@@ -17,15 +16,12 @@ interface ServerCorsProviderOptions {
   credentials?: boolean;
   maxAge?: number;
 }
-//# sourceMappingURL=ServerCorsProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
 /**
  * Plugin for configuring CORS on the Alepha server.
  */
-declare const AlephaServerCors: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaServerCors: _alepha_core1.Service<_alepha_core1.Module>;
 //#endregion
 export { AlephaServerCors, ServerCorsProvider, ServerCorsProviderOptions };
 //# sourceMappingURL=index.d.ts.map

package/server/health.d.ts

@@ -22,7 +22,6 @@ declare class ServerHealthProvider {
     }>;
   }>;
 }
-//# sourceMappingURL=ServerHealthProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
 /**
@@ -31,9 +30,7 @@ declare class ServerHealthProvider {
  * @see {@link ServerHealthProvider}
  * @module alepha.server.health
  */
-declare const AlephaServerHealth: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaServerHealth: _alepha_core0.Service<_alepha_core0.Module>;
 //#endregion
 export { AlephaServerHealth, ServerHealthProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/helmet.d.ts

@@ -1,28 +1,29 @@
-import * as _alepha_core0 from "alepha";
-import { Alepha, HookDescriptor } from "alepha";
+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: {
-    "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;
-  };
+  directives: CspDirectives;
 }
 interface HstsOptions {
   maxAge?: number;
@@ -35,7 +36,7 @@ interface HelmetOptions {
   xContentTypeOptions?: false;
   xFrameOptions?: "DENY" | "SAMEORIGIN" | false;
   xXssProtection?: false;
-  contentSecurityPolicy?: CspOptions | 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;
 }
 /**
@@ -49,8 +50,9 @@ declare class ServerHelmetProvider {
    * the application's configuration phase using `alepha.configure()`.
    */
   options: HelmetOptions;
-  private buildHeaders;
-  protected readonly onResponse: HookDescriptor<"server:onResponse">;
+  protected defaultCspDirectives(): CspDirectives;
+  protected buildHeaders(): Record<string, string>;
+  protected readonly onResponse: _alepha_core1.HookDescriptor<"server:onResponse">;
 }
 //#endregion
 //#region src/index.d.ts
@@ -61,9 +63,7 @@ declare class ServerHelmetProvider {
  * @see {@link ServerHelmetProvider}
  * @module alepha.server.helmet
  */
-declare const AlephaServerHelmet: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaServerHelmet: _alepha_core1.Service<_alepha_core1.Module>;
 //#endregion
-export { AlephaServerHelmet, CspOptions, HelmetOptions, HstsOptions, ServerHelmetProvider };
+export { AlephaServerHelmet, CspDirectives, CspOptions, HelmetOptions, HstsOptions, ServerHelmetProvider };
 //# sourceMappingURL=index.d.ts.map

package/server/links.d.ts

@@ -1,33 +1,83 @@
-import * as _alepha_core1 from "alepha";
-import * as _alepha_core0$1 from "alepha";
-import * as _alepha_core0 from "alepha";
-import { Alepha, Descriptor, KIND, Logger } from "alepha";
+import "alepha/server/security";
+import * as _alepha_core2 from "alepha";
+import { Alepha, Descriptor, KIND, Static } from "alepha";
 import * as _alepha_server0 from "alepha/server";
-import { ActionDescriptor, ApiLink, ApiLinksResponse, ClientRequestEntry, ClientRequestOptions, ClientRequestResponse, FetchResponse, HttpClient, RequestConfigSchema, ServerHandler, ServerRequestConfigEntry } from "alepha/server";
+import { ActionDescriptor, ClientRequestEntry, ClientRequestOptions, ClientRequestResponse, FetchResponse, HttpClient, RequestConfigSchema, ServerHandler, ServerRequestConfigEntry, ServerTimingProvider } from "alepha/server";
+import * as _alepha_logger0 from "alepha/logger";
 import * as _alepha_retry0 from "alepha/retry";
 import { ProxyDescriptorOptions, ServerProxyProvider } from "alepha/server/proxy";
 import { ServiceAccountDescriptor, UserAccountToken } from "alepha/security";
-import * as _sinclair_typebox0 from "@sinclair/typebox";
+import * as _sinclair_typebox19 from "@sinclair/typebox";
 
+//#region src/schemas/apiLinksResponseSchema.d.ts
+declare const apiLinkSchema: _sinclair_typebox19.TObject<{
+  name: _sinclair_typebox19.TString;
+  group: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+  path: _sinclair_typebox19.TString;
+  method: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+  requestBodyType: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+  service: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+}>;
+declare const apiLinksResponseSchema: _sinclair_typebox19.TObject<{
+  prefix: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+  links: _sinclair_typebox19.TArray<_sinclair_typebox19.TObject<{
+    name: _sinclair_typebox19.TString;
+    group: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+    path: _sinclair_typebox19.TString;
+    method: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+    requestBodyType: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+    service: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+  }>>;
+}>;
+type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
+type ApiLink = Static<typeof apiLinkSchema>;
+//#endregion
 //#region src/providers/LinkProvider.d.ts
+/**
+ * Browser, SSR friendly, service to handle links.
+ */
 declare class LinkProvider {
-  readonly URL_LINKS = "/api/_links";
-  protected readonly log: Logger;
+  static path: {
+    apiLinks: string;
+    apiSchema: string;
+  };
+  protected readonly log: _alepha_logger0.Logger;
   protected readonly alepha: Alepha;
   protected readonly httpClient: HttpClient;
-  links?: Array<HttpClientLink>;
-  pushLink(link: HttpClientLink): void;
-  getLinks(force?: boolean): Promise<HttpClientLink[]>;
+  protected serverLinks: Array<HttpClientLink>;
+  /**
+   * Get applicative links registered on the server.
+   * This does not include lazy-loaded remote links.
+   */
+  getServerLinks(): HttpClientLink[];
+  /**
+   * Register a new link for the application.
+   */
+  registerLink(link: HttpClientLink): void;
+  get links(): HttpClientLink[];
+  /**
+   * Force browser to refresh links from the server.
+   */
+  fetchLinks(): Promise<HttpClientLink[]>;
+  /**
+   * Create a virtual client that can be used to call actions.
+   *
+   * Use js Proxy under the hood.
+   */
   client<T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
-  protected createVirtualAction<T extends RequestConfigSchema>(name: string, scope?: ClientScope): VirtualAction<T>;
+  /**
+   * Check if a link with the given name exists.
+   * @param name
+   */
+  can(name: string): boolean;
   /**
    * 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 createVirtualAction<T extends RequestConfigSchema>(name: string, scope?: ClientScope): VirtualAction<T>;
   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 {
@@ -41,13 +91,13 @@ interface HttpClientLink extends ApiLink {
 interface ClientScope {
   group?: string;
   service?: string;
+  hostname?: string;
 }
 type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionDescriptor<RequestConfigSchema> ? K : never]: T[K] extends ActionDescriptor<infer Schema> ? VirtualAction<Schema> : never };
 interface VirtualAction<T extends RequestConfigSchema> extends Pick<ActionDescriptor<T>, "name" | "run" | "fetch"> {
   (config?: ClientRequestEntry<T>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T>>;
   can: () => boolean;
 }
-//# sourceMappingURL=LinkProvider.d.ts.map
 //#endregion
 //#region src/descriptors/$client.d.ts
 /**
@@ -57,8 +107,6 @@ declare const $client: {
   <T extends object>(scope?: ClientScope): HttpVirtualClient<T>;
   [KIND]: string;
 };
-//# sourceMappingURL=$client.d.ts.map
-
 //#endregion
 //#region src/descriptors/$remote.d.ts
 /**
@@ -121,83 +169,137 @@ interface RemoteDescriptorOptions {
 declare class RemoteDescriptor extends Descriptor<RemoteDescriptorOptions> {
   get name(): string;
 }
-//# sourceMappingURL=$remote.d.ts.map
 //#endregion
 //#region src/providers/RemoteDescriptorProvider.d.ts
 declare class RemoteDescriptorProvider {
-  static path: {
-    apiLinks: string;
+  protected readonly env: {
+    SERVER_API_PREFIX: string;
   };
   protected readonly alepha: Alepha;
-  protected readonly client: LinkProvider;
   protected readonly proxyProvider: ServerProxyProvider;
+  protected readonly linkProvider: LinkProvider;
   protected readonly remotes: Array<ServerRemote>;
-  protected readonly log: Logger;
+  protected readonly log: _alepha_logger0.Logger;
   getRemotes(): ServerRemote[];
-  readonly configure: _alepha_core1.HookDescriptor<"configure">;
-  readonly start: _alepha_core1.HookDescriptor<"start">;
+  readonly configure: _alepha_core2.HookDescriptor<"configure">;
+  readonly start: _alepha_core2.HookDescriptor<"start">;
   registerRemote(value: RemoteDescriptor): Promise<void>;
   protected readonly fetchLinks: _alepha_retry0.RetryDescriptorFn<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
 }
 interface FetchLinksOptions {
+  /**
+   * Name of the remote service.
+   */
   service: string;
+  /**
+   * URL to fetch links from.
+   */
   url: string;
+  /**
+   * Authorization header containing access token.
+   */
   authorization?: string;
 }
 interface ServerRemote {
+  /**
+   * URL of the remote service.
+   */
   url: string;
+  /**
+   * Name of the remote service.
+   */
   name: string;
+  /**
+   * Expose links as endpoint. It's not only internal.
+   */
   proxy: boolean;
+  /**
+   * It's only used inside the application.
+   */
   internal: boolean;
+  /**
+   * Links fetcher.
+   */
   links: (args: {
     authorization?: string;
   }) => Promise<ApiLinksResponse>;
+  /**
+   * Fetches schema for the remote service.
+   */
   schema: (args: {
     name: string;
     authorization?: string;
   }) => Promise<any>;
+  /**
+   * Force a default access token provider when not provided.
+   */
   serviceAccount?: ServiceAccountDescriptor;
+  /**
+   * Prefix for the remote service links.
+   */
   prefix: string;
 }
-//# sourceMappingURL=RemoteDescriptorProvider.d.ts.map
 //#endregion
 //#region src/providers/ServerLinksProvider.d.ts
 declare class ServerLinksProvider {
+  protected readonly env: {
+    SERVER_API_PREFIX: string;
+  };
   protected readonly alepha: Alepha;
-  protected readonly client: LinkProvider;
+  protected readonly linkProvider: LinkProvider;
   protected readonly remoteProvider: RemoteDescriptorProvider;
-  readonly onRoute: _alepha_core0$1.HookDescriptor<"configure">;
+  protected readonly serverTimingProvider: ServerTimingProvider;
+  get prefix(): string;
+  readonly onRoute: _alepha_core2.HookDescriptor<"configure">;
+  /**
+   * First API - Get all API links for the user.
+   *
+   * This is based on the user's permissions.
+   */
   readonly links: _alepha_server0.RouteDescriptor<{
-    response: _sinclair_typebox0.TObject<{
-      prefix: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
-      links: _sinclair_typebox0.TArray<_sinclair_typebox0.TObject<{
-        name: _sinclair_typebox0.TString;
-        path: _sinclair_typebox0.TString;
-        method: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
-        group: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
-        requestBodyType: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
-        service: _sinclair_typebox0.TOptional<_sinclair_typebox0.TString>;
+    response: _sinclair_typebox19.TObject<{
+      prefix: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+      links: _sinclair_typebox19.TArray<_sinclair_typebox19.TObject<{
+        name: _sinclair_typebox19.TString;
+        group: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+        path: _sinclair_typebox19.TString;
+        method: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+        requestBodyType: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
+        service: _sinclair_typebox19.TOptional<_sinclair_typebox19.TString>;
       }>>;
     }>;
   }>;
+  /**
+   * Second API - Get schema for a specific API link.
+   *
+   * Note: Body/Response schema are not included in `links` API because it's TOO BIG.
+   * I mean for 150+ links, you got 50ms of serialization time.
+   */
   readonly schema: _alepha_server0.RouteDescriptor<{
-    params: _sinclair_typebox0.TObject<{
-      name: _sinclair_typebox0.TString;
+    params: _sinclair_typebox19.TObject<{
+      name: _sinclair_typebox19.TString;
     }>;
-    response: _sinclair_typebox0.TRecord<_sinclair_typebox0.TString, _sinclair_typebox0.TAny>;
+    response: _sinclair_typebox19.TRecord<_sinclair_typebox19.TString, _sinclair_typebox19.TAny>;
   }>;
-  getLinks(options: GetLinksOptions): Promise<ApiLinksResponse>;
+  getSchemaByName(name: string, options?: GetApiLinksOptions): Promise<RequestConfigSchema>;
+  /**
+   * Retrieves API links for the user based on their permissions.
+   * Will check on local links and remote links.
+   */
+  getUserApiLinks(options: GetApiLinksOptions): Promise<ApiLinksResponse>;
 }
-interface GetLinksOptions {
+interface GetApiLinksOptions {
   user?: UserAccountToken;
   authorization?: string;
 }
-//# sourceMappingURL=ServerLinksProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
-declare const AlephaServerLinks: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare module "alepha" {
+  interface State {
+    api?: ApiLinksResponse;
+  }
+}
+declare const AlephaServerLinks: _alepha_core2.Service<_alepha_core2.Module>;
 //#endregion
-export { $client, $remote, AlephaServerLinks, ClientScope, FetchLinksOptions, GetLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider, ServerRemote, VirtualAction };
+export { $client, $remote, AlephaServerLinks, ApiLink, ApiLinksResponse, ClientScope, FetchLinksOptions, GetApiLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider, ServerRemote, VirtualAction, apiLinkSchema, apiLinksResponseSchema };
 //# sourceMappingURL=index.d.ts.map

package/server/metrics.d.ts

@@ -1,5 +1,4 @@
-import * as _alepha_core0$1 from "alepha";
-import * as _alepha_core0 from "alepha";
+import * as _alepha_core1 from "alepha";
 import { Alepha } from "alepha";
 import * as _alepha_server0 from "alepha/server";
 import { Histogram, Registry } from "prom-client";
@@ -11,9 +10,9 @@ declare class ServerMetricsProvider {
   protected httpRequestDuration?: Histogram<string>;
   readonly options: ServerMetricsProviderOptions;
   readonly metrics: _alepha_server0.RouteDescriptor<_alepha_server0.RequestConfigSchema>;
-  protected readonly onStart: _alepha_core0$1.HookDescriptor<"start">;
-  protected readonly onRequest: _alepha_core0$1.HookDescriptor<"server:onRequest">;
-  protected readonly onResponse: _alepha_core0$1.HookDescriptor<"server:onResponse">;
+  protected readonly onStart: _alepha_core1.HookDescriptor<"start">;
+  protected readonly onRequest: _alepha_core1.HookDescriptor<"server:onRequest">;
+  protected readonly onResponse: _alepha_core1.HookDescriptor<"server:onResponse">;
 }
 interface ServerMetricsProviderOptions {
   prefix?: string;
@@ -21,7 +20,6 @@ interface ServerMetricsProviderOptions {
   eventLoopMonitoringPrecision?: number;
   labels?: object;
 }
-//# sourceMappingURL=ServerMetricsProvider.d.ts.map
 //#endregion
 //#region src/index.d.ts
 /**
@@ -31,9 +29,7 @@ interface ServerMetricsProviderOptions {
  * @see {@link ServerMetricsProvider}
  * @module alepha.server.metrics
  */
-declare const AlephaServerMetrics: _alepha_core0.ModuleDescriptor;
-//# sourceMappingURL=index.d.ts.map
-
+declare const AlephaServerMetrics: _alepha_core1.Service<_alepha_core1.Module>;
 //#endregion
 export { AlephaServerMetrics, ServerMetricsProvider, ServerMetricsProviderOptions };
 //# sourceMappingURL=index.d.ts.map