alepha 0.13.0 → 0.13.2

package/dist/server-links/index.d.ts

@@ -1,94 +1,31 @@
-import * as alepha23 from "alepha";
-import { Alepha, Async, Descriptor, KIND, Static } from "alepha";
-import { JwtProvider, SecurityProvider, ServiceAccountDescriptor, UserAccount, UserAccountToken } from "alepha/security";
+import { ServerRouteSecure } from "alepha/server/security";
+import * as alepha1 from "alepha";
+import { Alepha, Async, KIND, Primitive, Static } from "alepha";
 import * as alepha_server0 from "alepha/server";
-import { ActionDescriptor, ClientRequestEntry, ClientRequestOptions, ClientRequestResponse, FetchOptions, FetchResponse, HttpClient, RequestConfigSchema, ServerHandler, ServerRequest, ServerRequestConfigEntry, ServerResponseBody, ServerRouterProvider, ServerTimingProvider } from "alepha/server";
+import { ActionPrimitive, ClientRequestEntry, ClientRequestOptions, ClientRequestResponse, FetchResponse, HttpClient, RequestConfigSchema, ServerRequest, ServerRequestConfigEntry, ServerResponseBody, ServerTimingProvider } from "alepha/server";
 import * as alepha_logger0 from "alepha/logger";
 import * as alepha_retry0 from "alepha/retry";
+import { ProxyPrimitiveOptions, ServerProxyProvider } from "alepha/server/proxy";
+import { ServiceAccountPrimitive, UserAccountToken } from "alepha/security";
 
-//#region src/server-security/providers/ServerBasicAuthProvider.d.ts
-interface BasicAuthOptions {
-  username: string;
-  password: string;
-}
-//#endregion
-//#region src/server-security/providers/ServerSecurityProvider.d.ts
-
-type ServerRouteSecure = {
-  realm?: string;
-  basic?: BasicAuthOptions;
-};
-//#endregion
-//#region src/server-security/index.d.ts
-declare module "alepha" {
-  interface State {
-    /**
-     * Real (or fake) user account, used for internal actions.
-     *
-     * If you define this, you assume that all actions are executed by this user by default.
-     * > To force a different user, you need to pass it explicitly in the options.
-     */
-    "alepha.server.security.system.user"?: UserAccountToken;
-    /**
-     * The authenticated user account attached to the server request state.
-     *
-     * @internal
-     */
-    "alepha.server.request.user"?: UserAccount;
-  }
-}
-declare module "alepha/server" {
-  interface ServerRequest<TConfig> {
-    user?: UserAccountToken;
-  }
-  interface ServerActionRequest<TConfig> {
-    user: UserAccountToken;
-  }
-  interface ServerRoute {
-    /**
-     * If true, the route will be protected by the security provider.
-     * All actions are secure by default, but you can disable it for specific actions.
-     */
-    secure?: boolean | ServerRouteSecure;
-  }
-  interface ClientRequestOptions extends FetchOptions {
-    /**
-     * Forward user from the previous request.
-     * If "system", use system user. @see {ServerSecurityProvider.localSystemUser}
-     * If "context", use the user from the current context (e.g. request).
-     *
-     * @default "system" if provided, else "context" if available.
-     */
-    user?: UserAccountToken | "system" | "context";
-  }
-}
-/**
- * Plugin for Alepha Server that provides security features. Based on the Alepha Security module.
- *
- * By default, all $action will be guarded by a permission check.
- *
- * @see {@link ServerSecurityProvider}
- * @module alepha.server.security
- */
-//#endregion
 //#region src/server-links/schemas/apiLinksResponseSchema.d.ts
-declare const apiLinkSchema: alepha23.TObject<{
-  name: alepha23.TString;
-  group: alepha23.TOptional<alepha23.TString>;
-  path: alepha23.TString;
-  method: alepha23.TOptional<alepha23.TString>;
-  requestBodyType: alepha23.TOptional<alepha23.TString>;
-  service: alepha23.TOptional<alepha23.TString>;
+declare const apiLinkSchema: alepha1.TObject<{
+  name: alepha1.TString;
+  group: alepha1.TOptional<alepha1.TString>;
+  path: alepha1.TString;
+  method: alepha1.TOptional<alepha1.TString>;
+  requestBodyType: alepha1.TOptional<alepha1.TString>;
+  service: alepha1.TOptional<alepha1.TString>;
 }>;
-declare const apiLinksResponseSchema: alepha23.TObject<{
-  prefix: alepha23.TOptional<alepha23.TString>;
-  links: alepha23.TArray<alepha23.TObject<{
-    name: alepha23.TString;
-    group: alepha23.TOptional<alepha23.TString>;
-    path: alepha23.TString;
-    method: alepha23.TOptional<alepha23.TString>;
-    requestBodyType: alepha23.TOptional<alepha23.TString>;
-    service: alepha23.TOptional<alepha23.TString>;
+declare const apiLinksResponseSchema: alepha1.TObject<{
+  prefix: alepha1.TOptional<alepha1.TString>;
+  links: alepha1.TArray<alepha1.TObject<{
+    name: alepha1.TString;
+    group: alepha1.TOptional<alepha1.TString>;
+    path: alepha1.TString;
+    method: alepha1.TOptional<alepha1.TString>;
+    requestBodyType: alepha1.TOptional<alepha1.TString>;
+    service: alepha1.TOptional<alepha1.TString>;
   }>>;
 }>;
 type ApiLinksResponse = Static<typeof apiLinksResponseSchema>;
@@ -155,13 +92,13 @@ interface ClientScope {
   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"> {
+type HttpVirtualClient<T> = { [K in keyof T as T[K] extends ActionPrimitive<RequestConfigSchema> ? K : never]: T[K] extends ActionPrimitive<infer Schema> ? VirtualAction<Schema> : never };
+interface VirtualAction<T extends RequestConfigSchema> extends Pick<ActionPrimitive<T>, "name" | "run" | "fetch"> {
   (config?: ClientRequestEntry<T>, opts?: ClientRequestOptions): Promise<ClientRequestResponse<T>>;
   can: () => boolean;
 }
 //#endregion
-//#region src/server-links/descriptors/$client.d.ts
+//#region src/server-links/primitives/$client.d.ts
 /**
  * Create a new client.
  */
@@ -170,138 +107,9 @@ declare const $client: {
   [KIND]: string;
 };
 //#endregion
-//#region src/server-proxy/descriptors/$proxy.d.ts
-type ProxyDescriptorOptions = {
-  /**
-   * Path pattern to match for proxying requests.
-   *
-   * Supports wildcards and path parameters:
-   * - `/api/*` - Matches all paths starting with `/api/`
-   * - `/api/v1/*` - Matches all paths starting with `/api/v1/`
-   * - `/users/:id` - Matches `/users/123`, `/users/abc`, etc.
-   *
-   * @example "/api/*"
-   * @example "/secure/admin/*"
-   * @example "/users/:id/posts"
-   */
-  path: string;
-  /**
-   * Target URL to which matching requests should be forwarded.
-   *
-   * Can be either:
-   * - **Static string**: A fixed URL like `"https://api.example.com"`
-   * - **Dynamic function**: A function that returns the URL, enabling runtime target resolution
-   *
-   * The target URL will be combined with the remaining path from the original request.
-   *
-   * @example "https://api.example.com"
-   * @example () => process.env.API_URL || "http://localhost:3001"
-   */
-  target: string | (() => string);
-  /**
-   * Whether this proxy is disabled.
-   *
-   * When `true`, requests matching the path will not be proxied and will be handled
-   * by other routes or return 404. Useful for feature toggles or conditional proxying.
-   *
-   * @default false
-   * @example !process.env.ENABLE_PROXY
-   */
-  disabled?: boolean;
-  /**
-   * Hook called before forwarding the request to the target server.
-   *
-   * Use this to:
-   * - Add authentication headers
-   * - Modify request headers or body
-   * - Add request tracking/logging
-   * - Transform the request before forwarding
-   *
-   * @param request - The original incoming server request
-   * @param proxyRequest - The request that will be sent to the target (modifiable)
-   *
-   * @example
-   * ```ts
-   * beforeRequest: async (request, proxyRequest) => {
-   *   proxyRequest.headers = {
-   *     ...proxyRequest.headers,
-   *     'Authorization': `Bearer ${await getToken()}`,
-   *     'X-Request-ID': generateRequestId()
-   *   };
-   * }
-   * ```
-   */
-  beforeRequest?: (request: ServerRequest, proxyRequest: RequestInit) => Async<void>;
-  /**
-   * Hook called after receiving the response from the target server.
-   *
-   * Use this to:
-   * - Log response details for monitoring
-   * - Add custom headers to the response
-   * - Transform response data
-   * - Handle error responses
-   *
-   * @param request - The original incoming server request
-   * @param proxyResponse - The response received from the target server
-   *
-   * @example
-   * ```ts
-   * afterResponse: async (request, proxyResponse) => {
-   *   console.log(`Proxy ${request.method} ${request.url} -> ${proxyResponse.status}`);
-   *
-   *   if (!proxyResponse.ok) {
-   *     await logError(`Proxy error: ${proxyResponse.status}`, { request, response: proxyResponse });
-   *   }
-   * }
-   * ```
-   */
-  afterResponse?: (request: ServerRequest, proxyResponse: Response) => Async<void>;
-  /**
-   * Function to rewrite the URL before sending to the target server.
-   *
-   * Use this to:
-   * - Remove or add path prefixes
-   * - Transform path parameters
-   * - Modify query parameters
-   * - Change the URL structure entirely
-   *
-   * The function receives a mutable URL object and should modify it in-place.
-   *
-   * @param url - The URL object to modify (mutable)
-   *
-   * @example
-   * ```ts
-   * // Remove /api prefix when forwarding
-   * rewrite: (url) => {
-   *   url.pathname = url.pathname.replace('/api', '');
-   * }
-   * ```
-   *
-   * @example
-   * ```ts
-   * // Add version prefix
-   * rewrite: (url) => {
-   *   url.pathname = `/v2${url.pathname}`;
-   * }
-   * ```
-   */
-  rewrite?: (url: URL) => void;
-};
-//#endregion
-//#region src/server-proxy/providers/ServerProxyProvider.d.ts
-declare class ServerProxyProvider {
-  protected readonly log: alepha_logger0.Logger;
-  protected readonly routerProvider: ServerRouterProvider;
-  protected readonly alepha: Alepha;
-  protected readonly configure: alepha23.HookDescriptor<"configure">;
-  createProxy(options: ProxyDescriptorOptions): void;
-  createProxyHandler(target: string, options: Omit<ProxyDescriptorOptions, "path">): ServerHandler;
-  private getRawRequestBody;
-}
-//#endregion
-//#region src/server-links/descriptors/$remote.d.ts
+//#region src/server-links/primitives/$remote.d.ts
 /**
- * $remote is a descriptor that allows you to define remote service access.
+ * $remote is a primitive that allows you to define remote service access.
  *
  * Use it only when you have 2 or more services that need to communicate with each other.
  *
@@ -310,10 +118,10 @@ declare class ServerProxyProvider {
  * You can add a service account if you want to use a security layer.
  */
 declare const $remote: {
-  (options: RemoteDescriptorOptions): RemoteDescriptor;
-  [KIND]: typeof RemoteDescriptor;
+  (options: RemotePrimitiveOptions): RemotePrimitive;
+  [KIND]: typeof RemotePrimitive;
 };
-interface RemoteDescriptorOptions {
+interface RemotePrimitiveOptions {
   /**
    * The URL of the remote service.
    * You can use a function to generate the URL dynamically.
@@ -345,7 +153,7 @@ interface RemoteDescriptorOptions {
    * 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 & {
+  proxy?: boolean | Partial<ProxyPrimitiveOptions & {
     /**
      * If true, the remote service won't be available internally, only through the proxy.
      */
@@ -355,14 +163,14 @@ interface RemoteDescriptorOptions {
    * 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;
+  serviceAccount?: ServiceAccountPrimitive;
 }
-declare class RemoteDescriptor extends Descriptor<RemoteDescriptorOptions> {
+declare class RemotePrimitive extends Primitive<RemotePrimitiveOptions> {
   get name(): string;
 }
 //#endregion
-//#region src/server-links/providers/RemoteDescriptorProvider.d.ts
-declare class RemoteDescriptorProvider {
+//#region src/server-links/providers/RemotePrimitiveProvider.d.ts
+declare class RemotePrimitiveProvider {
   protected readonly env: {
     SERVER_API_PREFIX: string;
   };
@@ -372,10 +180,10 @@ declare class RemoteDescriptorProvider {
   protected readonly remotes: Array<ServerRemote>;
   protected readonly log: alepha_logger0.Logger;
   getRemotes(): ServerRemote[];
-  readonly configure: alepha23.HookDescriptor<"configure">;
-  readonly start: alepha23.HookDescriptor<"start">;
-  registerRemote(value: RemoteDescriptor): Promise<void>;
-  protected readonly fetchLinks: alepha_retry0.RetryDescriptorFn<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
+  readonly configure: alepha1.HookPrimitive<"configure">;
+  readonly start: alepha1.HookPrimitive<"start">;
+  registerRemote(value: RemotePrimitive): Promise<void>;
+  protected readonly fetchLinks: alepha_retry0.RetryPrimitiveFn<(opts: FetchLinksOptions) => Promise<ApiLinksResponse>>;
 }
 interface FetchLinksOptions {
   /**
@@ -424,7 +232,7 @@ interface ServerRemote {
   /**
    * Force a default access token provider when not provided.
    */
-  serviceAccount?: ServiceAccountDescriptor;
+  serviceAccount?: ServiceAccountPrimitive;
   /**
    * Prefix for the remote service links.
    */
@@ -438,25 +246,25 @@ declare class ServerLinksProvider {
   };
   protected readonly alepha: Alepha;
   protected readonly linkProvider: LinkProvider;
-  protected readonly remoteProvider: RemoteDescriptorProvider;
+  protected readonly remoteProvider: RemotePrimitiveProvider;
   protected readonly serverTimingProvider: ServerTimingProvider;
   get prefix(): string;
-  readonly onRoute: alepha23.HookDescriptor<"configure">;
+  readonly onRoute: alepha1.HookPrimitive<"configure">;
   /**
    * First API - Get all API links for the user.
    *
    * This is based on the user's permissions.
    */
-  readonly links: alepha_server0.RouteDescriptor<{
-    response: alepha23.TObject<{
-      prefix: alepha23.TOptional<alepha23.TString>;
-      links: alepha23.TArray<alepha23.TObject<{
-        name: alepha23.TString;
-        group: alepha23.TOptional<alepha23.TString>;
-        path: alepha23.TString;
-        method: alepha23.TOptional<alepha23.TString>;
-        requestBodyType: alepha23.TOptional<alepha23.TString>;
-        service: alepha23.TOptional<alepha23.TString>;
+  readonly links: alepha_server0.RoutePrimitive<{
+    response: alepha1.TObject<{
+      prefix: alepha1.TOptional<alepha1.TString>;
+      links: alepha1.TArray<alepha1.TObject<{
+        name: alepha1.TString;
+        group: alepha1.TOptional<alepha1.TString>;
+        path: alepha1.TString;
+        method: alepha1.TOptional<alepha1.TString>;
+        requestBodyType: alepha1.TOptional<alepha1.TString>;
+        service: alepha1.TOptional<alepha1.TString>;
       }>>;
     }>;
   }>;
@@ -466,11 +274,11 @@ declare class ServerLinksProvider {
    * 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: alepha23.TObject<{
-      name: alepha23.TString;
+  readonly schema: alepha_server0.RoutePrimitive<{
+    params: alepha1.TObject<{
+      name: alepha1.TString;
     }>;
-    response: alepha23.TRecord<string, alepha23.TAny>;
+    response: alepha1.TRecord<string, alepha1.TAny>;
   }>;
   getSchemaByName(name: string, options?: GetApiLinksOptions): Promise<RequestConfigSchema>;
   /**
@@ -499,7 +307,7 @@ declare module "alepha" {
 /**
  * Provides server-side link management and remote capabilities for client-server interactions.
  *
- * The server-links module enables declarative link definitions using `$remote` and `$client` descriptors,
+ * The server-links module enables declarative link definitions using `$remote` and `$client` primitives,
  * facilitating seamless API endpoint management and client-server communication. It integrates with server
  * security features to ensure safe and controlled access to resources.
  *
@@ -507,7 +315,7 @@ declare module "alepha" {
  * @see {@link $client}
  * @module alepha.server.links
  */
-declare const AlephaServerLinks: alepha23.Service<alepha23.Module>;
+declare const AlephaServerLinks: alepha1.Service<alepha1.Module>;
 //#endregion
-export { $client, $remote, AlephaServerLinks, ApiLink, ApiLinksResponse, ClientScope, FetchLinksOptions, GetApiLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemoteDescriptor, RemoteDescriptorOptions, RemoteDescriptorProvider, ServerLinksProvider, ServerRemote, VirtualAction, apiLinkSchema, apiLinksResponseSchema };
+export { $client, $remote, AlephaServerLinks, ApiLink, ApiLinksResponse, ClientScope, FetchLinksOptions, GetApiLinksOptions, HttpClientLink, HttpVirtualClient, LinkProvider, RemotePrimitive, RemotePrimitiveOptions, RemotePrimitiveProvider, ServerLinksProvider, ServerRemote, VirtualAction, apiLinkSchema, apiLinksResponseSchema };
 //# sourceMappingURL=index.d.ts.map