@zcatalyst/transport 0.0.1 → 0.0.3

package/dist-types/ts3.4/fetch-handler.d.ts

@@ -0,0 +1,149 @@
+import { CoreType, IRequestConfig, jwtAccessTokenResponse, RequestHandlerOptions } from './utils/interfaces';
+type ICatalystDataRes = Record<string, string> | string | Blob | ArrayBuffer | ReadableStreamDefaultReader<Uint8Array> | FormData;
+export interface ICatalystClientRes {
+    request: RequestInit;
+    statusCode?: number;
+    headers: HeadersInit;
+    data?: ICatalystDataRes;
+    buffer?: Buffer;
+    blob?: Blob;
+    config: RequestHandlerOptions;
+    stream?: ArrayBuffer;
+}
+export declare class DefaultHttpResponse {
+    statusCode: number;
+    headers: HeadersInit;
+    config: RequestHandlerOptions;
+    resp: ICatalystClientRes;
+    /**
+     * Creates a DefaultHttpResponse instance.
+     * @param resp - The resp value.
+     */
+    constructor(resp: ICatalystClientRes);
+    /*
+    * Returns the data value for this DefaultHttpResponse instance.
+    *
+    * @returns The response payload.
+    * @throws {CatalystAPIError} when the request or response cannot be processed.
+    *
+    * @example
+    * ```ts
+    * import { Handler } from '@zcatalyst/transport';
+    * const result = undefined;
+    * ```
+    */
+    readonly data: ICatalystDataRes;
+}
+export declare class ResponseHandler {
+    private "ResponseHandler.#private";
+    static apiDomain: string;
+    /**
+     * Creates a ResponseHandler instance.
+     */
+    constructor();
+    /**
+     * Sends a browser fetch request with SDK authentication, timeout and response handling.
+     *
+     * @param options - The initialization or request options.
+     * @param options.requestCore - The Fetch API request configuration.
+     * @param options.url - The URL to update or request.
+     * @param requestOptions - The request handling options.
+     * @returns The fire general request result.
+     * @throws {CatalystAPIError} when the request or response cannot be processed.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const response = await ResponseHandler.fireGeneralRequest({ url: '/baas/v1/project/123', method: 'GET', headers: {} });
+     * ```
+     */
+    static fireGeneralRequest({ requestCore, url }: {
+        requestCore: RequestInit;
+        url: string;
+    }, requestOptions?: RequestHandlerOptions): Promise<DefaultHttpResponse | void>;
+    /**
+     * Wraps a Fetch API response in the SDK response object.
+     *
+     * @param response - The response to wrap.
+     * @param options - The initialization or request options.
+     * @returns The wrap response result.
+     * @throws {CatalystAPIError} when the request or response cannot be processed.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const response = await ResponseHandler.wrapResponse({ url: '/baas/v1/project/123', method: 'GET', headers: {} });
+     * ```
+     */
+    static wrapResponse(response: Response, options?: RequestHandlerOptions): Promise<DefaultHttpResponse>;
+    /**
+     * Sends a browser fetch request without retry handling.
+     *
+     * @param requestCore - The Fetch API request configuration.
+     * @param reqOptions - The raw request handling options.
+     * @returns The fire raw request result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const response = await ResponseHandler.fireRawRequest({ url: '/baas/v1/project/123', method: 'GET', headers: {} });
+     * ```
+     */
+    static fireRawRequest(requestCore: CoreType, reqOptions: RequestHandlerOptions): Promise<DefaultHttpResponse>;
+    /**
+     * Attaches browser authentication headers according to the configured auth protocol.
+     *
+     * @param headers - The headers object to mutate or extend.
+     * @returns The attach zcauth headers result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const response = await ResponseHandler.attachZCAuthHeaders({ url: '/baas/v1/project/123', method: 'GET', headers: {} });
+     * ```
+     */
+    static attachZCAuthHeaders(headers: HeadersInit): Promise<HeadersInit>;
+    /**
+     * Builds the browser JWT authorization token from the configured cookie.
+     *
+     * @returns The get jwtzcauth token result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const response = await ResponseHandler.getJWTZCAuthToken({ url: '/baas/v1/project/123', method: 'GET', headers: {} });
+     * ```
+     */
+    static getJWTZCAuthToken(): Promise<jwtAccessTokenResponse>;
+    /**
+     * Appends query parameters to a URL.
+     *
+     * @param url - The URL to update or request.
+     * @param qs - The query string values to append.
+     * @returns The URL with encoded query parameters.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const response = await ResponseHandler.appendQueryString({ url: '/baas/v1/project/123', method: 'GET', headers: {} });
+     * ```
+     */
+    static appendQueryString(url: string, qs?: Record<string, string | number | boolean | undefined>): string;
+    /**
+     * Sends a Catalyst HTTP request and returns the wrapped response.
+     *
+     * @param options - The initialization or request options.
+     * @param componentName - The component name for user-agent metadata.
+     * @param componentVersion - The component version for user-agent metadata.
+     * @returns The send result.
+     * @throws {CatalystAPIError} when the request or response cannot be processed.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const response = await ResponseHandler.send({ url: '/baas/v1/project/123', method: 'GET', headers: {} });
+     * ```
+     */
+    static send(options: IRequestConfig, componentName?: string, componentVersion?: string): Promise<DefaultHttpResponse | void>;
+}
+export {};

package/dist-types/ts3.4/http-handler.d.ts

@@ -0,0 +1,79 @@
+import { CatalystApp } from '@zcatalyst/auth-admin';
+import { ClientRequest, IncomingHttpHeaders, IncomingMessage } from 'http';
+import { Component, IRequestConfig } from './utils/interfaces';
+export interface IAPIResponse {
+    request: ClientRequest;
+    statusCode?: number;
+    headers: IncomingHttpHeaders;
+    data?: string;
+    buffer?: Buffer;
+    config: IRequestConfig;
+    stream?: IncomingMessage;
+}
+export declare class DefaultHttpResponse {
+    statusCode: number;
+    headers: IncomingHttpHeaders;
+    config: IRequestConfig;
+    resp: IAPIResponse;
+    /**
+     * Creates a DefaultHttpResponse instance.
+     * @param resp - The resp value.
+     */
+    constructor(resp: IAPIResponse);
+    /*
+    * Returns the parsed response payload.
+    *
+    * @returns The data result.
+    * @throws {CatalystAPIError} when the operation cannot be completed.
+    *
+    * @example
+    * ```ts
+    * import { Handler } from '@zcatalyst/transport';
+    * // Use DefaultHttpResponse.data while preparing or sending an SDK request.
+    * ```
+    */
+    readonly data: any;
+}
+export declare class HttpClient {
+    app?: CatalystApp;
+    /** * @param app - The app used to fetch access tokens to sign API requests. */
+    constructor(app?: CatalystApp);
+    /**
+     * Sends a Catalyst HTTP request and returns the wrapped response.
+     *
+     * @param req - The req value.
+     * @param apmTrackerName - The apmTrackerName value.
+     * @param componentVersion - The componentVersion value.
+     * @returns The send result.
+     * @throws {CatalystAPIError} when the operation cannot be completed.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * // Use HttpClient.send while preparing or sending an SDK request.
+     * ```
+     */
+    send(req: IRequestConfig, apmTrackerName?: string, componentVersion?: string): Promise<DefaultHttpResponse>;
+}
+export declare class AuthorizedHttpClient extends HttpClient {
+    readonly componentName?: string;
+    readonly componentVersion?: string;
+    /**
+     * @param app - The app used to fetch access tokens to sign API requests.
+     * @param component - Optional component metadata used to attach version headers.
+     */
+    constructor(app?: CatalystApp, component?: Component);
+    /**
+     * Sends a Catalyst HTTP request and returns the wrapped response.
+     *
+     * @param request - The request value.
+     * @returns The send result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * // Use AuthorizedHttpClient.send while preparing or sending an SDK request.
+     * ```
+     */
+    send(request: IRequestConfig): Promise<DefaultHttpResponse>;
+}

package/dist-types/ts3.4/index.browser.d.ts

@@ -0,0 +1,29 @@
+import { ICatalystClientRes } from './fetch-handler';
+import { Component, IRequestConfig } from './utils/interfaces';
+export { CatalystService, Component, CONSTANTS } from '@zcatalyst/utils';
+export { PrefixedCatalystError } from '@zcatalyst/utils';
+export declare class Handler {
+    component?: Component;
+    /**
+     * Creates a Handler instance.
+     * @param app - The app value.
+     * @param component - The component value.
+     */
+    constructor(app?: unknown, component?: Component);
+    /**
+     * Sends a Catalyst HTTP request and returns the wrapped response.
+     *
+     * @param options - The initialization or request options.
+     * @returns The send result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    send(options: IRequestConfig): Promise<ICatalystClientRes>;
+}
+export { RequestType, ResponseType } from './utils/enums';
+export { CatalystAPIError } from './utils/errors';
+export { IRequestConfig };

package/dist-types/ts3.4/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Internal HTTP / fetch transport layer used by every Catalyst component package.
+ *
+ * @packageDocumentation
+ */
+import { DefaultHttpResponse } from './http-handler';
+import FormData from './utils/form-data';
+import { Component, IRequestConfig } from './utils/interfaces';
+export { CatalystService, Component, CONSTANTS } from '@zcatalyst/utils';
+export { PrefixedCatalystError } from '@zcatalyst/utils';
+export declare class Handler {
+    component?: Component;
+    app?: any;
+    /**
+     * Creates a Handler instance.
+     * @param app - The app value.
+     * @param component - The component value.
+     */
+    constructor(app?: unknown, component?: Component);
+    /**
+     * Sends a Catalyst HTTP request through the Node transport handler.
+     *
+     * @param options - The request configuration to send.
+     * @returns The wrapped HTTP response.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const response = await new Handler(app).send({ method: 'GET', url: 'https://example.com' });
+     * ```
+     */
+    send(options: IRequestConfig): Promise<DefaultHttpResponse>;
+}
+export { RequestType, ResponseType } from './utils/enums';
+export { CatalystAPIError } from './utils/errors';
+export { FormData, IRequestConfig };

package/dist-types/ts3.4/utils/clonable-stream.d.ts

@@ -0,0 +1,75 @@
+import { PassThrough, Readable } from 'stream';
+declare class StreamClone extends PassThrough {
+    parent: CloneableStream;
+    /**
+     * Creates a StreamClone instance.
+     * @param parent - The parent value.
+     */
+    constructor(parent: CloneableStream);
+    private onDataClone;
+    private onResumeClone;
+    /**
+     * Performs clone for the transport package.
+     *
+     * @returns The clone result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    clone(): StreamClone;
+    /**
+     * Performs is cloneable for the transport package.
+     *
+     * @param stream - The stream value.
+     * @returns The is cloneable result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    isCloneable(stream: unknown): stream is CloneableStream | StreamClone;
+}
+export default class CloneableStream extends PassThrough {
+    _original: Readable | undefined;
+    _clonesCount: number;
+    _internalPipe: boolean;
+    _hasListener: boolean;
+    /**
+     * Creates a CloneableStream instance.
+     * @param stream - The stream value.
+     */
+    constructor(stream: Readable);
+    private onData;
+    private onResume;
+    /**
+     * Performs resume for the transport package.
+     *
+     * @returns The resume result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    resume(): this;
+    /**
+     * Performs clone for the transport package.
+     *
+     * @returns The clone result.
+     * @throws {Error} when validation fails.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    clone(): StreamClone;
+}
+export {};

package/dist-types/ts3.4/utils/constants.d.ts

@@ -0,0 +1,11 @@
+import { HTTP_CODE_MAP_TYPE, HTTP_CODE_REV_MAP_TYPE } from './interfaces';
+export declare const HTTP_CODE_MAP: HTTP_CODE_MAP_TYPE;
+export declare const HTTP_HEADER_MAP: {
+    CONTENT_JSON: string;
+    AUTHORIZATION_KEY: string;
+};
+export declare const REQUEST_PROPERTY: unknown;
+export declare const X_ZCSRF_TOKEN = "X-ZCSRF-TOKEN";
+export declare const ZD_CSRPARAM = "zd_csrparam";
+declare const HTTP_CODE_REV_MAP: HTTP_CODE_REV_MAP_TYPE;
+export { HTTP_CODE_REV_MAP };

package/dist-types/ts3.4/utils/enums.d.ts

@@ -0,0 +1,16 @@
+export declare const enum ResponseType {
+    RAW = "raw",
+    JSON = "json",
+    STRING = "string",
+    BUFFER = "buffer"
+}
+export declare const enum RequestType {
+    FILE = "file",
+    JSON = "json",
+    URL_ENCODED = "url_encoded",
+    RAW = "raw"
+}
+export declare const enum FormDataKeys {
+    CODE = "code",
+    FILE_NAME = "file_name"
+}

package/dist-types/ts3.4/utils/errors.d.ts

@@ -0,0 +1,11 @@
+import { PrefixedCatalystError } from '@zcatalyst/utils';
+export declare class CatalystAPIError extends PrefixedCatalystError {
+    /**
+     * Creates a CatalystAPIError instance.
+     * @param code - The code value.
+     * @param message - The message value.
+     * @param value - The value value.
+     * @param statusCode - The statusCode value.
+     */
+    constructor(code: string, message: string, value?: unknown, statusCode?: number);
+}

package/dist-types/ts3.4/utils/form-data.d.ts

@@ -0,0 +1,285 @@
+import { IncomingMessage } from 'http';
+import { PassThrough, Readable, Stream } from 'stream';
+export type formDataType = string | Buffer | Readable | IncomingMessage | PassThrough | Record<string, string>;
+export default class FormData extends Stream {
+    writable: boolean;
+    readable: boolean;
+    released: boolean;
+    streams: Array<formDataType>;
+    currentStream: undefined | formDataType;
+    insideLoop: boolean;
+    pendingNext: boolean;
+    boundary: string | undefined;
+    /**
+     * Creates a FormData instance.
+     * @param streams - The streams value.
+     */
+    constructor(streams?: Array<formDataType>);
+    static LINE_BREAK: string;
+    static CONTENT_TYPE: string;
+    /**
+     * Performs is stream for the transport package.
+     *
+     * @param value - The value to validate.
+     * @returns The is stream result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    isStream(value: unknown): boolean;
+    /**
+     * Performs multi part header for the transport package.
+     *
+     * @param field - The field value.
+     * @param value - The value to validate.
+     * @returns The multi part header result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _multiPartHeader(field: string, value: formDataType): string;
+    /**
+     * Performs get content disposition for the transport package.
+     *
+     * @param value - The value to validate.
+     * @returns The get content disposition result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _getContentDisposition(value: unknown): string | undefined;
+    /**
+     * Performs get content type for the transport package.
+     *
+     * @param value - The value to validate.
+     * @returns The get content type result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _getContentType(value: formDataType): string;
+    /**
+     * Performs last boundary for the transport package.
+     *
+     * @returns The last boundary result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _lastBoundary(): string;
+    /**
+     * Performs generate boundary for the transport package.
+     *
+     * @returns The generate boundary result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _generateBoundary(): string;
+    /**
+     * Performs error for the transport package.
+     *
+     * @param err - The err value.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _error(err: Error): void;
+    /**
+     * Performs handle stream errors for the transport package.
+     *
+     * @param stream - The stream value.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _handleStreamErrors(stream: Stream): void;
+    /**
+     * Performs pipe next for the transport package.
+     *
+     * @param stream - The stream value.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _pipeNext(stream: formDataType): void;
+    /**
+     * Performs get next for the transport package.
+     *
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _getNext(): void;
+    /**
+     * Performs reset for the transport package.
+     *
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    _reset(): void;
+    /**
+     * Performs create clone for the transport package.
+     *
+     * @returns The create clone result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    createClone(): FormData;
+    /**
+     * Performs append for the transport package.
+     *
+     * @param field - The field value.
+     * @param value - The value to validate.
+     * @returns The append result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    append(field: string, value: unknown): this;
+    /**
+     * Performs get headers for the transport package.
+     *
+     * @param userHeaders - The user headers value.
+     * @returns The get headers result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    getHeaders(userHeaders: {
+        [x: string]: string;
+    }): {
+        [x: string]: string;
+    };
+    /**
+     * Performs get boundary for the transport package.
+     *
+     * @returns The get boundary result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    getBoundary(): string;
+    /**
+     * Performs pipe for the transport package.
+     *
+     * @param dest - The dest value.
+     * @param options - The initialization or request options.
+     * @returns The pipe result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    pipe<T extends NodeJS.WritableStream>(dest: T, options?: {
+        end?: boolean;
+    }): T;
+    /**
+     * Performs write for the transport package.
+     *
+     * @param data - The data value.
+     * @returns The write result.
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    write(data: Uint8Array | string): boolean;
+    /**
+     * Performs pause for the transport package.
+     *
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    pause(): void;
+    /**
+     * Performs resume for the transport package.
+     *
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    resume(): void;
+    /**
+     * Performs end for the transport package.
+     *
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    end(): void;
+    /**
+     * Performs destroy for the transport package.
+     *
+     *
+     * @example
+     * ```ts
+     * import { Handler } from '@zcatalyst/transport';
+     * const result = undefined;
+     * ```
+     */
+    destroy(): void;
+    /** function toString() { [native code] } */
+    toString(): string;
+}