@clairejs/server 3.1.11 → 3.1.12

package/dist/service/AbstractFileService.d.ts

@@ -1,8 +1,8 @@
-import { FileOperation } from "../common/FileOperation";
-export declare abstract class AbstractFileService {
-    abstract getFileSize(objectKey: string): Promise<number>;
-    abstract getAccessUrl(objectKey: string, isPublic: boolean): string;
-    abstract getPresignedUrl(operation: FileOperation, objectKey: string): string;
-    abstract moveObject(fromObjectKey: string, toObjectKey: string): Promise<void>;
-    abstract removeObject(objectKey: string): Promise<void>;
-}
+import { FileOperation } from "../common/FileOperation";
+export declare abstract class AbstractFileService {
+    abstract getFileSize(objectKey: string): Promise<number>;
+    abstract getAccessUrl(objectKey: string, isPublic: boolean): string;
+    abstract getPresignedUrl(operation: FileOperation, objectKey: string): string;
+    abstract moveObject(fromObjectKey: string, toObjectKey: string): Promise<void>;
+    abstract removeObject(objectKey: string): Promise<void>;
+}

package/dist/service/AbstractService.d.ts

@@ -1,9 +1,9 @@
-import { AbstractDatabaseAdapter } from "../database/adapter/AbstractDatabaseAdapter";
-import { IDatabaseProvider } from "../database/adapter/IDatabaseProvider";
-import { ITransactionProvider } from "../database/transaction/ITransactionProvider";
-export declare abstract class AbstractService implements ITransactionProvider, IDatabaseProvider {
-    protected readonly databaseAdapter: AbstractDatabaseAdapter;
-    constructor(databaseAdapter: AbstractDatabaseAdapter);
-    getCurrentDatabaseAdapter(): Promise<AbstractDatabaseAdapter>;
-    getCurrentTransaction(): Promise<import("../database/transaction/ITransaction").ITransaction>;
-}
+import { AbstractDatabaseAdapter } from "../database/adapter/AbstractDatabaseAdapter";
+import { IDatabaseProvider } from "../database/adapter/IDatabaseProvider";
+import { ITransactionProvider } from "../database/transaction/ITransactionProvider";
+export declare abstract class AbstractService implements ITransactionProvider, IDatabaseProvider {
+    protected readonly databaseAdapter: AbstractDatabaseAdapter;
+    constructor(databaseAdapter: AbstractDatabaseAdapter);
+    getCurrentDatabaseAdapter(): Promise<AbstractDatabaseAdapter>;
+    getCurrentTransaction(): Promise<import("../database/transaction/ITransaction").ITransaction>;
+}

package/dist/socket/AbstractServerSocket.d.ts

@@ -1,39 +1,39 @@
-import { SocketPlainMessage, AbstractLogger } from "@clairejs/core";
-import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
-import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
-import { IPrincipal } from "../http/auth/IPrincipal";
-import { IServerSocket } from "./IServerSocket";
-export interface ServerSocketInfo {
-    id?: string;
-    isOpen?: boolean;
-    authorized?: boolean;
-    channels?: string[];
-    authInfo?: IPrincipal;
-    createdAt?: number;
-}
-export declare abstract class AbstractServerSocket implements IServerSocket {
-    readonly logger: AbstractLogger;
-    readonly requestHandler: AbstractHttpRequestHandler;
-    readonly authorizationProvider: AbstractHttpAuthorizationProvider<any>;
-    constructor(logger: AbstractLogger, requestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<any>);
-    connect(): void;
-    onMessage(_handler: (message: SocketPlainMessage) => void): void;
-    protected socketInfo: ServerSocketInfo;
-    abstract setOpen(isOpen: boolean): Promise<void>;
-    addChannels(channels: string[]): Promise<void>;
-    removeChannels(channels: string[]): Promise<void>;
-    isOpen(): boolean;
-    createdTime(): number;
-    isAuthorized(): boolean;
-    getAuthInfo(): IPrincipal | undefined;
-    getId(): string;
-    getChannels(): string[];
-    send(message: SocketPlainMessage): void;
-    disconnect(disconnectError?: any): void;
-    authorize(authInfo?: IPrincipal): Promise<void>;
-    protected sendToSocket(channel: string, message?: any): Promise<void>;
-    protected abstract physicDisconnect(): Promise<void>;
-    protected abstract physicSend(message: string): Promise<void>;
-    handleDisconnect(): Promise<void>;
-    handleMessage(channel: string, message?: any): Promise<void>;
-}
+import { SocketPlainMessage, AbstractLogger } from "@clairejs/core";
+import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
+import { IPrincipal } from "../http/auth/IPrincipal";
+import { IServerSocket } from "./IServerSocket";
+export interface ServerSocketInfo {
+    id?: string;
+    isOpen?: boolean;
+    authorized?: boolean;
+    channels?: string[];
+    authInfo?: IPrincipal;
+    createdAt?: number;
+}
+export declare abstract class AbstractServerSocket implements IServerSocket {
+    readonly logger: AbstractLogger;
+    readonly requestHandler: AbstractHttpRequestHandler;
+    readonly authorizationProvider: AbstractHttpAuthorizationProvider<any>;
+    constructor(logger: AbstractLogger, requestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<any>);
+    connect(): void;
+    onMessage(_handler: (message: SocketPlainMessage) => void): void;
+    protected socketInfo: ServerSocketInfo;
+    abstract setOpen(isOpen: boolean): Promise<void>;
+    addChannels(channels: string[]): Promise<void>;
+    removeChannels(channels: string[]): Promise<void>;
+    isOpen(): boolean;
+    createdTime(): number;
+    isAuthorized(): boolean;
+    getAuthInfo(): IPrincipal | undefined;
+    getId(): string;
+    getChannels(): string[];
+    send(message: SocketPlainMessage): void;
+    disconnect(disconnectError?: any): void;
+    authorize(authInfo?: IPrincipal): Promise<void>;
+    protected sendToSocket(channel: string, message?: any): Promise<void>;
+    protected abstract physicDisconnect(): Promise<void>;
+    protected abstract physicSend(message: string): Promise<void>;
+    handleDisconnect(): Promise<void>;
+    handleMessage(channel: string, message?: any): Promise<void>;
+}

package/dist/socket/AbstractServerSocketManager.d.ts

@@ -1,19 +1,19 @@
-/// <reference types="node" />
-import { Server } from "http";
-import { AbstractLogger } from "@clairejs/core";
-import { RequestOptions } from "../http/common/RequestOptions";
-import { ResponseValues } from "../http/common/ResponseValues";
-import { AbstractServerSocket } from "./AbstractServerSocket";
-import { IServerSocket } from "./IServerSocket";
-export declare abstract class AbstractServerSocketManager {
-    protected readonly logger: AbstractLogger;
-    protected constructor(logger: AbstractLogger);
-    abstract configure(httpServer?: Server): void;
-    abstract intercept(options: RequestOptions): Promise<ResponseValues | undefined>;
-    abstract add(socket: AbstractServerSocket): Promise<void>;
-    abstract removeById(id: string): Promise<void>;
-    abstract getById(id: string): Promise<AbstractServerSocket | undefined>;
-    protected abstract getAllSockets(): Promise<AbstractServerSocket[]>;
-    protected getAllAliveSockets(): Promise<AbstractServerSocket[]>;
-    getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
-}
+/// <reference types="node" />
+import { Server } from "http";
+import { AbstractLogger } from "@clairejs/core";
+import { RequestOptions } from "../http/common/RequestOptions";
+import { ResponseValues } from "../http/common/ResponseValues";
+import { AbstractServerSocket } from "./AbstractServerSocket";
+import { IServerSocket } from "./IServerSocket";
+export declare abstract class AbstractServerSocketManager {
+    protected readonly logger: AbstractLogger;
+    protected constructor(logger: AbstractLogger);
+    abstract configure(httpServer?: Server): void;
+    abstract intercept(options: RequestOptions): Promise<ResponseValues | undefined>;
+    abstract add(socket: AbstractServerSocket): Promise<void>;
+    abstract removeById(id: string): Promise<void>;
+    abstract getById(id: string): Promise<AbstractServerSocket | undefined>;
+    protected abstract getAllSockets(): Promise<AbstractServerSocket[]>;
+    protected getAllAliveSockets(): Promise<AbstractServerSocket[]>;
+    getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
+}

package/dist/socket/AwsSocketManager.d.ts

@@ -1,46 +1,46 @@
-import { AbstractLogger, IInit } from "@clairejs/core";
-import { RedisClient } from "redis";
-import { ApiGatewayManagementApi } from "aws-sdk";
-import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
-import { AbstractServerSocketManager } from "./AbstractServerSocketManager";
-import { AbstractServerSocket, ServerSocketInfo } from "./AbstractServerSocket";
-import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
-import { RequestOptions } from "../http/common/RequestOptions";
-import { ResponseValues } from "../http/common/ResponseValues";
-declare class ApiGatewaySocket extends AbstractServerSocket {
-    protected socketManager: AbstractServerSocketManager;
-    private readonly apiGateway;
-    private readonly redisClient;
-    private readonly socketNamespace;
-    constructor(socketManager: AbstractServerSocketManager, logger: AbstractLogger, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<any>, socketInfo: ServerSocketInfo, apiGateway: ApiGatewayManagementApi, socketNamespace: string, redisClient: RedisClient);
-    protected physicSend(message: string): Promise<void>;
-    private updateSocketInfo;
-    physicDisconnect(): Promise<void>;
-    setOpen(isOpen: boolean): Promise<void>;
-    addChannels(channels: string[]): Promise<void>;
-    removeChannels(channels: string[]): Promise<void>;
-    authorize(authInfo: any): Promise<void>;
-    serialize(): string;
-}
-export declare class AwsSocketManager extends AbstractServerSocketManager implements IInit {
-    protected readonly region: string;
-    protected readonly socketDomainUrl: string;
-    protected readonly redisServerUrl: string;
-    protected readonly socketNamespace: string;
-    protected readonly httpRequestHandler: AbstractHttpRequestHandler;
-    protected readonly authorizationProvider: AbstractHttpAuthorizationProvider<any>;
-    protected readonly logger: AbstractLogger;
-    private readonly redisClient;
-    private readonly apiGatewayManagement;
-    constructor(region: string, socketDomainUrl: string, redisServerUrl: string, socketNamespace: string, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<any>, logger: AbstractLogger);
-    configure(): void;
-    intercept(options: RequestOptions): Promise<ResponseValues | undefined>;
-    init(): Promise<void>;
-    exit(): void;
-    create(socketInfo: ServerSocketInfo): ApiGatewaySocket;
-    add(socket: ApiGatewaySocket): Promise<void>;
-    removeById(id: string): Promise<void>;
-    getById(id: string): Promise<AbstractServerSocket | undefined>;
-    protected getAllSockets(): Promise<AbstractServerSocket[]>;
-}
-export {};
+import { AbstractLogger, IInit } from "@clairejs/core";
+import { RedisClient } from "redis";
+import { ApiGatewayManagementApi } from "aws-sdk";
+import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { AbstractServerSocketManager } from "./AbstractServerSocketManager";
+import { AbstractServerSocket, ServerSocketInfo } from "./AbstractServerSocket";
+import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
+import { RequestOptions } from "../http/common/RequestOptions";
+import { ResponseValues } from "../http/common/ResponseValues";
+declare class ApiGatewaySocket extends AbstractServerSocket {
+    protected socketManager: AbstractServerSocketManager;
+    private readonly apiGateway;
+    private readonly redisClient;
+    private readonly socketNamespace;
+    constructor(socketManager: AbstractServerSocketManager, logger: AbstractLogger, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<any>, socketInfo: ServerSocketInfo, apiGateway: ApiGatewayManagementApi, socketNamespace: string, redisClient: RedisClient);
+    protected physicSend(message: string): Promise<void>;
+    private updateSocketInfo;
+    physicDisconnect(): Promise<void>;
+    setOpen(isOpen: boolean): Promise<void>;
+    addChannels(channels: string[]): Promise<void>;
+    removeChannels(channels: string[]): Promise<void>;
+    authorize(authInfo: any): Promise<void>;
+    serialize(): string;
+}
+export declare class AwsSocketManager extends AbstractServerSocketManager implements IInit {
+    protected readonly region: string;
+    protected readonly socketDomainUrl: string;
+    protected readonly redisServerUrl: string;
+    protected readonly socketNamespace: string;
+    protected readonly httpRequestHandler: AbstractHttpRequestHandler;
+    protected readonly authorizationProvider: AbstractHttpAuthorizationProvider<any>;
+    protected readonly logger: AbstractLogger;
+    private readonly redisClient;
+    private readonly apiGatewayManagement;
+    constructor(region: string, socketDomainUrl: string, redisServerUrl: string, socketNamespace: string, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<any>, logger: AbstractLogger);
+    configure(): void;
+    intercept(options: RequestOptions): Promise<ResponseValues | undefined>;
+    init(): Promise<void>;
+    exit(): void;
+    create(socketInfo: ServerSocketInfo): ApiGatewaySocket;
+    add(socket: ApiGatewaySocket): Promise<void>;
+    removeById(id: string): Promise<void>;
+    getById(id: string): Promise<AbstractServerSocket | undefined>;
+    protected getAllSockets(): Promise<AbstractServerSocket[]>;
+}
+export {};

package/dist/socket/IServerSocket.d.ts

@@ -1,8 +1,8 @@
-import { ISocket } from "@clairejs/core";
-import { IPrincipal } from "../http/auth/IPrincipal";
-export interface IServerSocket extends ISocket {
-    getId(): string;
-    getAuthInfo(): IPrincipal | undefined;
-    isOpen(): boolean;
-    isAuthorized(): boolean;
-}
+import { ISocket } from "@clairejs/core";
+import { IPrincipal } from "../http/auth/IPrincipal";
+export interface IServerSocket extends ISocket {
+    getId(): string;
+    getAuthInfo(): IPrincipal | undefined;
+    isOpen(): boolean;
+    isAuthorized(): boolean;
+}

package/dist/socket/LocalSocketManager.d.ts

@@ -1,23 +1,23 @@
-/// <reference types="node" />
-import { AbstractLogger } from "@clairejs/core";
-import WebSocket from "ws";
-import { Server } from "http";
-import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
-import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
-import { ResponseValues } from "../http/common/ResponseValues";
-import { AbstractServerSocketManager } from "./AbstractServerSocketManager";
-import { AbstractServerSocket } from "./AbstractServerSocket";
-export declare class LocalSocketManager extends AbstractServerSocketManager {
-    protected readonly logger: AbstractLogger;
-    protected readonly httpRequestHandler: AbstractHttpRequestHandler;
-    protected readonly authorizationProvider: AbstractHttpAuthorizationProvider<any>;
-    private readonly allSockets;
-    constructor(logger: AbstractLogger, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<any>);
-    configure(httpServer?: Server): void;
-    intercept(): Promise<ResponseValues | undefined>;
-    create(socket: WebSocket): AbstractServerSocket;
-    protected getAllSockets(): Promise<AbstractServerSocket[]>;
-    add(socket: AbstractServerSocket): Promise<void>;
-    removeById(id: string): Promise<void>;
-    getById(id: string): Promise<AbstractServerSocket | undefined>;
-}
+/// <reference types="node" />
+import { AbstractLogger } from "@clairejs/core";
+import WebSocket from "ws";
+import { Server } from "http";
+import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
+import { ResponseValues } from "../http/common/ResponseValues";
+import { AbstractServerSocketManager } from "./AbstractServerSocketManager";
+import { AbstractServerSocket } from "./AbstractServerSocket";
+export declare class LocalSocketManager extends AbstractServerSocketManager {
+    protected readonly logger: AbstractLogger;
+    protected readonly httpRequestHandler: AbstractHttpRequestHandler;
+    protected readonly authorizationProvider: AbstractHttpAuthorizationProvider<any>;
+    private readonly allSockets;
+    constructor(logger: AbstractLogger, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<any>);
+    configure(httpServer?: Server): void;
+    intercept(): Promise<ResponseValues | undefined>;
+    create(socket: WebSocket): AbstractServerSocket;
+    protected getAllSockets(): Promise<AbstractServerSocket[]>;
+    add(socket: AbstractServerSocket): Promise<void>;
+    removeById(id: string): Promise<void>;
+    getById(id: string): Promise<AbstractServerSocket | undefined>;
+}

package/dist/system/AbstractFileUploadHandler.d.ts

@@ -1,6 +1,6 @@
-export declare abstract class AbstractFileUploadHandler {
-    abstract moveFile(fromUri: string, toUri: string): Promise<void>;
-    abstract removeFile(uri: string): Promise<void>;
-    abstract resolvePublicUrl(uri: string): Promise<string>;
-    abstract resolvePrivateUrl(uri: string): Promise<string>;
-}
+export declare abstract class AbstractFileUploadHandler {
+    abstract moveFile(fromUri: string, toUri: string): Promise<void>;
+    abstract removeFile(uri: string): Promise<void>;
+    abstract resolvePublicUrl(uri: string): Promise<string>;
+    abstract resolvePrivateUrl(uri: string): Promise<string>;
+}

package/dist/system/ClaireServer.d.ts

@@ -1,10 +1,10 @@
-import { AbstractLogger, ClaireApp } from "@clairejs/core";
-export declare class ClaireServer extends ClaireApp {
-    private readonly injector;
-    protected readonly logger: AbstractLogger;
-    private booted;
-    constructor();
-    init(): Promise<void>;
-    exit(): void;
-    private stop;
-}
+import { AbstractLogger, ClaireApp } from "@clairejs/core";
+export declare class ClaireServer extends ClaireApp {
+    private readonly injector;
+    protected readonly logger: AbstractLogger;
+    private booted;
+    constructor();
+    init(): Promise<void>;
+    exit(): void;
+    private stop;
+}

package/dist/system/ExpressWrapper.d.ts

@@ -1,17 +1,17 @@
-import { ClaireServer } from "./ClaireServer";
-interface ExpressWrapperConfig {
-    maxBodySizeKB?: number;
-}
-export declare class ExpressWrapper {
-    private readonly injector;
-    private readonly socketManager?;
-    private readonly logger;
-    private readonly server;
-    private readonly config?;
-    private readonly httpRequestHandler;
-    private httpServer?;
-    constructor(server: ClaireServer, config?: ExpressWrapperConfig);
-    close(): void;
-    listen(listenPort: number): Promise<void>;
-}
-export {};
+import { ClaireServer } from "./ClaireServer";
+interface ExpressWrapperConfig {
+    maxBodySizeKB?: number;
+}
+export declare class ExpressWrapper {
+    private readonly injector;
+    private readonly socketManager?;
+    private readonly logger;
+    private readonly server;
+    private readonly config?;
+    private readonly httpRequestHandler;
+    private httpServer?;
+    constructor(server: ClaireServer, config?: ExpressWrapperConfig);
+    close(): void;
+    listen(listenPort: number): Promise<void>;
+}
+export {};

package/dist/system/FileUploadHandler.d.ts

@@ -1,10 +1,10 @@
-import { AbstractFileService } from "../service/AbstractFileService";
-import { AbstractFileUploadHandler } from "./AbstractFileUploadHandler";
-export declare class FileUploadHandler extends AbstractFileUploadHandler {
-    readonly fileService: AbstractFileService;
-    constructor(fileService: AbstractFileService);
-    moveFile(fromUri: string, toUri: string): Promise<void>;
-    removeFile(uri: string): Promise<void>;
-    resolvePublicUrl(uri: string): Promise<string>;
-    resolvePrivateUrl(uri: string): Promise<string>;
-}
+import { AbstractFileService } from "../service/AbstractFileService";
+import { AbstractFileUploadHandler } from "./AbstractFileUploadHandler";
+export declare class FileUploadHandler extends AbstractFileUploadHandler {
+    readonly fileService: AbstractFileService;
+    constructor(fileService: AbstractFileService);
+    moveFile(fromUri: string, toUri: string): Promise<void>;
+    removeFile(uri: string): Promise<void>;
+    resolvePublicUrl(uri: string): Promise<string>;
+    resolvePrivateUrl(uri: string): Promise<string>;
+}

package/dist/system/IRequestHandler.d.ts

@@ -1,5 +1,5 @@
-import { RequestOptions } from "../http/common/RequestOptions";
-import { ResponseValues } from "../http/common/ResponseValues";
-export interface IRequestHandler {
-    handle(options: RequestOptions): Promise<ResponseValues>;
-}
+import { RequestOptions } from "../http/common/RequestOptions";
+import { ResponseValues } from "../http/common/ResponseValues";
+export interface IRequestHandler {
+    handle(options: RequestOptions): Promise<ResponseValues>;
+}

package/dist/system/LambdaWrapper.d.ts

@@ -1,17 +1,17 @@
-import { RequestOptions } from "../http/common/RequestOptions";
-import { ClaireServer } from "./ClaireServer";
-interface LambdaResponse {
-    statusCode: number;
-    body: string;
-    headers: any;
-}
-export declare class LambdaWrapper {
-    private readonly injector;
-    private readonly httpRequestHandler;
-    private readonly socketManager?;
-    private readonly server;
-    private readonly requestMapper;
-    constructor(server: ClaireServer, requestMapper: (event: any) => RequestOptions | undefined);
-    handler(event: any): Promise<LambdaResponse>;
-}
-export {};
+import { RequestOptions } from "../http/common/RequestOptions";
+import { ClaireServer } from "./ClaireServer";
+interface LambdaResponse {
+    statusCode: number;
+    body: string;
+    headers: any;
+}
+export declare class LambdaWrapper {
+    private readonly injector;
+    private readonly httpRequestHandler;
+    private readonly socketManager?;
+    private readonly server;
+    private readonly requestMapper;
+    constructor(server: ClaireServer, requestMapper: (event: any) => RequestOptions | undefined);
+    handler(event: any): Promise<LambdaResponse>;
+}
+export {};

package/dist/system/ServerGlobalStore.d.ts

@@ -1,5 +1,5 @@
-import { CoreGlobalStore } from "@clairejs/core";
-import { MountedEndpointInfo } from "../http/controller/MountedEndpointInfo";
-export interface ServerGlobalStore extends CoreGlobalStore {
-    mountedEndpointInfo?: MountedEndpointInfo[];
-}
+import { CoreGlobalStore } from "@clairejs/core";
+import { MountedEndpointInfo } from "../http/controller/MountedEndpointInfo";
+export interface ServerGlobalStore extends CoreGlobalStore {
+    mountedEndpointInfo?: MountedEndpointInfo[];
+}

package/package.json

@@ -1,59 +1,59 @@
-{
-    "name": "@clairejs/server",
-    "version": "3.1.11",
-    "description": "Claire server NodeJs framework written in Typescript.",
-    "types": "dist/index.d.ts",
-    "main": "dist/index.js",
-    "scripts": {
-        "test-db": "mocha -r ts-node/register ./test/database.test.ts",
-        "test-http": "mocha -r ts-node/register ./test/e2e/e2e.test.ts",
-        "test": "npm run test-db && npm run test-http",
-        "build": "rm -rf ./dist && webpack --mode production --display-modules",
-        "push": "npm run build && npm test && npm publish && git push"
-    },
-    "author": "immort",
-    "license": "ISC",
-    "dependencies": {
-        "aws-sdk": "^2.841.0",
-        "cors": "^2.8.5",
-        "express": "^4.17.1",
-        "express-fileupload": "^1.2.1",
-        "mysql2": "^2.2.5",
-        "parseurl": "^1.3.3",
-        "path-to-regexp": "^6.2.0",
-        "pg": "^8.5.1",
-        "pg-hstore": "^2.3.4",
-        "query-string": "^6.14.0",
-        "redis": "^3.0.2",
-        "reflect-metadata": "^0.1.13",
-        "sequelize": "^6.5.0",
-        "sequelize-cli": "^6.2.0",
-        "ws": "^7.5.5"
-    },
-    "peerDependencies": {
-        "@clairejs/core": "^3.0.27"
-    },
-    "devDependencies": {
-        "@types/body-parser": "^1.19.0",
-        "@types/cors": "^2.8.9",
-        "@types/express": "^4.17.11",
-        "@types/express-fileupload": "^1.1.6",
-        "@types/mocha": "^8.2.2",
-        "@types/node": "^14.14.25",
-        "@types/parseurl": "^1.3.1",
-        "@types/redis": "^2.8.28",
-        "@types/validator": "^13.1.3",
-        "@types/webpack-env": "^1.16.0",
-        "@types/ws": "^7.4.0",
-        "axios": "^0.21.1",
-        "mocha": "^8.3.2",
-        "terser-webpack-plugin": "^4.2.3",
-        "ts-loader": "^8.0.17",
-        "ts-node": "^9.1.1",
-        "tslib": "^2.1.0",
-        "typescript": "^4.4.4",
-        "webpack": "^4.46.0",
-        "webpack-cli": "^3.3.12",
-        "webpack-node-externals": "^2.5.1"
-    }
-}
+{
+    "name": "@clairejs/server",
+    "version": "3.1.12",
+    "description": "Claire server NodeJs framework written in Typescript.",
+    "types": "dist/index.d.ts",
+    "main": "dist/index.js",
+    "scripts": {
+        "test-db": "mocha -r ts-node/register ./test/database.test.ts",
+        "test-http": "mocha -r ts-node/register ./test/e2e/e2e.test.ts",
+        "test": "npm run test-db && npm run test-http",
+        "build": "rm -rf ./dist && webpack --mode production --display-modules",
+        "push": "npm run build && npm test && npm publish && git push"
+    },
+    "author": "immort",
+    "license": "ISC",
+    "dependencies": {
+        "aws-sdk": "^2.841.0",
+        "cors": "^2.8.5",
+        "express": "^4.17.1",
+        "express-fileupload": "^1.2.1",
+        "mysql2": "^2.2.5",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^6.2.0",
+        "pg": "^8.5.1",
+        "pg-hstore": "^2.3.4",
+        "query-string": "^6.14.0",
+        "redis": "^3.0.2",
+        "reflect-metadata": "^0.1.13",
+        "sequelize": "^6.5.0",
+        "sequelize-cli": "^6.2.0",
+        "ws": "^7.5.5"
+    },
+    "peerDependencies": {
+        "@clairejs/core": "^3.0.28"
+    },
+    "devDependencies": {
+        "@types/body-parser": "^1.19.0",
+        "@types/cors": "^2.8.9",
+        "@types/express": "^4.17.11",
+        "@types/express-fileupload": "^1.1.6",
+        "@types/mocha": "^8.2.2",
+        "@types/node": "^14.14.25",
+        "@types/parseurl": "^1.3.1",
+        "@types/redis": "^2.8.28",
+        "@types/validator": "^13.1.3",
+        "@types/webpack-env": "^1.16.0",
+        "@types/ws": "^7.4.0",
+        "axios": "^0.21.1",
+        "mocha": "^8.3.2",
+        "terser-webpack-plugin": "^4.2.3",
+        "ts-loader": "^8.0.17",
+        "ts-node": "^9.1.1",
+        "tslib": "^2.1.0",
+        "typescript": "^4.4.4",
+        "webpack": "^4.46.0",
+        "webpack-cli": "^3.3.12",
+        "webpack-node-externals": "^2.5.1"
+    }
+}