@aerokit/sdk 12.44.0

package/dist/dts/http/client-async.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Provides a JavaScript/TypeScript wrapper (Facade) for making asynchronous HTTP requests.
+ *
+ */
+/** Defines a single HTTP header, used for both request and response. */
+export interface HttpClientHeader {
+    /** The name of the header (e.g., 'Content-Type', 'Authorization'). */
+    name: string;
+    /** The value of the header. */
+    value: string;
+}
+/** Defines a query parameter that will be appended to the URL. */
+export interface HttpClientParam {
+    /** The name of the URL query parameter (e.g., 'id'). */
+    name: string;
+    /** The value of the URL query parameter. */
+    value: string;
+}
+/** Defines a file to be included in a multi-part form data request. */
+export interface HttpClientFile {
+    /** The form field name for the file. */
+    name: string;
+    /** The file path or content. */
+    value: string;
+}
+/** Configuration options for an HTTP request, mirroring the capabilities of the underlying Java client. */
+export interface HttpClientRequestOptions {
+    expectContinueEnabled?: boolean;
+    proxyHost?: string;
+    proxyPort?: number;
+    cookieSpec?: string;
+    redirectsEnabled?: boolean;
+    relativeRedirectsAllowed?: boolean;
+    circularRedirectsAllowed?: boolean;
+    maxRedirects?: number;
+    authenticationEnabled?: boolean;
+    targetPreferredAuthSchemes?: string[];
+    proxyPreferredAuthSchemes?: string[];
+    connectionRequestTimeout?: number;
+    connectTimeout?: number;
+    socketTimeout?: number;
+    contentCompressionEnabled?: boolean;
+    sslTrustAllEnabled?: boolean;
+    data?: any[];
+    text?: string;
+    files?: HttpClientFile[];
+    characterEncoding?: string;
+    characterEncodingEnabled?: boolean;
+    contentType?: string;
+    headers?: HttpClientHeader[];
+    params?: HttpClientParam[];
+    binary?: boolean;
+    context?: {
+        [key: string]: any;
+    };
+}
+/** The structure of the response returned by the HttpClient methods. */
+export interface HttpClientResponse {
+    /** The HTTP status code (e.g., 200, 404, 500). */
+    statusCode: number;
+    /** The status message returned by the server (e.g., 'OK', 'Not Found'). */
+    statusMessage: string;
+    /** Response body content as an array of bytes (if requested as binary). */
+    data: any[];
+    /** Response body content as a decoded string. */
+    text: string;
+    /** The protocol used (e.g., 'HTTP/1.1'). */
+    protocol: string;
+    /** Indicates if the response was processed as binary data. */
+    binary: boolean;
+    /** Array of all headers received in the response. */
+    headers: HttpClientHeader[];
+}
+/**
+ * Defines the callback structure for asynchronous requests.
+ * Note: Callbacks are provided as strings containing executable JavaScript code.
+ */
+export interface HttpClientAsyncConfig {
+    /**
+     * Mandatory success callback as a **string of JavaScript code**.
+     * It will be executed with signature: `(response: HttpClientResponse, context: { [key: string]: any }) => void`
+     */
+    success: string;
+    /**
+     * Optional error callback as a **string of JavaScript code**.
+     * It will be executed with signature: `(exception: any) => void`
+     */
+    error?: string;
+    /**
+     * Optional cancel callback as a **string of JavaScript code**.
+     * It will be executed with signature: `() => void`
+     */
+    cancel?: string;
+}
+/**
+ * The asynchronous HTTP client class. All request methods return immediately
+ * and execute callbacks upon completion.
+ */
+export declare class HttpAsyncClient {
+    /**
+     * Executes an asynchronous HTTP GET request.
+     * @param url The target URL.
+     * @param config The callback configuration object.
+     * @param options Request configuration options (e.g., headers, body, params).
+     */
+    getAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void;
+    /**
+     * Executes an asynchronous HTTP POST request.
+     * @param url The target URL.
+     * @param config The callback configuration object.
+     * @param options Request configuration options.
+     */
+    postAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void;
+    /**
+     * Executes an asynchronous HTTP PUT request.
+     * @param url The target URL.
+     * @param config The callback configuration object.
+     * @param options Request configuration options.
+     */
+    putAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void;
+    /**
+     * Executes an asynchronous HTTP PATCH request.
+     * @param url The target URL.
+     * @param config The callback configuration object.
+     * @param options Request configuration options.
+     */
+    patchAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void;
+    /**
+     * Executes an asynchronous HTTP DELETE request.
+     * @param url The target URL.
+     * @param config The callback configuration object.
+     * @param options Request configuration options.
+     */
+    deleteAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void;
+    /**
+     * Executes an asynchronous HTTP HEAD request.
+     * @param url The target URL.
+     * @param config The callback configuration object.
+     * @param options Request configuration options.
+     */
+    headAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void;
+    /**
+     * Executes an asynchronous HTTP TRACE request.
+     * @param url The target URL.
+     * @param config The callback configuration object.
+     * @param options Request configuration options.
+     */
+    traceAsync(url: string, config: HttpClientAsyncConfig, options?: HttpClientRequestOptions): void;
+    /**
+     * Initiates the execution of queued asynchronous requests (depending on the underlying Java client's threading model).
+     */
+    execute(): void;
+}
+/**
+ * Factory function to retrieve a new instance of the asynchronous client.
+ * @returns A new instance of HttpAsyncClient.
+ */
+export declare function getInstance(): HttpAsyncClient;

package/dist/dts/http/client.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Provides a JavaScript/TypeScript wrapper (Facade) for making synchronous HTTP requests.
+ *
+ */
+/**
+ * Defines a single HTTP header, used for both request and response.
+ */
+export interface HttpClientHeader {
+    /** The name of the header (e.g., 'Content-Type', 'Authorization'). */
+    name: string;
+    /** The value of the header. */
+    value: string;
+}
+/**
+ * Defines a query parameter that will be appended to the URL.
+ */
+export interface HttpClientParam {
+    /** The name of the URL query parameter (e.g., 'id'). */
+    name: string;
+    /** The value of the URL query parameter. */
+    value: string;
+}
+/**
+ * Defines a file to be included in a multi-part form data request.
+ */
+export interface HttpClientFile {
+    /** The form field name for the file. */
+    name: string;
+    /** The file path or content (behavior depends on the underlying Java implementation). */
+    value: string;
+}
+/**
+ * Configuration options for an HTTP request, mirroring the capabilities of the underlying Java client.
+ */
+export interface HttpClientRequestOptions {
+    /** Whether 'Expect: 100-Continue' handshake is enabled. Defaults to false. */
+    expectContinueEnabled?: boolean;
+    /** The proxy hostname to use for the request. */
+    proxyHost?: string;
+    /** The proxy port number. */
+    proxyPort?: number;
+    /** The cookie specification to use (e.g., 'default', 'netscape'). */
+    cookieSpec?: string;
+    /** Whether automatic redirects are enabled. Defaults to true. */
+    redirectsEnabled?: boolean;
+    /** Whether relative redirects should be allowed. Defaults to true. */
+    relativeRedirectsAllowed?: boolean;
+    /** Whether circular redirects (infinite loops) should be allowed. Defaults to false. */
+    circularRedirectsAllowed?: boolean;
+    /** The maximum number of redirects to follow. */
+    maxRedirects?: number;
+    /** Whether authentication handling is enabled. */
+    authenticationEnabled?: boolean;
+    /** Array of preferred authentication schemes for the target host. */
+    targetPreferredAuthSchemes?: string[];
+    /** Array of preferred authentication schemes for the proxy. */
+    proxyPreferredAuthSchemes?: string[];
+    /** Timeout in milliseconds for requesting a connection from the connection manager. */
+    connectionRequestTimeout?: number;
+    /** Timeout in milliseconds for establishing the connection. */
+    connectTimeout?: number;
+    /** Socket timeout (timeout for waiting for data) in milliseconds. */
+    socketTimeout?: number;
+    /** Whether automatic content compression (e.g., gzip) is enabled. */
+    contentCompressionEnabled?: boolean;
+    /** Whether to trust all SSL certificates (use only for testing non-production systems). */
+    sslTrustAllEnabled?: boolean;
+    /** Data to be sent as the request body, typically as an array of bytes/integers. */
+    data?: any[];
+    /** Text content to be sent as the request body. Takes precedence over `data`. */
+    text?: string;
+    /** Array of files for multi-part form data submissions. */
+    files?: HttpClientFile[];
+    /** The character encoding (charset) to use for the request body (e.g., 'UTF-8'). */
+    characterEncoding?: string;
+    /** Whether to enforce the character encoding. */
+    characterEncodingEnabled?: boolean;
+    /** The Content-Type header value for the request body. */
+    contentType?: string;
+    /** Array of custom headers to include in the request. */
+    headers?: HttpClientHeader[];
+    /** Array of query parameters to be appended to the URL. */
+    params?: HttpClientParam[];
+    /** If true, treats the response body as binary data. */
+    binary?: boolean;
+    /** Optional context map for advanced configuration of the underlying Java client. */
+    context?: {
+        [key: string]: any;
+    };
+}
+/**
+ * The structure of the response returned by the HttpClient methods.
+ */
+export interface HttpClientResponse {
+    /** The HTTP status code (e.g., 200, 404, 500). */
+    statusCode: number;
+    /** The status message returned by the server (e.g., 'OK', 'Not Found'). */
+    statusMessage: string;
+    /** Response body content as an array of bytes (if requested as binary). */
+    data: any[];
+    /** Response body content as a decoded string. */
+    text: string;
+    /** The protocol used (e.g., 'HTTP/1.1'). */
+    protocol: string;
+    /** Indicates if the response was processed as binary data. */
+    binary: boolean;
+    /** Array of all headers received in the response. */
+    headers: HttpClientHeader[];
+}
+/**
+ * A static class providing methods for making synchronous HTTP requests.
+ * All methods call the underlying Java Facade and parse the JSON response.
+ */
+export declare class HttpClient {
+    /**
+     * Executes a synchronous HTTP GET request.
+     * @param url The target URL.
+     * @param options Configuration options for the request.
+     * @returns The parsed response object containing status, headers, and body.
+     */
+    static get(url: string, options?: HttpClientRequestOptions): HttpClientResponse;
+    /**
+     * Executes a synchronous HTTP POST request.
+     * @param url The target URL.
+     * @param options Configuration options for the request, including request body in `text` or `data`.
+     * @returns The parsed response object.
+     */
+    static post(url: string, options?: HttpClientRequestOptions): HttpClientResponse;
+    /**
+     * Executes a synchronous HTTP PUT request.
+     * @param url The target URL.
+     * @param options Configuration options for the request.
+     * @returns The parsed response object.
+     */
+    static put(url: string, options?: HttpClientRequestOptions): HttpClientResponse;
+    /**
+     * Executes a synchronous HTTP PATCH request.
+     * @param url The target URL.
+     * @param options Configuration options for the request.
+     * @returns The parsed response object.
+     */
+    static patch(url: string, options?: HttpClientRequestOptions): HttpClientResponse;
+    /**
+     * Executes a synchronous HTTP DELETE request.
+     * @param url The target URL.
+     * @param options Configuration options for the request.
+     * @returns The parsed response object.
+     */
+    static delete(url: string, options?: HttpClientRequestOptions): HttpClientResponse;
+    /**
+     * Alias for {@link HttpClient.delete}. Executes a synchronous HTTP DELETE request.
+     * @param url The target URL.
+     * @param options Configuration options for the request.
+     * @returns The parsed response object.
+     */
+    static del(url: string, options?: HttpClientRequestOptions): HttpClientResponse;
+    /**
+     * Executes a synchronous HTTP HEAD request (fetches headers only).
+     * @param url The target URL.
+     * @param options Configuration options for the request.
+     * @returns The parsed response object. The body (`text` and `data`) will typically be empty.
+     */
+    static head(url: string, options?: HttpClientRequestOptions): HttpClientResponse;
+    /**
+     * Executes a synchronous HTTP TRACE request.
+     * @param url The target URL.
+     * @param options Configuration options for the request.
+     * @returns The parsed response object.
+     */
+    static trace(url: string, options?: HttpClientRequestOptions): HttpClientResponse;
+    /**
+     * @private
+     * Builds the request URL by appending query parameters from options.params,
+     * then removes `params` from the options object before passing it to the Java Facade.
+     * @param url The base URL.
+     * @param options The request options object.
+     * @returns The URL with appended query parameters.
+     */
+    private static buildUrl;
+}

package/dist/dts/http/decorators.d.ts

@@ -0,0 +1,11 @@
+export declare function Controller(ctr: {
+    new (): any;
+}, context: ClassDecoratorContext): void;
+export declare function Documentation(documentation: string): (value: any, context: ClassDecoratorContext | ClassFieldDecoratorContext | ClassMethodDecoratorContext) => void;
+export declare const Get: (path: string, consumesMimeTypes?: undefined | string | string[], producesMimeTypes?: undefined | string | string[]) => any;
+export declare const Post: (path: string, consumesMimeTypes?: undefined | string | string[], producesMimeTypes?: undefined | string | string[]) => any;
+export declare const Put: (path: string, consumesMimeTypes?: undefined | string | string[], producesMimeTypes?: undefined | string | string[]) => any;
+export declare const Patch: (path: string, consumesMimeTypes?: undefined | string | string[], producesMimeTypes?: undefined | string | string[]) => any;
+export declare const Delete: (path: string, consumesMimeTypes?: undefined | string | string[], producesMimeTypes?: undefined | string | string[]) => any;
+export declare const Head: (path: string, consumesMimeTypes?: undefined | string | string[], producesMimeTypes?: undefined | string | string[]) => any;
+export declare const Options: (path: string, consumesMimeTypes?: undefined | string | string[], producesMimeTypes?: undefined | string | string[]) => any;

package/dist/dts/http/errors/ForbiddenError.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Custom error class representing a 403 Forbidden status, indicating
+ * that the user does not have permission to access the requested resource.
+ */
+export declare class ForbiddenError extends Error {
+    /**
+     * The name of the error, set to "ForbiddenError".
+     */
+    readonly name = "ForbiddenError";
+    /**
+     * Captures the stack trace when the error is instantiated.
+     */
+    readonly stack: string;
+    /**
+     * Creates an instance of ForbiddenError.
+     *
+     * @param message The error message. Defaults to "You don't have permission to access this resource".
+     */
+    constructor(message?: string);
+}

package/dist/dts/http/errors/ValidationError.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Custom error class used for representing failures due to invalid input
+ * or data that violates domain-specific validation rules.
+ */
+export declare class ValidationError extends Error {
+    /**
+     * The name of the error, set to "ValidationError".
+     */
+    readonly name = "ValidationError";
+    /**
+     * Captures the stack trace when the error is instantiated.
+     */
+    readonly stack: string;
+    /**
+     * Creates an instance of ValidationError.
+     *
+     * @param message The detailed message describing the validation failure.
+     */
+    constructor(message: string);
+}

package/dist/dts/http/errors.d.ts

@@ -0,0 +1,2 @@
+export { ForbiddenError } from "./errors/ForbiddenError";
+export { ValidationError } from "./errors/ValidationError";

package/dist/dts/http/index.d.ts

@@ -0,0 +1,16 @@
+export * as asyncClient from "./client-async";
+export * from "./client";
+export { HttpClient as client } from "./client";
+export * as decorators from "./decorators";
+export * from "./decorators";
+export * from "./request";
+export { Request as request } from "./request";
+export * from "./response";
+export { Response as response } from "./response";
+export * as rs from "./rs";
+export * from "./session";
+export { Session as session } from "./session";
+export * from "./upload";
+export { Upload as upload } from "./upload";
+export * as errors from "./errors";
+export { HttpUtils as utils } from "./utils";

package/dist/dts/http/request.d.ts

@@ -0,0 +1,158 @@
+/**
+ * The Request API under the HTTP module is responsible for
+ * managing standard HTTP request parameters, headers, cookies,
+ * and request metadata provided to server-side scripting services.
+ *
+ */
+import { InputStream } from "@aerokit/sdk/io/streams";
+import { Cookie } from "./response";
+/**
+ * Represents the HTTP Request object available within a service execution
+ * context. It provides access to HTTP metadata, query parameters, request
+ * body content, cookies, and security information.
+ *
+ * All functions in this class are static: no instance of `Request`
+ * needs to be created.
+ */
+export declare class Request {
+    private static TEXT_DATA;
+    /**
+     * Determines whether the current thread is handling a valid HTTP request.
+     *
+     * @returns `true` if called in a valid HTTP request context, otherwise `false`.
+     */
+    static isValid(): boolean;
+    /** Returns the HTTP method (GET, POST, PUT, DELETE, etc.). */
+    static getMethod(): string;
+    /** Returns the authenticated remote user name if available. */
+    static getRemoteUser(): string;
+    /** Returns the portion of the request path following the servlet path. */
+    static getPathInfo(): string;
+    /** Returns the translated file system path for the request. */
+    static getPathTranslated(): string;
+    /**
+     * Returns the value of a specific HTTP header.
+     *
+     * @param name - Header name to retrieve.
+     * @returns The header value or `undefined` if not found.
+     */
+    static getHeader(name: string): string;
+    /**
+     * Checks whether the remote user has the given role.
+     *
+     * @param role - The role name to check.
+     */
+    static isUserInRole(role: string): boolean;
+    /**
+     * Returns a request attribute value previously associated with the request.
+     *
+     * @param name - The attribute name.
+     * @returns A string value or `undefined`.
+     */
+    static getAttribute(name: string): string | undefined;
+    /** Returns the authentication type if known (BASIC, CLIENT_CERT, etc.). */
+    static getAuthType(): string;
+    /**
+     * Returns all cookies sent with the request.
+     *
+     * @returns An array of Cookie objects.
+     */
+    static getCookies(): Cookie[];
+    /** Returns all available request attribute names. */
+    static getAttributeNames(): string[];
+    /** Returns the character encoding used in the request body. */
+    static getCharacterEncoding(): string;
+    /** Returns the size of the request body in bytes, if known. */
+    static getContentLength(): number;
+    /**
+     * Returns all values of a specific header.
+     *
+     * @param name - Header name to retrieve.
+     */
+    static getHeaders(name: string): string[];
+    /** Returns the MIME content type of the request body. */
+    static getContentType(): string;
+    /** Returns the raw request body as a byte array. */
+    static getBytes(): any[];
+    /**
+     * Returns the request body as text. This is computed once and cached.
+     */
+    static getText(): string;
+    /**
+     * Returns the request body parsed as JSON if valid.
+     *
+     * @returns A JSON object or `undefined` if parsing fails.
+     */
+    static json(): {
+        [key: string]: any;
+    } | undefined;
+    /** Same as json(); explicit form. */
+    static getJSON(): {
+        [key: string]: any;
+    } | undefined;
+    /** Returns a request parameter value. */
+    static getParameter(name: string): string;
+    /** Returns a map of request parameters to arrays of values. */
+    static getParameters(): {
+        [key: string]: string[];
+    };
+    /** Returns the allocated request resource path. */
+    static getResourcePath(): string;
+    /** Returns all header names. */
+    static getHeaderNames(): string[];
+    /** Returns all parameter names. */
+    static getParameterNames(): string[];
+    /** Returns all values for a given parameter name. */
+    static getParameterValues(name: string): string[];
+    /** Returns the HTTP protocol version. */
+    static getProtocol(): string;
+    /** Returns the transport scheme (e.g., http, https). */
+    static getScheme(): string;
+    /** Returns the context path of the request. */
+    static getContextPath(): string;
+    /** Returns the server host name. */
+    static getServerName(): string;
+    /** Returns the server port number. */
+    static getServerPort(): number;
+    /** Returns the full raw query string. */
+    static getQueryString(): string;
+    /**
+     * Parses the query string and returns a map of parameter keys to values.
+     * If the same key appears multiple times, values are collected into arrays.
+     */
+    static getQueryParametersMap(): {
+        [key: string]: string | string[];
+    };
+    /** Returns the remote client IP address. */
+    static getRemoteAddress(): string;
+    /** Returns the remote client host name. */
+    static getRemoteHost(): string;
+    /** Assigns a new attribute to the request. */
+    static setAttribute(name: string, value: string): void;
+    /** Removes an attribute from the request. */
+    static removeAttribute(name: string): void;
+    /** Returns the client locale preferences. */
+    static getLocale(): any;
+    /** Returns the full request URI. */
+    static getRequestURI(): string;
+    /** Returns `true` if the request was made over HTTPS. */
+    static isSecure(): boolean;
+    /** Returns the full request URL including protocol and host. */
+    static getRequestURL(): string;
+    /** Returns the internal service path for routing. */
+    static getServicePath(): string;
+    /** Returns the remote client port number. */
+    static getRemotePort(): number;
+    /** Returns the local network host name. */
+    static getLocalName(): string;
+    /** Returns the local IP address. */
+    static getLocalAddress(): string;
+    /** Returns the server local port number handling the request. */
+    static getLocalPort(): number;
+    /**
+     * Returns the request body as a binary input stream.
+     *
+     * Useful for processing binary uploads.
+     */
+    static getInputStream(): InputStream;
+}