@webda/core 4.0.0-beta.1 → 4.0.0-beta.3

package/lib/utils/context.d.ts

@@ -1,462 +0,0 @@
-import { WorkerLogLevel } from "@webda/workout";
-import { EventEmitter } from "events";
-import * as http from "http";
-import sanitize from "sanitize-html";
-import { Readable, Writable } from "stream";
-import { Core } from "../core.js";
-import { User } from "../models/user.js";
-import { Service } from "../services/service.js";
-import { Session } from "../utils/session.js";
-import { HttpContext } from "./httpcontext.js";
-/**
- * @category CoreFeatures
- */
-declare class Cookie {
-    name: string;
-    value: string;
-    options: any;
-}
-/**
- * Data provided by the context
- */
-export interface ContextProviderInfo {
-    /**
-     * Stream to write to
-     */
-    stream?: Writable;
-    /**
-     * If this is http context
-     */
-    http?: HttpContext;
-    /**
-     * true if this is a global context
-     */
-    global?: boolean;
-    /**
-     * Can contain any type of information
-     */
-    [key: string]: any;
-}
-/**
- * @category CoreFeatures
- */
-export interface ContextProvider {
-    /**
-     * Info can contain any type of information
-     * @param info
-     */
-    getContext(info: ContextProviderInfo): OperationContext;
-}
-/**
- * OperationContext is used when call to an operation
- *
- * @param T type of input for this context
- * @param U type of output for this context
- */
-export declare class OperationContext<T = any, U = any> extends EventEmitter {
-    protected static __globalContext: OperationContext;
-    /**
-     * Contain emitting Core
-     */
-    protected _webda: Core;
-    /**
-     * Session
-     */
-    protected session: Session;
-    /**
-     * Allow extensions
-     */
-    protected extensions: {
-        [key: string]: any;
-    };
-    /**
-     * Contain the sanitized request body if computed
-     */
-    protected _sanitized: any;
-    /**
-     * Output
-     */
-    protected _body: string;
-    /**
-     * Loaded user if exist
-     */
-    private user;
-    /**
-     * Contain all registered promises to this context
-     */
-    _promises: Promise<any>[];
-    /**
-     * @ignore
-     * Used by Webda framework to set the body, session and output stream if known
-     */
-    constructor(webda: Core, stream?: Writable);
-    /**
-     * Output stream
-     */
-    _stream: Writable;
-    /**
-     * Get an extension of the context
-     * @param name of the extension
-     * @returns extension object
-     */
-    getExtension<K = any>(name: string): K;
-    /**
-     * For easier compatibility with WebContext
-     * On OperationContext this call is simply ignored
-     */
-    setHeader(_name: string, _value: string): void;
-    /**
-     * For easier compatibility with WebContext
-     * On OperationContext this call is simply ignored
-     */
-    writeHead(_code: number, _headers: any): void;
-    /**
-     *
-     * @param name to add
-     * @param extension object to store
-     */
-    setExtension(name: string, extension: any): this;
-    /**
-     * Return the webda
-     */
-    getWebda(): Core<import("../core").CoreEvents>;
-    /**
-     * Register a promise with the context
-     * @param promise
-     */
-    addAsyncRequest(promise: any): void;
-    /**
-     * Get output as string, if a OutputStream is provided it will returned null
-     * @returns
-     */
-    getOutput(): string;
-    /**
-     * Get current http context
-     */
-    getHttpContext(): HttpContext | undefined;
-    /**
-     * Ensure the whole execution is finished
-     */
-    end(): Promise<void>;
-    getInput(sanitizedOptions?: sanitize.IOptions & {
-        defaultValue?: any;
-        raw?: boolean | string[];
-    }): Promise<T>;
-    /**
-     * By default empty
-     * @returns
-     */
-    getRawInputAsString(limit?: number, timeout?: number, encoding?: BufferEncoding): Promise<string>;
-    /**
-     * @override
-     */
-    getRawInput(_limit?: number, _timeout?: number): Promise<Buffer>;
-    /**
-     * @override
-     */
-    getRawStream(): Readable;
-    /**
-     * Get the HTTP stream to output raw data
-     * @returns {*}
-     */
-    getOutputStream(): Writable;
-    /**
-     * Get linked session
-     * @returns
-     */
-    getSession<K = Session>(): K;
-    /**
-     * Remove sanitized body
-     */
-    reinit(): void;
-    /**
-     * Create a buffer stream
-     */
-    createStream(): void;
-    /**
-     * Proxy for simplification
-     * @param level
-     * @param args
-     */
-    log(level: WorkerLogLevel, ...args: any[]): void;
-    /**
-     * Create a new session
-     * @returns
-     */
-    newSession(): Promise<Session>;
-    /**
-     * Remove everything that was about to be sent
-     */
-    resetResponse(): void;
-    /**
-     * Write data to the client
-     *
-     * @param output If it is an object it will be serialized with toPublicJSON, if it is a String it will be appended to the result, if it is a buffer it will replace the result
-     * @param ...args any arguments to pass to the toPublicJSON method
-     */
-    write(output: U, _encoding?: string, _cb?: (error: Error) => void): boolean;
-    init(): Promise<this>;
-    /**
-     * Get the current user from session
-     */
-    getCurrentUser<K extends User>(refresh?: boolean): Promise<K>;
-    /**
-     * Get the current user id from session
-     */
-    getCurrentUserId(): any;
-    /**
-     * Global context is the default Context
-     *
-     * Whenever a request is internal to the system
-     * or not linked to a user request
-     * @returns
-     */
-    isGlobal(): boolean;
-}
-export declare class GlobalContext extends OperationContext {
-    session: Session;
-    constructor(webda: Core);
-    /**
-     * @override
-     */
-    isGlobal(): boolean;
-}
-/**
- * Simple Operation Context with custom input
- */
-export declare class SimpleOperationContext extends OperationContext {
-    constructor(webda: Core);
-    input: Buffer;
-    /**
-     * Create another context from an existing one
-     * @param context
-     * @returns
-     */
-    static fromContext(context: OperationContext): Promise<SimpleOperationContext>;
-    /**
-     * Set the input
-     */
-    setInput(input: Buffer): this;
-    /**
-     * Set the session
-     * @param session
-     * @returns
-     */
-    setSession(session: Session): this;
-    /**
-     * @override
-     */
-    getRawInput(limit?: number, _timeout?: number): Promise<Buffer>;
-}
-/**
- * This represent in fact a WebContext
- * In 3.0 an abstract version of Context will replace this (closer to OperationContext)
- * @category CoreFeatures
- *
- */
-export declare class WebContext<T = any, U = any> extends OperationContext<T, U> {
-    /**
-     * Contains the response headers
-     */
-    protected _outputHeaders: http.OutgoingHttpHeaders;
-    /**
-     * Current status code
-     */
-    statusCode: number;
-    /**
-     * Cookies to send back
-     */
-    _cookie: Map<string, Cookie>;
-    /**
-     *
-     */
-    headers: Map<string, string>;
-    _route: any;
-    _ended: Promise<any>;
-    _executor: Service<any>;
-    /**
-     * If headers were flushed
-     */
-    protected headersFlushed: boolean;
-    protected parameters: any;
-    protected _pathParams: any;
-    protected _serviceParams: any;
-    private _init;
-    /**
-     * Set current http context
-     * @param httpContext current http context
-     */
-    setHttpContext(httpContext: HttpContext): void;
-    /**
-     * @override
-     */
-    getRawInputAsString(limit?: number, timeout?: number, encoding?: string): Promise<string>;
-    /**
-     * @override
-     */
-    getRawInput(limit?: number, timeout?: number): Promise<Buffer>;
-    /**
-     * @override
-     */
-    getRawStream(): Readable;
-    /**
-     * Get output headers
-     */
-    getResponseHeaders(): any;
-    getRequestParameters(): any;
-    parameter(name: string): any;
-    getParameters(): any;
-    private processParameters;
-    getServiceParameters(): any;
-    getPathParameters(): any;
-    setServiceParameters(params: any): void;
-    setPathParameters(params: any): void;
-    /**
-     * Remove everything that was about to be sent
-     */
-    resetResponse(): void;
-    /**
-     * Write data to the client
-     *
-     * @param output If it is an object it will be serializeb with toPublicJSON, if it is a String it will be appended to the result, if it is a buffer it will replace the result
-     * @param ...args any arguments to pass to the toPublicJSON method
-     */
-    write(output: U, encoding?: string, cb?: (error: Error) => void): boolean;
-    /**
-     * Set a header value
-     *
-     * @param {String} header name
-     * @param {String} value
-     */
-    setHeader(header: any, value: any): void;
-    /**
-     * Write the http return code and some headers
-     * Those headers are not flushed yet so can still be overwritten
-     *
-     * @param {Number} statusCode to return to the client
-     * @param {Object} headers to add to the response
-     */
-    writeHead(statusCode: number, headers?: http.OutgoingHttpHeaders): this;
-    /**
-     *
-     * @returns
-     */
-    getResponseCode(): number;
-    /**
-     * Redirect to another url
-     * @param url
-     */
-    redirect(url: string): void;
-    /**
-     * For compatibility reason
-     */
-    cookie(param: any, value: any, options?: any): void;
-    getResponseCookies(): Map<string, Cookie>;
-    isEnded(): Promise<any>;
-    /******************************
-     *
-     * Express Compatibiliy method
-     *
-     ******************************/
-    /**
-     * Express response allow statusCode to be defined this way
-     * @param code to return
-     */
-    status(code: number): this;
-    /**
-     * Express response allow answer to be sent this way
-     * @param code to return
-     */
-    json(obj: any): this;
-    /**
-     * Return the response size
-     * @returns
-     */
-    getResponseSize(): number | undefined;
-    /**
-     * Flush the request
-     *
-     * @emits 'finish' event
-     * @throws Error if the request was already ended
-     */
-    end(): Promise<any>;
-    /**
-     * Alias to keep compatibility with WebContext
-     * @param sanitizedOptions
-     * @returns
-     */
-    getRequestBody(sanitizedOptions?: any): Promise<T>;
-    /**
-     * Get request body
-     * @returns
-     */
-    getResponseBody(): any;
-    /**
-     * Retrieve a http.IncomingMessage valid from Context
-     *
-     * Need more testing
-     * @returns
-     */
-    getRequest(): http.IncomingMessage;
-    /**
-     * Get a service from webda
-     *
-     * @see Webda
-     * @param {String} name of the service
-     */
-    getService<K extends Service>(name: any): K;
-    /**
-     * Get the HTTP stream to output raw data
-     * @returns {*}
-     */
-    getStream(): Writable;
-    /**
-     * Get the current user id from session
-     */
-    getCurrentUserId(): string;
-    /**
-     * Return the service handling the request
-     */
-    getExecutor(): Service<any>;
-    /**
-     * Execute the target route
-     */
-    execute(): Promise<any>;
-    /**
-     * Get the request locale if found
-     */
-    getLocale(): string;
-    /**
-     * @ignore
-     * Used by Webda framework to set the current route
-     */
-    setRoute(route: any): void;
-    getRoute(): any;
-    /**
-     * @param executor {object} Set the current executor for this context
-     */
-    setExecutor(executor: any): void;
-    /**
-     * @ignore
-     * Used for compatibility with express module
-     */
-    logIn(): void;
-    /**
-     * Return true if Headers got flushed already
-     * @returns
-     */
-    hasFlushedHeaders(): boolean;
-    /**
-     * Set flushed header status
-     * @param status
-     */
-    setFlushedHeaders(status?: boolean): void;
-    /**
-     * @ignore
-     * Used by Webda framework to set the body, session and output stream if known
-     */
-    constructor(webda: Core, httpContext: HttpContext, stream?: Writable);
-    init(force?: boolean): Promise<this>;
-    emitError(err: any): void;
-}
-export {};