@clairejs/server 3.2.8 → 3.3.2

package/dist/job/RedisJobManager.d.ts

@@ -0,0 +1,6 @@
+import { AbstractJobManager } from "./AbstractJobManager";
+import { Job } from "./Job";
+export declare class RedisJobManager extends AbstractJobManager {
+    publishJobs(jobs: Job[]): Promise<void>;
+    retrieveJob(): Promise<Job | undefined>;
+}

package/dist/job/SnsJobManager.d.ts

@@ -0,0 +1,6 @@
+import { AbstractJobManager } from "./AbstractJobManager";
+import { Job } from "./Job";
+export declare class SnsJobManager extends AbstractJobManager {
+    publishJobs(jobs: Job[]): Promise<void>;
+    retrieveJob(): Promise<Job | undefined>;
+}

package/dist/logging/FileLogMedium.d.ts

@@ -1,13 +1,13 @@
-import { LogLevel, ILogMedium } from "@clairejs/core";
-export declare class FileLogMedium implements ILogMedium {
-    private static readonly levels;
-    private readonly destination;
-    private readonly separated;
-    constructor(config: {
-        destination: string;
-        separated?: boolean;
-    });
-    init(): Promise<void>;
-    exit(): void;
-    write(level: LogLevel, content: string): void;
-}
+import { LogLevel, ILogMedium } from "@clairejs/core";
+export declare class FileLogMedium implements ILogMedium {
+    private static readonly levels;
+    private readonly destination;
+    private readonly separated;
+    constructor(config: {
+        destination: string;
+        separated?: boolean;
+    });
+    init(): Promise<void>;
+    exit(): void;
+    write(level: LogLevel, content: string): void;
+}

package/dist/service/AbstractCacheService.d.ts

@@ -1,22 +1,22 @@
-export interface MutexLock {
-    unlock(): Promise<void>;
-}
-export interface ICacheTransaction {
-    hset(hash: string, key: string, value: any): void;
-    set(key: string, value: any): void;
-    del(key: string): void;
-    hdel(hash: string, key: string): void;
-    exec(): Promise<any[]>;
-}
-export declare abstract class AbstractCacheService {
-    abstract hget<T>(hash: string, key: string): Promise<T | undefined>;
-    abstract hset<T>(hash: string, key: string, value: T): Promise<void>;
-    abstract hkeys(hash: string): Promise<string[]>;
-    abstract get<T>(key: string): Promise<T | undefined>;
-    abstract set<T>(key: string, value: T): Promise<void>;
-    abstract del(key: string): Promise<void>;
-    abstract hdel(hash: string, key: string): Promise<void>;
-    abstract flush(): Promise<void>;
-    abstract lock(key: string, durationMs: number, timeoutMs?: number): Promise<MutexLock>;
-    abstract createTransaction(): ICacheTransaction;
-}
+export interface MutexLock {
+    unlock(): Promise<void>;
+}
+export interface ICacheTransaction {
+    hset(hash: string, key: string, value: any): void;
+    set(key: string, value: any): void;
+    del(key: string): void;
+    hdel(hash: string, key: string): void;
+    exec(): Promise<any[]>;
+}
+export declare abstract class AbstractCacheService {
+    abstract hget<T>(hash: string, key: string): Promise<T | undefined>;
+    abstract hset<T>(hash: string, key: string, value: T): Promise<void>;
+    abstract hkeys(hash: string): Promise<string[]>;
+    abstract get<T>(key: string): Promise<T | undefined>;
+    abstract set<T>(key: string, value: T): Promise<void>;
+    abstract del(key: string): Promise<void>;
+    abstract hdel(hash: string, key: string): Promise<void>;
+    abstract flush(): Promise<void>;
+    abstract lock(key: string, durationMs: number, timeoutMs?: number): Promise<MutexLock>;
+    abstract createTransaction(): ICacheTransaction;
+}

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,8 +1,8 @@
-import { ITransactionFactory } from "../database/transaction/ITransactionFactory";
-import { ITransactionProvider } from "../database/transaction/ITransactionProvider";
-export declare abstract class AbstractService implements ITransactionProvider, ITransactionFactory {
-    protected readonly databaseAdapter: ITransactionFactory;
-    constructor(databaseAdapter: ITransactionFactory);
-    createTransaction(): Promise<import("..").ITransaction>;
-    getCurrentTransaction(): Promise<import("..").ITransaction>;
-}
+import { ITransactionFactory } from "../database/transaction/ITransactionFactory";
+import { ITransactionProvider } from "../database/transaction/ITransactionProvider";
+export declare abstract class AbstractService implements ITransactionProvider, ITransactionFactory {
+    protected readonly databaseAdapter: ITransactionFactory;
+    constructor(databaseAdapter: ITransactionFactory);
+    createTransaction(): Promise<import("..").ITransaction>;
+    getCurrentTransaction(): Promise<import("..").ITransaction>;
+}

package/dist/socket/AbstractServerSocket.d.ts

@@ -1,39 +1,19 @@
-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 { SocketMessage } from "@clairejs/core";
+import { IPrincipal } from "../common/auth/IPrincipal";
+import { IServerSocket } from "./IServerSocket";
+import { ChannelInfo, ServerSocketInfo } from "./AbstractServerSocketManager";
+export declare abstract class AbstractServerSocket implements IServerSocket {
+    readonly socketInfo: ServerSocketInfo;
+    constructor(socketInfo: ServerSocketInfo);
+    getId(): string;
+    getAuthInfo(): IPrincipal | undefined;
+    send(data: any, channel?: string): void;
+    sendRaw(data: SocketMessage): void;
+    disconnect(): void;
+    removeChannels(channels: string[]): void;
+    addChannels(channelInfos: ChannelInfo[]): void;
+    getChannelsInfo(): ChannelInfo[];
+    abstract physicSend(data: any): void;
+    abstract physicClose(): void;
+    abstract saveSocketInfo(): Promise<void>;
+}

package/dist/socket/AbstractServerSocketManager.d.ts

@@ -1,19 +1,42 @@
-/// <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[]>;
-}
+import { AbstractLogger, SocketMessage } from "@clairejs/core";
+import { SocketData } from "../common/request/SocketData";
+import { AbstractSocketConnectionHandler } from "./AbstractSocketConnectionHandler";
+import { IPrincipal } from "../common/auth/IPrincipal";
+import { AbstractServerSocket } from "./AbstractServerSocket";
+import { MountedEndpointInfo } from "../common/request/MountedEndpointInfo";
+import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
+import { IServerSocket } from "./IServerSocket";
+import { RedisClient } from "redis";
+export interface ChannelInfo {
+    name: string;
+    clientToServerAllowed: boolean;
+    serverToClientAllowed: boolean;
+}
+export interface ServerSocketInfo {
+    id: string;
+    createdAt: number;
+    channels: ChannelInfo[];
+    authInfo?: IPrincipal;
+}
+export declare abstract class AbstractServerSocketManager {
+    protected readonly requireAuthentication: boolean;
+    protected readonly logger: AbstractLogger;
+    protected readonly redisClient: RedisClient;
+    protected readonly connectionHandler: AbstractSocketConnectionHandler;
+    protected readonly authProvider: AbstractHttpAuthorizationProvider;
+    private mountedEndpointInfo?;
+    protected constructor(requireAuthentication: boolean, logger: AbstractLogger, redisClient: RedisClient, connectionHandler: AbstractSocketConnectionHandler, authProvider: AbstractHttpAuthorizationProvider);
+    abstract configure(data?: any): void;
+    protected getUniqueChannelPrefix(): string;
+    protected formatBroadcastData(channel: string, data: any): SocketMessage;
+    protected getUniqueChannelName(channel: string): string;
+    protected getSocketIdsOfChannel(channel: string): Promise<string[]>;
+    abstract createCustomChannel(channel: string): Promise<void>;
+    addSocketToChannel(socketId: string, channelInfos: ChannelInfo[]): Promise<void>;
+    removeSocketFromChannel(socketId: string, channels: string[]): Promise<void>;
+    abstract getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
+    abstract broadcastToChannel(channel: string, data: any): Promise<void>;
+    abstract getById(socketId: string): Promise<AbstractServerSocket | undefined>;
+    handle(socketData: SocketData): Promise<void>;
+    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
+}

package/dist/socket/AbstractSocketConnectionHandler.d.ts

@@ -0,0 +1,6 @@
+import { IServerSocket } from "./IServerSocket";
+export declare abstract class AbstractSocketConnectionHandler {
+    abstract onSocketConnect(socket: IServerSocket): void;
+    abstract onSocketDisconnect(socket: IServerSocket): void;
+    abstract onMessage(socket: IServerSocket, data: any): void;
+}

package/dist/socket/AbstractSocketController.d.ts

@@ -0,0 +1,14 @@
+import { IServerSocket } from "./IServerSocket";
+export declare abstract class AbstractSocketController {
+    readonly channel: string;
+    constructor(channel: string);
+    onChannelJoin(socket: IServerSocket): void;
+    onChannelLeave(socket: IServerSocket): void;
+    /**
+     * Handle the message sent to this channel
+     * @param socket the socket sending message
+     * @param data the data payload being sent
+     * @returns return false to prevent message broadcast
+     */
+    onMessage(socket: IServerSocket, data: any): boolean | void;
+}

package/dist/socket/AwsSocketManager.d.ts

@@ -1,46 +1,33 @@
-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 { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { AbstractServerSocketManager, ServerSocketInfo } from "./AbstractServerSocketManager";
+import { AbstractServerSocket } from "./AbstractServerSocket";
+import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
+import { IPrincipal } from "../common/auth/IPrincipal";
+import { AbstractSocketConnectionHandler } from "./AbstractSocketConnectionHandler";
+import { IServerSocket } from "./IServerSocket";
+export declare class AwsSocketManager extends AbstractServerSocketManager implements IInit {
+    protected readonly authenticationRequired: boolean;
+    protected readonly region: string;
+    protected readonly socketDomainUrl: string;
+    protected readonly redisClient: RedisClient;
+    protected readonly connectionHandler: AbstractSocketConnectionHandler;
+    protected readonly httpRequestHandler: AbstractHttpRequestHandler;
+    protected readonly authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>;
+    protected readonly logger: AbstractLogger;
+    private readonly apiGatewayManagement;
+    constructor(authenticationRequired: boolean, region: string, socketDomainUrl: string, redisClient: RedisClient, connectionHandler: AbstractSocketConnectionHandler, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>, logger: AbstractLogger);
+    init(): Promise<void>;
+    exit(): void;
+    protected getSocketInfoHashKey(): string;
+    physicSend(socketId: string, data: any): Promise<void>;
+    configure(data?: any): void;
+    createCustomChannel(channel: string): Promise<void>;
+    getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
+    broadcastToChannel(channel: string, data: any): Promise<void>;
+    addSocket(socketInfo: ServerSocketInfo, data: any): Promise<AbstractServerSocket>;
+    removeSocket(socketId: string): Promise<void>;
+    private getSocketBySerialized;
+    getById(socketId: string): Promise<AbstractServerSocket | undefined>;
+}

package/dist/socket/IServerSocket.d.ts

@@ -1,8 +1,16 @@
-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 { IPrincipal } from "../common/auth/IPrincipal";
+export interface IServerSocket {
+    getId(): string;
+    getAuthInfo(): IPrincipal | undefined;
+    /**
+     * Send back data to client
+     * @param data The data to send, will be serialized using JSON.stringify
+     */
+    send(data: any, channel?: string): void;
+    /**
+     * Disconnect the socket and optionally provide the error which cause the disconnection.
+     * The client socket will treat this error as intended reason for socket termination.
+     * @param err The error which cause the disconnection
+     */
+    disconnect(err?: any): void;
+}

package/dist/socket/LocalSocketManager.d.ts

@@ -1,23 +1,38 @@
-/// <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, IInit } from "@clairejs/core";
+import WebSocket from "ws";
+import { Server } from "http";
+import { RedisClient } from "redis";
+import { AbstractServerSocketManager, ChannelInfo, ServerSocketInfo } from "./AbstractServerSocketManager";
+import { AbstractSocketConnectionHandler } from "./AbstractSocketConnectionHandler";
+import { AbstractServerSocket } from "./AbstractServerSocket";
+import { AbstractHttpAuthorizationProvider } from "../http/auth/AbstractHttpAuthorizationProvider";
+import { IServerSocket } from "./IServerSocket";
+export declare class LocalSocketManager extends AbstractServerSocketManager implements IInit {
+    protected readonly authenticationRequired: boolean;
+    protected readonly redisClient: RedisClient;
+    protected readonly logger: AbstractLogger;
+    protected readonly authProvider: AbstractHttpAuthorizationProvider;
+    protected readonly connectionHandler: AbstractSocketConnectionHandler;
+    private readonly subClient;
+    private readonly channelSubClient;
+    private readonly sendClient;
+    private allSockets;
+    constructor(authenticationRequired: boolean, redisClient: RedisClient, logger: AbstractLogger, authProvider: AbstractHttpAuthorizationProvider, connectionHandler: AbstractSocketConnectionHandler);
+    init(): Promise<void>;
+    exit(): void;
+    protected getSocketChannelKeyPrefix(): string;
+    protected getSocketInfoHashKey(): string;
+    protected getSocketChannelKey(socketId: string): string;
+    createCustomChannel(channel: string): Promise<void>;
+    broadcastToChannel(channel: string, data: any): Promise<void>;
+    addSocketToChannel(socketId: string, channelInfos: ChannelInfo[]): Promise<void>;
+    removeSocketFromChannel(socketId: string, channels: string[]): Promise<void>;
+    addSocket(socketInfo: ServerSocketInfo, { socket }: {
+        socket: WebSocket;
+    }): Promise<AbstractServerSocket>;
+    removeSocket(socketId: string): Promise<void>;
+    getById(socketId: string): Promise<AbstractServerSocket | undefined>;
+    getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
+    configure(httpServer?: Server): void;
+}

package/dist/system/ClaireServer.d.ts

@@ -1,10 +1,13 @@
-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";
+import { AbstractHttpRequestHandler } from "../http/controller/AbstractHttpRequestHandler";
+import { AbstractServerSocketManager } from "../socket/AbstractServerSocketManager";
+export declare class ClaireServer extends ClaireApp {
+    readonly logger: AbstractLogger;
+    readonly httpRequestHandler: AbstractHttpRequestHandler | undefined;
+    readonly socketManager: AbstractServerSocketManager | undefined;
+    private booted;
+    constructor(logger: AbstractLogger, httpRequestHandler: AbstractHttpRequestHandler | undefined, socketManager: AbstractServerSocketManager | undefined);
+    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/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 "../common/request/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 "../common/request/MountedEndpointInfo";
+export interface ServerGlobalStore extends CoreGlobalStore {
+    mountedEndpointInfo?: MountedEndpointInfo[];
+}

package/dist/system/errors.d.ts

@@ -1,14 +1,14 @@
-export declare const Errors: {
-    TFA_REQUIRED: string;
-    SYSTEM_ERROR: string;
-    HTTP_REQUEST_ERROR: string;
-    SESSION_EXPIRED: string;
-    ACCESS_DENIED: string;
-    AUTHENTICATION_ERROR: string;
-    NOT_FOUND: string;
-    VALIDATION_ERROR: string;
-    BAD_STATE: string;
-    QUERY_ERROR: string;
-    REQUEST_RATE_LIMIT: string;
-    CANNOT_LOCK: string;
-};
+export declare const Errors: {
+    TFA_REQUIRED: string;
+    SYSTEM_ERROR: string;
+    HTTP_REQUEST_ERROR: string;
+    SESSION_EXPIRED: string;
+    ACCESS_DENIED: string;
+    AUTHENTICATION_ERROR: string;
+    NOT_FOUND: string;
+    VALIDATION_ERROR: string;
+    BAD_STATE: string;
+    QUERY_ERROR: string;
+    REQUEST_RATE_LIMIT: string;
+    CANNOT_LOCK: string;
+};