@jwn-js/common 1.1.48 → 1.3.2

package/index.d.ts

@@ -1,10 +1,13 @@
 import * as formidable from 'formidable';
+import * as stream$1 from 'stream';
+import { Stream } from 'stream';
 import * as uWebSockets_js from 'uWebSockets.js';
 import { HttpResponse, HttpRequest } from 'uWebSockets.js';
 export { ApiError, ApiErrorMessage } from './ApiError';
 export { Server, Handler as ServerHandler, Options as ServerOptions, Routes as ServerRoutes, WebSocket as ServerWebsocket, codeToStatus } from './Server';
 export { Jwt } from './Jwt';
 import { Client } from 'memjs';
+import { Query } from 'buildmsql';
 
 declare class Memcached {
     memjs: Client;
@@ -54,10 +57,621 @@ declare class Memcached {
  */
 declare function staticBody(res: HttpResponse, req: HttpRequest, base: string): Promise<void>;
 
+interface Context$3 {
+    readonly manifest: Record<string, any>;
+    readonly memcached: Memcached;
+    readonly [key: string]: any;
+}
+/**
+ * Ssr handler for production
+ */
+declare class Ssr {
+    res: HttpResponse;
+    req: HttpRequest;
+    context: Context$3;
+    entry: CallableFunction;
+    /**
+     * @constructor
+     * @param res response
+     * @param req request
+     * @param context params
+     * @param entry - entry point function
+     */
+    constructor(res: HttpResponse, req: HttpRequest, context: Context$3, entry: CallableFunction);
+    /**
+     * @param request addition request params
+     */
+    request(request?: Record<string, any>): Promise<void>;
+}
+
+/**
+ * Input params of error
+ */
+interface ApiErrorMessage {
+    message?: string;
+    code?: number;
+    statusCode?: number;
+    data?: Record<string, unknown>;
+    headers?: Record<string, string>;
+}
+/**
+ * @class Api Error
+ * @description Base error class for @jwn-js
+ */
+declare class ApiError extends Error {
+    statusCode: number;
+    code: number;
+    data: Record<string, unknown>;
+    headers: Record<string, string>;
+    /**
+     * @constructor
+     * @param message
+     * @param code
+     * @param statusCode
+     */
+    constructor(message?: string, code?: number, statusCode?: number);
+    constructor(params: ApiErrorMessage | string, code?: number, statusCode?: number);
+    /**
+     * Get error message
+     */
+    getMessage(): string;
+    /**
+     * Get internal status code
+     */
+    getStatusCode(): number;
+    /**
+     * Get internal error code
+     */
+    getCode(): number;
+    /**
+     * Get error data
+     */
+    getData(): Record<string, unknown>;
+    /**
+     * Get error headers
+     */
+    getHeaders(): Record<string, string>;
+}
+
+declare type method$2 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+declare module "uWebSockets.js" {
+    interface HttpRequest {
+        cookies: Record<string, any>;
+    }
+}
+interface Route$1 {
+    name: string;
+    method?: method$2 | Array<method$2>;
+    component: any;
+}
+interface Context$2 {
+    readonly routes: Array<Route$1>;
+    readonly config: Config$1;
+    readonly db: Record<string, Query>;
+    readonly [key: string]: any;
+}
+interface Response$1 {
+    statusCode: number;
+    headers: Record<string, any>;
+    body: any;
+}
+interface Config$1 {
+    server: Record<string, any>;
+    db: Record<string, any>;
+    [key: string]: any;
+}
+interface ContextWeb {
+    readonly config: Config$1;
+    readonly db: Record<string, Query>;
+    controller: {
+        id: number;
+        name: string;
+        isActive: boolean;
+        isSitemap: boolean;
+    };
+    subaction: {
+        id: number;
+        name: string;
+        isPermission: boolean;
+        isCheckMethod: boolean;
+        isLog: boolean;
+        isActive: boolean;
+    };
+    action: {
+        id: number;
+        name: string;
+        isActive: boolean;
+        method: method$2;
+    };
+    [key: string]: any;
+}
+interface ContextWebController extends ContextWeb {
+    method: string;
+    cookies: Record<string, any>;
+    hostname: string;
+    protocol: string;
+    url: string;
+    headers: Record<string, any>;
+    getRequest: () => Record<string, any>;
+    db: Record<string, Query>;
+    $stream?: Stream;
+    $body?: any;
+    $route?: Route$1;
+}
+/**
+ * Entry point for /web api
+ * handler for api request
+ */
+declare class Web {
+    res: HttpResponse;
+    req: HttpRequest;
+    context: Context$2;
+    defaultRequest: {
+        controller: string;
+        subaction: string;
+        lang: string;
+    };
+    defaultResponse: {
+        statusCode: number;
+        headers: {
+            "content-type": string;
+        };
+        body: {};
+    };
+    route: Route$1;
+    contextWeb: ContextWeb;
+    /**
+     * @constructor
+     * @param res response
+     * @param req request
+     * @param context params
+     */
+    constructor(res: HttpResponse, req: HttpRequest, context: Context$2);
+    request(request?: Record<string, any>): Promise<void>;
+    /**
+     * Import controller class
+     * @param request params
+     * @private
+     */
+    private importController;
+    /**
+     * Find route in api routers
+     * @private
+     */
+    private findRoute;
+    /**
+     * Inject app context
+     * @param obj
+     * @private
+     */
+    private injectContext;
+    /**
+     * Initing component if init method exists
+     * @param obj
+     * @returns
+     * @private
+     */
+    private initComponent;
+    /**
+     * Success response
+     */
+    success(response: Response$1): void;
+    /**
+     * Error response
+     */
+    error(e: ApiError | Error): void;
+}
+
+declare type method$1 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+declare module "uWebSockets.js" {
+    interface HttpRequest {
+        cookies: Record<string, any>;
+    }
+}
+interface Route {
+    name: string;
+    method?: method$1 | Array<method$1>;
+    component: any;
+}
+interface Config {
+    server: Record<string, any>;
+    db: Record<string, any>;
+    [key: string]: any;
+}
+
+interface TestContext {
+    readonly config?: Config;
+    readonly db?: Record<string, Query>;
+    controller?: {
+        id: number;
+        name: string;
+        isActive: boolean;
+        isSitemap: boolean;
+    };
+    subaction?: {
+        id: number;
+        name: string;
+        isPermission: boolean;
+        isCheckMethod: boolean;
+        isLog: boolean;
+        isActive: boolean;
+    };
+    action?: {
+        id: number;
+        name: string;
+        isActive: boolean;
+        method: method$1;
+    };
+    method?: method$1;
+    cookies?: Record<string, any>;
+    hostname?: string;
+    protocol?: string;
+    url?: string;
+    headers?: Record<string, any>;
+    getRequest?: () => Record<string, any>;
+    $stream?: Stream;
+    $body?: any;
+    $route?: Route;
+    [key: string]: any;
+}
+/**
+ * Create class with inject context
+ */
+declare const mountWithContext: <T>($class: new () => T, $context: TestContext, request?: Record<string, any>) => Promise<T>;
+
+interface Context$1 extends ContextWeb {
+    method: string;
+    getRequest: () => Record<string, any>;
+    db: Record<string, any>;
+    headers: Record<string, any>;
+}
+/**
+ * Base model
+ */
+declare class Model$1 {
+    protected $context: Context$1;
+    /**
+     * Create model
+     * @param model
+     * @param args
+     */
+    protected $create<T extends Model$1 | Record<string, any>, A extends Array<any>>(model: {
+        new (...args: [...A]): T;
+    }, ...args: [...A]): Promise<T>;
+    /**
+     * Inject app context
+     * @param context
+     */
+    $inject(context: any): void;
+    getContext(): Context$1;
+    getRequest(): Record<string, any>;
+    getConfig(): Config$1;
+    getMethod(): string;
+    getHeaders(): Record<string, any>;
+    getController(): {
+        id: number;
+        name: string;
+        isActive: boolean;
+        isSitemap: boolean;
+    };
+    getAction(): {
+        id: number;
+        name: string;
+        isActive: boolean;
+        method: method$2;
+    };
+    getSubaction(): {
+        id: number;
+        name: string;
+        isPermission: boolean;
+        isCheckMethod: boolean;
+        isLog: boolean;
+        isActive: boolean;
+    };
+}
+
+interface ResponseOptions {
+    memcache?: number | null;
+    headers?: Record<string, any>;
+    statusCode?: number;
+}
+/**
+ * Base Controller
+ */
+declare class Controller {
+    $context: ContextWebController;
+    /**
+     * Set cookies
+     * @param name
+     * @param value
+     * @param options
+     */
+    setCookieHeader(name: string, value: any, options?: Record<string, any>): string;
+    /**
+     * Success request
+     * @param data response params
+     * @param options
+     * @returns
+     */
+    success(data?: {}, options?: ResponseOptions | any): {
+        headers: any;
+        body: {
+            isError: boolean;
+            data: {};
+        };
+        memcache: any;
+        statusCode: any;
+    };
+    /**
+     * Error response
+     * @param err
+     */
+    error(err: unknown | Error | ApiError): {
+        headers: {
+            "content-type": string;
+        } & Record<string, string>;
+        body: {
+            isError: boolean;
+            error: string;
+            code: number;
+            data: Record<string, unknown>;
+            stack: string | undefined;
+            response: {
+                status: any;
+                headers: any;
+                config: {
+                    url: any;
+                    method: any;
+                    params: any;
+                    headers: any;
+                };
+                data: any;
+            } | {
+                status?: undefined;
+                headers?: undefined;
+                config?: undefined;
+                data?: undefined;
+            };
+        };
+        statusCode: number;
+    };
+    /**
+     * Xml response
+     * @param data response params
+     * @param options addition options
+     */
+    successXml(data?: {}, options?: ResponseOptions): {
+        headers: Record<string, any>;
+        body: string;
+        memcache: any;
+    };
+    /**
+     * Error xml response
+     * @param err error object
+     */
+    errorXml(err: unknown | Error | ApiError): {
+        headers: {
+            "content-type": string;
+        } & Record<string, string>;
+        body: string;
+        statusCode: number;
+    };
+    /**
+     * Create model
+     * @param model
+     * @param args
+     */
+    $create<T extends Model$1 | Record<string, any>, A extends Array<any>>(model: {
+        new (...args: [...A]): T;
+    }, ...args: [...A]): Promise<T>;
+    /**
+     * Inject app context
+     * @param context
+     */
+    $inject(context: ContextWebController): void;
+    getContext(): ContextWebController;
+    getRequest(): Record<string, any>;
+    getBody(): Buffer;
+    getStream(): Stream;
+    getConfig(): Config$1;
+    getMethod(): string;
+    getCookies(): Record<string, any>;
+    getHostname(): string;
+    getUrl(): string;
+    getProtocol(): string;
+    getDb(): Record<string, Query>;
+    getHeaders(): Record<string, any>;
+    getController(): {
+        id: number;
+        name: string;
+        isActive: boolean;
+        isSitemap: boolean;
+    };
+    getAction(): {
+        id: number;
+        name: string;
+        isActive: boolean;
+        method: method$2;
+    };
+    getSubaction(): {
+        id: number;
+        name: string;
+        isPermission: boolean;
+        isCheckMethod: boolean;
+        isLog: boolean;
+        isActive: boolean;
+    };
+    getHome(): Query;
+}
+
+interface Context extends ContextWeb {
+    method: string;
+    getRequest: () => Record<string, any>;
+    db: Record<string, any>;
+    headers: Record<string, any>;
+}
+/**
+ * Base model
+ */
+declare class Model {
+    protected $context: Context;
+    /**
+     * Create model
+     * @param model
+     * @param args
+     */
+    protected $create<T extends Model | Record<string, any>, A extends Array<any>>(model: {
+        new (...args: [...A]): T;
+    }, ...args: [...A]): Promise<T>;
+    /**
+     * Inject app context
+     * @param context
+     */
+    $inject(context: any): void;
+    getContext(): Context;
+    getRequest(): Record<string, any>;
+    getConfig(): Config$1;
+    getMethod(): string;
+    getHeaders(): Record<string, any>;
+    getController(): {
+        id: number;
+        name: string;
+        isActive: boolean;
+        isSitemap: boolean;
+    };
+    getAction(): {
+        id: number;
+        name: string;
+        isActive: boolean;
+        method: method$2;
+    };
+    getSubaction(): {
+        id: number;
+        name: string;
+        isPermission: boolean;
+        isCheckMethod: boolean;
+        isLog: boolean;
+        isActive: boolean;
+    };
+}
+
+/**
+ * Response interface
+ */
+interface Response {
+    memcache?: number | null;
+    headers?: Record<string, any>;
+    statusCode?: number;
+}
+declare type CallbackFunctionAny = (...args: any[]) => any;
+/**
+ * Mixin helper for decorators
+ * @param behaviour
+ * @param sharedBehaviour
+ * http://raganwald.com/2015/06/26/decorators-in-es7.html
+ * http://raganwald.com/2015/06/17/functional-mixins.html
+ * https://habr.com/ru/post/277021/
+ */
+declare function mixin<T extends Record<string, any>>(behaviour: T, sharedBehaviour?: {}): (clazz: any) => any;
+/**
+ * @request() decorator
+ */
+declare function request(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @context() decorator
+ */
+declare function context(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @config() decorator
+ */
+declare function config(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @method() decorator
+ */
+declare function method(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @cookies() decorator
+ */
+declare function cookies(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @hostname() decorator
+ */
+declare function hostname(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @url() decorator
+ */
+declare function url(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @protocol() decorator
+ */
+declare function protocol(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @db() decorator
+ */
+declare function db(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @headers() decorator
+ */
+declare function headers(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @controller() decorator
+ */
+declare function controller(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @action() decorator
+ */
+declare function action(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @subaction() decorator
+ */
+declare function subaction(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @body() decorator
+ */
+declare function body(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @stream() decorator
+ */
+declare function stream(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @home() decorator
+ */
+declare function home(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @connection() decorator
+ */
+declare function connection(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Json response
+ * @param opt response options
+ */
+declare function json(opt?: Response): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Xml response
+ * @param opt response options
+ */
+declare function xml(opt?: Response): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Logger
+ * @param name logger name
+ */
+declare function logerror(name: string): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Subaction method decorator
+ * @http() decorator
+ */
+declare function http(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * @init decorator
+ */
+declare function init(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+
 declare const helpers: {
     cookieParse: (str: string) => Record<string, any>;
     cookieString: (name: string, value: any, options?: Record<string, any>) => string;
     jsonBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<any>;
+    rawBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<Buffer>;
+    streamBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => stream$1.Stream;
     urlencodedBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<any>;
     multipartBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest, options?: formidable.Options) => Promise<any>;
     readConfig: (jsonfile: string) => Promise<any>;
@@ -67,4 +681,4 @@ declare const helpers: {
     getExt: (path: string) => string;
 };
 
-export { Memcached, helpers };
+export { Controller, Memcached, Model, Ssr, Web, action, body, config, connection, context, controller, cookies, db, headers, helpers, home, hostname, http, init, json, logerror, method, mixin, mountWithContext as mount, protocol, request, stream, subaction, url, xml };