@clairejs/server 3.11.14 → 3.11.16

package/dist/services/AbstractMailService.d.ts

@@ -1,31 +1,31 @@
-import { AbstractLogger } from "@clairejs/core";
-export interface EmailInfo {
-    sender: string;
-    receivers: string[];
-    cc?: string[];
-    bcc?: string[];
-    subject: string;
-    content: string;
-    contentType: "html" | "text";
-}
-export declare abstract class AbstractMailService {
-    abstract send(email: EmailInfo): Promise<void>;
-}
-export interface LocalMailServiceConfig {
-    LOCAL_MAIL_FOLDER: string;
-}
-export declare class LocalMailService extends AbstractMailService {
-    readonly config: LocalMailServiceConfig;
-    constructor(config: LocalMailServiceConfig);
-    send(email: EmailInfo): Promise<void>;
-}
-export interface SesMailServiceConfig {
-    SES_REGION: string;
-}
-export declare class SesMailService extends AbstractMailService {
-    readonly config: SesMailServiceConfig;
-    readonly logger: AbstractLogger;
-    private readonly emailClient;
-    constructor(config: SesMailServiceConfig, logger: AbstractLogger);
-    send(email: EmailInfo): Promise<void>;
-}
+import { AbstractLogger } from "@clairejs/core";
+export interface EmailInfo {
+    sender: string;
+    receivers: string[];
+    cc?: string[];
+    bcc?: string[];
+    subject: string;
+    content: string;
+    contentType: "html" | "text";
+}
+export declare abstract class AbstractMailService {
+    abstract send(email: EmailInfo): Promise<void>;
+}
+export interface LocalMailServiceConfig {
+    LOCAL_MAIL_FOLDER: string;
+}
+export declare class LocalMailService extends AbstractMailService {
+    readonly config: LocalMailServiceConfig;
+    constructor(config: LocalMailServiceConfig);
+    send(email: EmailInfo): Promise<void>;
+}
+export interface SesMailServiceConfig {
+    SES_REGION: string;
+}
+export declare class SesMailService extends AbstractMailService {
+    readonly config: SesMailServiceConfig;
+    readonly logger: AbstractLogger;
+    private readonly emailClient;
+    constructor(config: SesMailServiceConfig, logger: AbstractLogger);
+    send(email: EmailInfo): Promise<void>;
+}

package/dist/services/AbstractService.d.ts

@@ -1,7 +1,7 @@
-import { ITransactionFactory, ITransactionProvider } from "@clairejs/orm";
-export declare abstract class AbstractService implements ITransactionProvider, ITransactionFactory {
-    protected readonly databaseAdapter: ITransactionFactory;
-    constructor(databaseAdapter: ITransactionFactory);
-    createTransaction(): Promise<import("@clairejs/orm").ITransaction>;
-    getCurrentTransaction(): Promise<import("@clairejs/orm").ITransaction>;
-}
+import { ITransactionFactory, ITransactionProvider } from "@clairejs/orm";
+export declare abstract class AbstractService implements ITransactionProvider, ITransactionFactory {
+    protected readonly databaseAdapter: ITransactionFactory;
+    constructor(databaseAdapter: ITransactionFactory);
+    createTransaction(): Promise<import("@clairejs/orm").ITransaction>;
+    getCurrentTransaction(): Promise<import("@clairejs/orm").ITransaction>;
+}

package/dist/services/AbstractSmsService.d.ts

@@ -1,25 +1,25 @@
-import { AbstractLogger } from "@clairejs/core";
-export declare abstract class AbstractSmsService {
-    abstract send(fromNumber: string, toNumber: string, content: string): Promise<void>;
-}
-export interface LocalSmsServiceConfig {
-    LOCAL_SMS_FOLDER: string;
-}
-export declare class LocalSmsService extends AbstractSmsService {
-    readonly config: LocalSmsServiceConfig;
-    constructor(config: LocalSmsServiceConfig);
-    exit(): number;
-    send(fromNumber: string, toNumber: string, content: string): Promise<void>;
-}
-export interface TwilioSmsServiceConfig {
-    TWILIO_ACCOUNT_SID: string;
-    TWILIO_AUTH_TOKEN: string;
-}
-export declare class TwilioSmsService extends AbstractSmsService {
-    readonly config: TwilioSmsServiceConfig;
-    readonly logger: AbstractLogger;
-    private client;
-    constructor(config: TwilioSmsServiceConfig, logger: AbstractLogger);
-    exit(): number;
-    send(fromNumber: string, toNumber: string, content: string): Promise<void>;
-}
+import { AbstractLogger } from "@clairejs/core";
+export declare abstract class AbstractSmsService {
+    abstract send(fromNumber: string, toNumber: string, content: string): Promise<void>;
+}
+export interface LocalSmsServiceConfig {
+    LOCAL_SMS_FOLDER: string;
+}
+export declare class LocalSmsService extends AbstractSmsService {
+    readonly config: LocalSmsServiceConfig;
+    constructor(config: LocalSmsServiceConfig);
+    exit(): number;
+    send(fromNumber: string, toNumber: string, content: string): Promise<void>;
+}
+export interface TwilioSmsServiceConfig {
+    TWILIO_ACCOUNT_SID: string;
+    TWILIO_AUTH_TOKEN: string;
+}
+export declare class TwilioSmsService extends AbstractSmsService {
+    readonly config: TwilioSmsServiceConfig;
+    readonly logger: AbstractLogger;
+    private client;
+    constructor(config: TwilioSmsServiceConfig, logger: AbstractLogger);
+    exit(): number;
+    send(fromNumber: string, toNumber: string, content: string): Promise<void>;
+}

package/dist/services/LocalFileService.d.ts

@@ -1,17 +1,17 @@
-import { FileOperation } from "../common/FileOperation";
-import { AbstractFileService } from "./AbstractFileService";
-export interface LocalFileServiceConfig {
-    FILE_SERVER_URL: string;
-}
-export declare class LocalFileService extends AbstractFileService {
-    readonly config: LocalFileServiceConfig;
-    constructor(config: LocalFileServiceConfig);
-    getFileSize(objectKeys: string[]): Promise<number[]>;
-    getAccessUrls(uris: string[], _isPublic: boolean): Promise<string[]>;
-    getPresignedUrl(_operation: FileOperation, uris: string[]): Promise<string[]>;
-    moveObject(uris: {
-        fromURI: string;
-        toURI: string;
-    }[]): Promise<void>;
-    removeObject(uris: string[]): Promise<void>;
-}
+import { FileOperation } from "../common/FileOperation";
+import { AbstractFileService } from "./AbstractFileService";
+export interface LocalFileServiceConfig {
+    FILE_SERVER_URL: string;
+}
+export declare class LocalFileService extends AbstractFileService {
+    readonly config: LocalFileServiceConfig;
+    constructor(config: LocalFileServiceConfig);
+    getFileSize(objectKeys: string[]): Promise<number[]>;
+    getAccessUrls(uris: string[], _isPublic: boolean): Promise<string[]>;
+    getPresignedUrl(_operation: FileOperation, uris: string[]): Promise<string[]>;
+    moveObject(uris: {
+        fromURI: string;
+        toURI: string;
+    }[]): Promise<void>;
+    removeObject(uris: string[]): Promise<void>;
+}

package/dist/services/ProxyFileService.d.ts

@@ -1,16 +1,16 @@
-import { AbstractHttpClient } from "@clairejs/client";
-import { AbstractFileService } from "./AbstractFileService";
-import { FileOperation } from "../common/FileOperation";
-export declare class ProxyFileService extends AbstractFileService {
-    readonly fileServiceHttpClient: AbstractHttpClient;
-    readonly publicFileServerEndpoint: string;
-    constructor(fileServiceHttpClient: AbstractHttpClient, publicFileServerEndpoint: string);
-    getFileSize(objectKeys: string[]): Promise<number[]>;
-    getAccessUrls(uris: string[], isPublic: boolean): Promise<string[]>;
-    getPresignedUrl(_operation: FileOperation, _uris: string[]): Promise<string[]>;
-    moveObject(uris: {
-        fromURI: string;
-        toURI: string;
-    }[]): Promise<void>;
-    removeObject(uris: string[]): Promise<void>;
-}
+import { AbstractHttpClient } from "@clairejs/client";
+import { AbstractFileService } from "./AbstractFileService";
+import { FileOperation } from "../common/FileOperation";
+export declare class ProxyFileService extends AbstractFileService {
+    readonly fileServiceHttpClient: AbstractHttpClient;
+    readonly publicFileServerEndpoint: string;
+    constructor(fileServiceHttpClient: AbstractHttpClient, publicFileServerEndpoint: string);
+    getFileSize(objectKeys: string[]): Promise<number[]>;
+    getAccessUrls(uris: string[], isPublic: boolean): Promise<string[]>;
+    getPresignedUrl(_operation: FileOperation, _uris: string[]): Promise<string[]>;
+    moveObject(uris: {
+        fromURI: string;
+        toURI: string;
+    }[]): Promise<void>;
+    removeObject(uris: string[]): Promise<void>;
+}

package/dist/services/RedisCacheService.d.ts

@@ -1,25 +1,25 @@
-import { AbstractLogger, IInit } from "@clairejs/core";
-import Client from "ioredis";
-import { AbstractCacheService, ICacheTransaction, MutexLock } from "./AbstractCacheService";
-export interface RedisCacheServiceConfig {
-    REDIS_SERVER: string;
-}
-export declare class RedisCacheService extends AbstractCacheService implements IInit {
-    readonly config: RedisCacheServiceConfig;
-    readonly logger: AbstractLogger;
-    private _redisClient?;
-    constructor(config: RedisCacheServiceConfig, logger: AbstractLogger);
-    get redisClient(): Client;
-    createTransaction(): ICacheTransaction;
-    init(): Promise<void>;
-    exit(): number;
-    flush(): Promise<void>;
-    hkeys(hash: string): Promise<string[]>;
-    del(key: string): Promise<void>;
-    hdel(hash: string, key: string): Promise<void>;
-    hget<T>(hash: string, key: string): Promise<T | undefined>;
-    hset<T>(hash: string, key: string, data: T): Promise<void>;
-    get<T>(key: string): Promise<T | undefined>;
-    set<T>(key: string, value: T, expiredSeconds?: number): Promise<void>;
-    lock(key: string, durationMs: number, timeoutMs?: number): Promise<MutexLock>;
-}
+import { AbstractLogger, IInit } from "@clairejs/core";
+import Client from "ioredis";
+import { AbstractCacheService, ICacheTransaction, MutexLock } from "./AbstractCacheService";
+export interface RedisCacheServiceConfig {
+    REDIS_SERVER: string;
+}
+export declare class RedisCacheService extends AbstractCacheService implements IInit {
+    readonly config: RedisCacheServiceConfig;
+    readonly logger: AbstractLogger;
+    private _redisClient?;
+    constructor(config: RedisCacheServiceConfig, logger: AbstractLogger);
+    get redisClient(): Client;
+    createTransaction(): ICacheTransaction;
+    init(): Promise<void>;
+    exit(): number;
+    flush(): Promise<void>;
+    hkeys(hash: string): Promise<string[]>;
+    del(key: string): Promise<void>;
+    hdel(hash: string, key: string): Promise<void>;
+    hget<T>(hash: string, key: string): Promise<T | undefined>;
+    hset<T>(hash: string, key: string, data: T): Promise<void>;
+    get<T>(key: string): Promise<T | undefined>;
+    set<T>(key: string, value: T, expiredSeconds?: number): Promise<void>;
+    lock(key: string, durationMs: number, timeoutMs?: number): Promise<MutexLock>;
+}

package/dist/services/S3FileService.d.ts

@@ -1,31 +1,31 @@
-import { AbstractLogger } from "@clairejs/core";
-import { FileOperation } from "../common/FileOperation";
-import { AbstractFileService } from "./AbstractFileService";
-export interface S3FileServiceConfig {
-    S3_BUCKET_NAME: string;
-    S3_BUCKET_REGION: string;
-    PRESIGNED_URL_EXPIRATION_S: number;
-    CLOUD_FRONT_PUBLIC_KEY_ID: string;
-    CLOUD_FRONT_PRIVATE_KEY_BASE64: string;
-    CLOUD_FRONT_PUBLIC_DOMAIN: string;
-}
-export declare class S3FileService extends AbstractFileService {
-    readonly config: S3FileServiceConfig;
-    readonly logger: AbstractLogger;
-    private readonly s3Client;
-    private readonly cloudfrontSigner;
-    constructor(config: S3FileServiceConfig, logger: AbstractLogger);
-    getFileSize(objectKeys: string[]): Promise<number[]>;
-    getAccessUrls(uris: string[], isPublic: boolean): Promise<string[]>;
-    getPresignedUrl(operation: FileOperation, uris: string[]): Promise<string[]>;
-    moveObject(uris: {
-        fromURI: string;
-        toURI: string;
-    }[]): Promise<void>;
-    removeObject(uris: string[]): Promise<void>;
-    private getSingleFileSize;
-    private getSinglePresignedUrl;
-    private moveSingleObject;
-    private getSingleAccessUrl;
-    private removeSingleObject;
-}
+import { AbstractLogger } from "@clairejs/core";
+import { FileOperation } from "../common/FileOperation";
+import { AbstractFileService } from "./AbstractFileService";
+export interface S3FileServiceConfig {
+    S3_BUCKET_NAME: string;
+    S3_BUCKET_REGION: string;
+    PRESIGNED_URL_EXPIRATION_S: number;
+    CLOUD_FRONT_PUBLIC_KEY_ID: string;
+    CLOUD_FRONT_PRIVATE_KEY_BASE64: string;
+    CLOUD_FRONT_PUBLIC_DOMAIN: string;
+}
+export declare class S3FileService extends AbstractFileService {
+    readonly config: S3FileServiceConfig;
+    readonly logger: AbstractLogger;
+    private readonly s3Client;
+    private readonly cloudfrontSigner;
+    constructor(config: S3FileServiceConfig, logger: AbstractLogger);
+    getFileSize(objectKeys: string[]): Promise<number[]>;
+    getAccessUrls(uris: string[], isPublic: boolean): Promise<string[]>;
+    getPresignedUrl(operation: FileOperation, uris: string[]): Promise<string[]>;
+    moveObject(uris: {
+        fromURI: string;
+        toURI: string;
+    }[]): Promise<void>;
+    removeObject(uris: string[]): Promise<void>;
+    private getSingleFileSize;
+    private getSinglePresignedUrl;
+    private moveSingleObject;
+    private getSingleAccessUrl;
+    private removeSingleObject;
+}

package/dist/services/SystemService.d.ts

@@ -1,15 +1,15 @@
-import { Constructor } from "@clairejs/core";
-import { AbstractDatabaseAdapter } from "@clairejs/orm";
-import { AbstractCacheService } from "./AbstractCacheService";
-import { AbstractService } from "./AbstractService";
-import { ApiInfoResponse } from "../controllers/dto/permissions";
-import { CacheOperation } from "../controllers/dto/system";
-export declare class SystemService extends AbstractService {
-    readonly cacheService: AbstractCacheService;
-    readonly databaseAdapter: AbstractDatabaseAdapter;
-    constructor(cacheService: AbstractCacheService, databaseAdapter: AbstractDatabaseAdapter);
-    getApiInfo(): Promise<ApiInfoResponse>;
-    getCacheValue(operation: CacheOperation, keys: string[]): Promise<unknown>;
-    getSystemSettings<T>(settingTemplate: Constructor<T>): Promise<T>;
-    updateSystemSetting(settings: object): Promise<void>;
-}
+import { Constructor } from "@clairejs/core";
+import { AbstractDatabaseAdapter } from "@clairejs/orm";
+import { AbstractCacheService } from "./AbstractCacheService";
+import { AbstractService } from "./AbstractService";
+import { ApiInfoResponse } from "../controllers/dto/permissions";
+import { CacheOperation } from "../controllers/dto/system";
+export declare class SystemService extends AbstractService {
+    readonly cacheService: AbstractCacheService;
+    readonly databaseAdapter: AbstractDatabaseAdapter;
+    constructor(cacheService: AbstractCacheService, databaseAdapter: AbstractDatabaseAdapter);
+    getApiInfo(): Promise<ApiInfoResponse>;
+    getCacheValue(operation: CacheOperation, keys: string[]): Promise<unknown>;
+    getSystemSettings<T>(settingTemplate: Constructor<T>): Promise<T>;
+    updateSystemSetting(settings: object): Promise<void>;
+}

package/dist/socket/AbstractServerSocket.d.ts

@@ -1,18 +1,18 @@
-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): Promise<void>;
-    sendRaw(data: SocketMessage): Promise<void>;
-    removeChannels(channels: string[]): void;
-    addChannels(channelInfos: ChannelInfo[]): void;
-    getChannelsInfo(): ChannelInfo[];
-    abstract disconnect(err?: any): Promise<void>;
-    abstract physicSend(data: any): Promise<void>;
-    abstract saveSocketInfo(): 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): Promise<void>;
+    sendRaw(data: SocketMessage): Promise<void>;
+    removeChannels(channels: string[]): void;
+    addChannels(channelInfos: ChannelInfo[]): void;
+    getChannelsInfo(): ChannelInfo[];
+    abstract disconnect(err?: any): Promise<void>;
+    abstract physicSend(data: any): Promise<void>;
+    abstract saveSocketInfo(): Promise<void>;
+}

package/dist/socket/AbstractServerSocketManager.d.ts

@@ -1,46 +1,46 @@
-import { AbstractLogger, SocketMessage } from "@clairejs/core";
-import Client from "ioredis";
-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";
-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 redisServerUrl: string;
-    protected readonly authProvider: AbstractHttpAuthorizationProvider;
-    protected readonly authResolver: (queries?: any) => any;
-    private mountedEndpointInfo?;
-    private _connectionHandler?;
-    protected redisClient: Client;
-    protected constructor(requireAuthentication: boolean, logger: AbstractLogger, redisServerUrl: string, authProvider: AbstractHttpAuthorizationProvider, authResolver: (queries?: any) => any);
-    abstract configure(data?: any): void;
-    protected getUniqueChannelPrefix(): string;
-    protected getSocketInfoHashKey(): string;
-    protected getConnectionHandler(): Promise<AbstractSocketConnectionHandler | undefined>;
-    protected formatBroadcastData(channel: string, data: any): SocketMessage;
-    protected getUniqueChannelName(channel: string): string;
-    protected getSocketIdsOfChannel(channel: string): Promise<string[]>;
-    addSocketToChannel(socketId: string, channelInfos: ChannelInfo[]): Promise<AbstractServerSocket | undefined>;
-    removeSocketFromChannel(socketId: string, channels: string[], persist?: boolean): Promise<void>;
-    abstract getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
-    abstract broadcastToChannel(channel: string, data: any): Promise<void>;
-    removeSocket(socketId: string, physicRemove?: boolean): Promise<void>;
-    abstract getById(socketId: string): Promise<AbstractServerSocket | undefined>;
-    handle(socketData: SocketData): Promise<void>;
-    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
-}
+import { AbstractLogger, SocketMessage } from "@clairejs/core";
+import Client from "ioredis";
+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";
+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 redisServerUrl: string;
+    protected readonly authProvider: AbstractHttpAuthorizationProvider;
+    protected readonly authResolver: (queries?: any) => any;
+    private mountedEndpointInfo?;
+    private _connectionHandler?;
+    protected redisClient: Client;
+    protected constructor(requireAuthentication: boolean, logger: AbstractLogger, redisServerUrl: string, authProvider: AbstractHttpAuthorizationProvider, authResolver: (queries?: any) => any);
+    abstract configure(data?: any): void;
+    protected getUniqueChannelPrefix(): string;
+    protected getSocketInfoHashKey(): string;
+    protected getConnectionHandler(): Promise<AbstractSocketConnectionHandler | undefined>;
+    protected formatBroadcastData(channel: string, data: any): SocketMessage;
+    protected getUniqueChannelName(channel: string): string;
+    protected getSocketIdsOfChannel(channel: string): Promise<string[]>;
+    addSocketToChannel(socketId: string, channelInfos: ChannelInfo[]): Promise<AbstractServerSocket | undefined>;
+    removeSocketFromChannel(socketId: string, channels: string[], persist?: boolean): Promise<void>;
+    abstract getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
+    abstract broadcastToChannel(channel: string, data: any): Promise<void>;
+    removeSocket(socketId: string, physicRemove?: boolean): Promise<void>;
+    abstract getById(socketId: string): Promise<AbstractServerSocket | undefined>;
+    handle(socketData: SocketData): Promise<void>;
+    getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;
+}

package/dist/socket/AbstractSocketConnectionHandler.d.ts

@@ -1,6 +1,6 @@
-import { IServerSocket } from "./IServerSocket";
-export declare abstract class AbstractSocketConnectionHandler {
-    abstract onSocketConnect(socket: IServerSocket): Promise<void>;
-    abstract onSocketDisconnect(socket: IServerSocket): Promise<void>;
-    abstract onMessage(socket: IServerSocket, message: any, channel?: string): Promise<void>;
-}
+import { IServerSocket } from "./IServerSocket";
+export declare abstract class AbstractSocketConnectionHandler {
+    abstract onSocketConnect(socket: IServerSocket): Promise<void>;
+    abstract onSocketDisconnect(socket: IServerSocket): Promise<void>;
+    abstract onMessage(socket: IServerSocket, message: any, channel?: string): Promise<void>;
+}

package/dist/socket/AbstractSocketController.d.ts

@@ -1,14 +1,14 @@
-import { IServerSocket } from "./IServerSocket";
-export declare abstract class AbstractSocketController {
-    readonly channel: string;
-    constructor(channel: string);
-    onChannelJoin(socket: IServerSocket): Promise<void>;
-    onChannelLeave(socket: IServerSocket): Promise<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, message: any): Promise<boolean | void>;
-}
+import { IServerSocket } from "./IServerSocket";
+export declare abstract class AbstractSocketController {
+    readonly channel: string;
+    constructor(channel: string);
+    onChannelJoin(socket: IServerSocket): Promise<void>;
+    onChannelLeave(socket: IServerSocket): Promise<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, message: any): Promise<boolean | void>;
+}

package/dist/socket/AwsSocketManager.d.ts

@@ -1,30 +1,30 @@
-import { AbstractLogger, IInit } from "@clairejs/core";
-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 { 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 redisServerUrl: string;
-    protected readonly httpRequestHandler: AbstractHttpRequestHandler;
-    protected readonly authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>;
-    protected readonly authResolver: (queries?: any) => any;
-    protected readonly logger: AbstractLogger;
-    private readonly apiGatewayManagement;
-    constructor(authenticationRequired: boolean, region: string, socketDomainUrl: string, redisServerUrl: string, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>, authResolver: (queries?: any) => any, logger: AbstractLogger);
-    init(): Promise<void>;
-    exit(): void;
-    removeSocketFromRedis(socketId: string): Promise<void>;
-    physicSend(socketId: string, data: any): Promise<void>;
-    configure(data?: any): void;
-    getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
-    broadcastToChannel(channel: string, data: any): Promise<void>;
-    addSocket(socketInfo: ServerSocketInfo, data: any): Promise<AbstractServerSocket>;
-    removeSocket(socketId: string, physicRemove?: boolean): Promise<void>;
-    private getSocketBySerialized;
-    getById(socketId: string): Promise<AbstractServerSocket | undefined>;
-}
+import { AbstractLogger, IInit } from "@clairejs/core";
+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 { 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 redisServerUrl: string;
+    protected readonly httpRequestHandler: AbstractHttpRequestHandler;
+    protected readonly authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>;
+    protected readonly authResolver: (queries?: any) => any;
+    protected readonly logger: AbstractLogger;
+    private readonly apiGatewayManagement;
+    constructor(authenticationRequired: boolean, region: string, socketDomainUrl: string, redisServerUrl: string, httpRequestHandler: AbstractHttpRequestHandler, authorizationProvider: AbstractHttpAuthorizationProvider<IPrincipal>, authResolver: (queries?: any) => any, logger: AbstractLogger);
+    init(): Promise<void>;
+    exit(): void;
+    removeSocketFromRedis(socketId: string): Promise<void>;
+    physicSend(socketId: string, data: any): Promise<void>;
+    configure(data?: any): void;
+    getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
+    broadcastToChannel(channel: string, data: any): Promise<void>;
+    addSocket(socketInfo: ServerSocketInfo, data: any): Promise<AbstractServerSocket>;
+    removeSocket(socketId: string, physicRemove?: boolean): Promise<void>;
+    private getSocketBySerialized;
+    getById(socketId: string): Promise<AbstractServerSocket | undefined>;
+}

package/dist/socket/IServerSocket.d.ts

@@ -1,16 +1,16 @@
-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): Promise<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): Promise<void>;
-}
+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): Promise<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): Promise<void>;
+}