@webda/core 2.1.1 → 2.1.2

package/lib/utils/context.d.ts

@@ -1,10 +1,12 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
 import { WorkerLogLevel } from "@webda/workout";
 import { EventEmitter } from "events";
 import * as http from "http";
-import { Writable } from "stream";
+import { Readable, Writable } from "stream";
 import { Core } from "../core.js";
 import { User } from "../models/user.js";
 import { Service } from "../services/service.js";
@@ -19,102 +21,214 @@ declare class Cookie {
     options: any;
 }
 /**
- * @category CoreFeatures
- * @WebdaModel
+ * OperationContext is used when call to an operation
  */
-export declare class Context<T = any, U = any> extends EventEmitter {
-    protected _body: any;
-    /**
-     * Contains the response headers
-     */
-    protected _outputHeaders: Map<string, string>;
+export declare class OperationContext<T = any, U = any> extends EventEmitter {
+    protected static __globalContext: OperationContext;
+    private global;
     /**
      * Contain emitting Core
      */
     protected _webda: Core;
     /**
-     * Current status code
+     * Session
      */
-    statusCode: number;
-    _cookie: Map<string, Cookie>;
+    protected session: Session;
     /**
-     *
+     * Allow extensions
      */
-    headers: Map<string, string>;
-    _route: any;
+    protected extensions: {
+        [key: string]: any;
+    };
     /**
-     * Session
+     * Contain the sanitized request body if computed
      */
-    protected session: Session;
-    _ended: Promise<any>;
-    _stream: Writable;
+    protected _sanitized: any;
+    /**
+     * Output
+     */
+    protected _body: string;
+    /**
+     * Loaded user if exist
+     */
+    private user;
     /**
      * Contain all registered promises to this context
      */
     _promises: Promise<any>[];
-    _executor: Service<any>;
     /**
-     * If headers were flushed
+     * @ignore
+     * Used by Webda framework to set the body, session and output stream if known
      */
-    protected headersFlushed: boolean;
+    constructor(webda: Core, stream?: Writable);
     /**
-     * Contain the sanitized request body if computed
+     * Output stream
      */
-    protected _sanitized: any;
-    protected parameters: any;
-    protected _pathParams: any;
-    protected _serviceParams: any;
-    protected static __globalContext: Context;
-    private global;
+    _stream: Writable;
     /**
-     * Allow extensions
+     * Get an extension of the context
+     * @param name of the extension
+     * @returns extension object
      */
-    protected extensions: {
-        [key: string]: any;
-    };
+    getExtension<K = any>(name: string): K;
     /**
-     * Loaded user if exist
+     *
+     * @param name to add
+     * @param extension object to store
      */
-    private user;
+    setExtension(name: string, extension: any): void;
+    /**
+     * 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;
+    /**
+     * Ensure the whole execution is finished
+     */
+    end(): Promise<void>;
+    getInput(sanitizedOptions?: any): Promise<T>;
+    /**
+     * By default empty
+     * @returns
+     */
+    getRawInputAsString(_limit?: number, _timeout?: number, _encoding?: string): 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 samitized 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(): 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 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;
     /**
      * Get Global Context
      */
-    static getGlobalContext(): Context<any, any>;
+    static getGlobalContext(): OperationContext<any, any>;
     /**
      * Set the Global Context
      *
      * @param ctx to set as Global
      */
-    static setGlobalContext(ctx: Context): void;
+    static setGlobalContext(ctx: OperationContext): void;
     /**
      * Return if context is global
      */
     isGlobal(): 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;
+}
+/**
+ * This represent in fact a WebContext
+ * In 3.0 an abstract version of Context will replace this (closer to OperationContext)
+ * @category CoreFeatures
+ * @WebdaModel
+ *
+ * @deprecated use WebContext instead - will be removed in 3.0
+ */
+export declare class Context<T = any, U = any> extends OperationContext<T, U> {
+    /**
+     * Contains the response headers
+     */
+    protected _outputHeaders: Map<string, string>;
+    /**
+     * 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;
     /**
      * Set current http context
      * @param httpContext current http context
      */
     setHttpContext(httpContext: HttpContext): void;
-    /**
-     * Remove samitized body
-     */
-    reinit(): void;
     /**
      * Get current http context
      */
     getHttpContext(): HttpContext;
     /**
-     * Get an extension of the context
-     * @param name of the extension
-     * @returns extension object
+     * @override
      */
-    getExtension<K = any>(name: string): K;
+    getRawInputAsString(limit?: number, timeout?: number, encoding?: string): Promise<string>;
     /**
-     *
-     * @param name to add
-     * @param extension object to store
+     * @override
      */
-    setExtension(name: string, extension: any): void;
+    getRawInput(limit?: number, timeout?: number): Promise<Buffer>;
+    /**
+     * @override
+     */
+    getRawStream(): Readable;
     /**
      * Get output headers
      */
@@ -123,11 +237,6 @@ export declare class Context<T = any, U = any> extends EventEmitter {
     parameter(name: string): any;
     getParameters(): any;
     private processParameters;
-    /**
-     * Get linked session
-     * @returns
-     */
-    getSession<K = Session>(): K;
     getServiceParameters(): any;
     getPathParameters(): any;
     setServiceParameters(params: any): void;
@@ -142,7 +251,7 @@ export declare class Context<T = any, U = any> extends EventEmitter {
      * @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;
+    write(output: U, encoding?: string, cb?: (error: Error) => void): boolean;
     /**
      * Set a header value
      *
@@ -168,7 +277,6 @@ export declare class Context<T = any, U = any> extends EventEmitter {
      */
     cookie(param: any, value: any, options?: any): void;
     getResponseCookies(): Map<string, Cookie>;
-    addAsyncRequest(promise: any): void;
     isEnded(): Promise<any>;
     /******************************
      *
@@ -176,12 +284,12 @@ export declare class Context<T = any, U = any> extends EventEmitter {
      *
      ******************************/
     /**
-     * Express response allow statusCode to be defined this was
+     * 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 w
+     * Express response allow answer to be sent this way
      * @param code to return
      */
     json(obj: any): this;
@@ -192,12 +300,17 @@ export declare class Context<T = any, U = any> extends EventEmitter {
      * @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;
+    getResponseBody(): string | false | Buffer;
     /**
      * Retrieve a http.IncomingMessage valid from Context
      *
@@ -217,10 +330,6 @@ export declare class Context<T = any, U = any> extends EventEmitter {
      * @returns {*}
      */
     getStream(): Writable;
-    /**
-     * Get the current user from session
-     */
-    getCurrentUser<K extends User>(refresh?: boolean): Promise<K>;
     /**
      * Get the current user id from session
      */
@@ -233,10 +342,6 @@ export declare class Context<T = any, U = any> extends EventEmitter {
      * Execute the target route
      */
     execute(): Promise<any>;
-    /**
-     * Return the webda
-     */
-    getWebda(): Core<import("../core").CoreEvents>;
     /**
      * Get the request locale if found
      */
@@ -256,12 +361,6 @@ export declare class Context<T = any, U = any> extends EventEmitter {
      * Used for compatibility with express module
      */
     logIn(): void;
-    /**
-     * Proxy for simplification
-     * @param level
-     * @param args
-     */
-    log(level: WorkerLogLevel, ...args: any[]): void;
     /**
      * Return true if Headers got flushed already
      * @returns
@@ -277,13 +376,12 @@ export declare class Context<T = any, U = any> extends EventEmitter {
      * Used by Webda framework to set the body, session and output stream if known
      */
     constructor(webda: Core, httpContext: HttpContext, stream?: Writable);
-    createStream(): void;
-    /**
-     * Create a new session
-     * @returns
-     */
-    newSession(): Session;
     init(): Promise<this>;
     emitError(err: any): void;
 }
+/**
+ * Replacement for Context
+ */
+export declare class WebContext<T = any, U = any> extends Context<T, U> {
+}
 export {};