@logux/server 0.12.2 → 0.12.4

package/base-server/index.d.ts

@@ -1,172 +1,185 @@
-import {
+import type {
+  AbstractActionCreator,
+  LoguxSubscribeAction,
+  LoguxUnsubscribeAction
+} from '@logux/actions'
+import type {
   Action,
   AnyAction,
   ID,
   Log,
+  LogStore,
   Meta,
   ServerConnection,
-  LogStore,
   TestTime
 } from '@logux/core'
-import { Server as HTTPServer, ServerResponse, IncomingMessage } from 'http'
-import {
-  LoguxUnsubscribeAction,
-  AbstractActionCreator,
-  LoguxSubscribeAction
-} from '@logux/actions'
-import { Unsubscribe } from 'nanoevents'
-import { LogFn } from 'pino'
+import type { Server as HTTPServer, IncomingMessage, ServerResponse } from 'http'
+import type { Unsubscribe } from 'nanoevents'
+import type { LogFn } from 'pino'
 
-import { Context, ChannelContext } from '../context/index.js'
-import { ServerClient } from '../server-client/index.js'
+import type { ChannelContext, Context } from '../context/index.js'
+import type { ServerClient } from '../server-client/index.js'
 
 export interface ServerMeta extends Meta {
   /**
-   * Action processing status
+   * All nodes subscribed to channel will receive the action.
    */
-  status?: 'waiting' | 'processed' | 'error'
+  channel?: string
 
   /**
-   * Node ID of the server received the action.
+   * All nodes subscribed to listed channels will receive the action.
    */
-  server: string
+  channels?: string[]
 
   /**
-   * All nodes subscribed to listed channels will receive the action.
+   * All nodes with listed client ID will receive the action.
    */
-  channels?: string[]
+  client?: string
 
   /**
-   * All nodes subscribed to channel will receive the action.
+   * All nodes with listed client IDs will receive the action.
    */
-  channel?: string
+  clients?: string[]
 
   /**
-   * All nodes with listed user IDs will receive the action.
+   * Client IDs, which will not receive the action.
    */
-  users?: string[]
+  excludeClients?: string[]
 
   /**
-   * All nodes with listed user ID will receive the action.
+   * Node with listed node ID will receive the action.
    */
-  user?: string
+  node?: string
 
   /**
-   * All nodes with listed client IDs will receive the action.
+   * All nodes with listed node IDs will receive the action.
    */
-  clients?: string[]
+  nodes?: string[]
 
   /**
-   * All nodes with listed client ID will receive the action.
+   * Node ID of the server received the action.
    */
-  client?: string
+  server: string
 
   /**
-   * All nodes with listed node IDs will receive the action.
+   * Action processing status
    */
-  nodes?: string[]
+  status?: 'error' | 'processed' | 'waiting'
 
   /**
-   * Node with listed node ID will receive the action.
+   * All nodes with listed user ID will receive the action.
    */
-  node?: string
+  user?: string
 
   /**
-   * Client IDs, which will not receive the action.
+   * All nodes with listed user IDs will receive the action.
    */
-  excludeClients?: string[]
+  users?: string[]
 }
 
 export interface BaseServerOptions {
   /**
-   * Server current application subprotocol version in SemVer format.
+   * URL to PHP, Ruby on Rails, or other backend to process actions and
+   * authentication.
    */
-  subprotocol?: string
+  backend?: string
 
   /**
-   * npm’s version requirements for client subprotocol version.
+   * SSL certificate or path to it. Path could be relative from server
+   * root. It is required in production mode, because WSS is highly
+   * recommended.
    */
-  supports?: string
+  cert?: string
 
   /**
-   * Application root to load files and show errors.
-   * Default is `process.cwd()`.
+   * Regular expression which should be cleaned from error message and stack.
    *
-   * ```js
-   * root: __dirname
-   * ```
+   * By default it cleans `Bearer [^\s"]+`.
    */
-  root?: string
+  cleanFromLog?: RegExp
 
   /**
-   * URL of main JS file in the root dir. Shortcut to set `root` in ES modules
-   * without `fileURLToPath`.
-   *
-   * ```
-   * fileUrl: import.meta.url
-   * ```
+   * CIDR masks for IP address, where control requests could came from.
    */
-  fileUrl?: string
+  controlMask?: string
 
   /**
-   * Timeout in milliseconds to disconnect connection.
-   * Default is `20000`.
+   * Secret to control the server.
    */
-  timeout?: number
+  controlSecret?: string
 
   /**
-   * Milliseconds since last message to test connection by sending ping.
-   * Default is `10000`.
+   * Disable health check endpoint, control HTTP API, {@link Server#http}.
+   *
+   * The server will process only WebSocket connection and ignore all other
+   * HTTP request (so they can be processed by other HTTP server).
    */
-  ping?: number
+  disableHttpServer?: boolean
 
   /**
-   * URL to PHP, Ruby on Rails, or other backend to process actions and
-   * authentication.
+   * Development or production server mode. By default,
+   * it will be taken from `NODE_ENV` environment variable.
+   * On empty `NODE_ENV` it will be `'development'`.
    */
-  backend?: string
+  env?: 'development' | 'production'
 
   /**
-   * URL to Redis for Logux Server Pro scaling.
+   * URL of main JS file in the root dir. Shortcut to set `root` in ES modules
+   * without `fileURLToPath`.
+   *
+   * ```
+   * fileUrl: import.meta.url
+   * ```
    */
-  redis?: string
+  fileUrl?: string
 
   /**
-   * Secret to control the server.
+   * IP-address to bind server. Default is `127.0.0.1`.
    */
-  controlSecret?: string
+  host?: string
 
   /**
-   * CIDR masks for IP address, where control requests could came from.
+   * Custom random ID to be used in node ID.
    */
-  controlMask?: string
+  id?: string
 
   /**
-   * Store to save log. Will be {@link @logux/core:MemoryStore}, by default.
+   * SSL key or path to it. Path could be relative from server root.
+   * It is required in production mode, because WSS is highly recommended.
    */
-  store?: LogStore
+  key?: { pem: string } | string
 
   /**
-   * Test time to test server.
+   * Process ID, to display in logs.
    */
-  time?: TestTime
+  pid?: number
 
   /**
-   * Custom random ID to be used in node ID.
+   * Milliseconds since last message to test connection by sending ping.
+   * Default is `20000`.
    */
-  id?: string
+  ping?: number
 
   /**
-   * Development or production server mode. By default,
-   * it will be taken from `NODE_ENV` environment variable.
-   * On empty `NODE_ENV` it will be `'development'`.
+   * Port to bind server. It will create HTTP server manually to connect
+   * WebSocket server to it. Default is `31337`.
    */
-  env?: 'production' | 'development'
+  port?: number
 
   /**
-   * Process ID, to display in logs.
+   * URL to Redis for Logux Server Pro scaling.
    */
-  pid?: number
+  redis?: string
+
+  /**
+   * Application root to load files and show errors.
+   * Default is `process.cwd()`.
+   *
+   * ```js
+   * root: __dirname
+   * ```
+   */
+  root?: string
 
   /**
    * HTTP server to serve Logux’s WebSocket and HTTP requests.
@@ -177,58 +190,45 @@ export interface BaseServerOptions {
   server?: HTTPServer
 
   /**
-   * Port to bind server. It will create HTTP server manually to connect
-   * WebSocket server to it. Default is `31337`.
-   */
-  port?: number
-
-  /**
-   * IP-address to bind server. Default is `127.0.0.1`.
+   * Store to save log. Will be {@link @logux/core:MemoryStore}, by default.
    */
-  host?: string
+  store?: LogStore
 
   /**
-   * SSL key or path to it. Path could be relative from server root.
-   * It is required in production mode, because WSS is highly recommended.
+   * Server current application subprotocol version in SemVer format.
    */
-  key?: string | { pem: string }
+  subprotocol?: string
 
   /**
-   * SSL certificate or path to it. Path could be relative from server
-   * root. It is required in production mode, because WSS is highly
-   * recommended.
+   * npm’s version requirements for client subprotocol version.
    */
-  cert?: string
+  supports?: string
 
   /**
-   * Regular expression which should be cleaned from error message and stack.
-   *
-   * By default it cleans `Bearer [^\s"]+`.
+   * Test time to test server.
    */
-  cleanFromLog?: RegExp
+  time?: TestTime
 
   /**
-   * Disable health check endpoint, control HTTP API, {@link Server#http}.
-   *
-   * The server will process only WebSocket connection and ignore all other
-   * HTTP request (so they can be processed by other HTTP server).
+   * Timeout in milliseconds to disconnect connection.
+   * Default is `70000`.
    */
-  disableHttpServer?: boolean
+  timeout?: number
 }
 
 export interface AuthenticatorOptions<Headers extends object> {
-  headers: Headers
   client: ServerClient
-  userId: string
   cookie: Record<string, string>
+  headers: Headers
   token: string
+  userId: string
 }
 
 export type SendBackActions =
-  | void
+  | [Action, Partial<Meta>][]
   | Action
   | Action[]
-  | [Action, Partial<Meta>][]
+  | void
 
 /**
  * The authentication callback.
@@ -279,7 +279,7 @@ interface Resender<
     ctx: Context<Data, Headers>,
     action: Readonly<TypeAction>,
     meta: Readonly<ServerMeta>
-  ): Resend | Promise<Resend>
+  ): Promise<Resend> | Resend
 }
 
 /**
@@ -299,7 +299,7 @@ interface Processor<
     ctx: Context<Data, Headers>,
     action: Readonly<TypeAction>,
     meta: Readonly<ServerMeta>
-  ): void | Promise<void>
+  ): Promise<void> | void
 }
 
 /**
@@ -377,7 +377,7 @@ interface FilterCreator<
     ctx: ChannelContext<Data, ChannelParams, Headers>,
     action: Readonly<SubscribeAction>,
     meta: Readonly<ServerMeta>
-  ): Promise<ChannelFilter<Headers>> | ChannelFilter<Headers> | void
+  ): ChannelFilter<Headers> | Promise<ChannelFilter<Headers>> | void
 }
 
 /**
@@ -398,7 +398,7 @@ interface ChannelLoader<
     ctx: ChannelContext<Data, ChannelParams, Headers>,
     action: Readonly<SubscribeAction>,
     meta: Readonly<ServerMeta>
-  ): SendBackActions | Promise<SendBackActions>
+  ): Promise<SendBackActions> | SendBackActions
 }
 
 /**
@@ -455,8 +455,8 @@ type ActionCallbacks<
       accessAndProcess: Processor<TypeAction, Data, Headers>
     }
 ) & {
-  resend?: Resender<TypeAction, Data, Headers>
   finally?: ActionFinally<TypeAction, Data, Headers>
+  resend?: Resender<TypeAction, Data, Headers>
 }
 
 type ChannelCallbacks<
@@ -499,67 +499,67 @@ interface CleanReporter {
 
 interface AuthenticationReporter {
   connectionId: string
-  subprotocol: string
   nodeId: string
+  subprotocol: string
 }
 
 interface ReportersArguments {
   add: ActionReporter
-  useless: ActionReporter
+  authenticated: AuthenticationReporter
   clean: CleanReporter
-  error: {
-    err: Error
-    fatal?: true
-    actionId?: ID
-    nodeId?: string
-    connectionId?: string
-  }
   clientError: {
+    connectionId?: string
     err: Error
     nodeId?: string
-    connectionId?: string
   }
   connect: {
     connectionId: string
     ipAddress: string
   }
+  denied: CleanReporter
+  destroy: void
   disconnect: {
+    connectionId?: string
     nodeId?: string
+  }
+  error: {
+    actionId?: ID
     connectionId?: string
+    err: Error
+    fatal?: true
+    nodeId?: string
   }
-  destroy: void
-  unknownType: {
-    type: string
-    actionId: ID
+  listen: {
+    backend: string
+    cert: boolean
+    controlMask: string
+    controlSecret: string
+    environment: 'development' | 'production'
+    host: string
+    loguxServer: string
+    nodeId: string
+    notes: object
+    port: string
+    redis: string
+    server: boolean
+    subprotocol: string
+    supports: string
   }
-  wrongChannel: SubscriptionReporter
   processed: {
     actionId: ID
     latency: number
   }
   subscribed: SubscriptionReporter
-  unsubscribed: SubscriptionReporter
-  denied: CleanReporter
-  authenticated: AuthenticationReporter
   unauthenticated: AuthenticationReporter
-  zombie: {
-    nodeId: string
+  unknownType: {
+    actionId: ID
+    type: string
   }
-  listen: {
-    controlSecret: string
-    controlMask: string
-    loguxServer: string
-    environment: 'production' | 'development'
-    subprotocol: string
-    supports: string
-    backend: string
-    server: boolean
+  unsubscribed: SubscriptionReporter
+  useless: ActionReporter
+  wrongChannel: SubscriptionReporter
+  zombie: {
     nodeId: string
-    redis: string
-    notes: object
-    cert: boolean
-    host: string
-    port: string
   }
 }
 
@@ -571,42 +571,42 @@ export interface Reporter {
 }
 
 export type Resend =
-  | string
-  | string[]
   | {
       channel?: string
       channels?: string[]
-      user?: string
-      users?: string[]
       client?: string
       clients?: string[]
+      excludeClients?: string[]
       node?: string
       nodes?: string[]
-      excludeClients?: string[]
+      user?: string
+      users?: string[]
     }
+  | string
+  | string[]
 
 export interface Logger {
-  info(details: object, message: string): void
-  warn(details: object, message: string): void
   error(details: object, message: string): void
   fatal(details: object, message: string): void
+  info(details: object, message: string): void
+  warn(details: object, message: string): void
 }
 
 interface Response {
+  body: string
   header?: {
     [name: string]: string
   }
-  body: string
 }
 
 interface GetProcessor {
+  request(request: object): Promise<Response> | Response
   safe?: boolean
-  request(request: object): Response | Promise<Response>
 }
 
 interface PostProcessor {
-  isValid(command: object): boolean
   command(command: object, request: object): Promise<void>
+  isValid(command: object): boolean
 }
 
 /**
@@ -634,18 +634,30 @@ export class BaseServer<
   ServerLog extends Log = Log<ServerMeta>
 > {
   /**
-   * @param opts Server options.
+   * Connected client by client ID.
+   *
+   * Do not rely on this data, when you have multiple Logux servers.
+   * Each server will have a different list.
    */
-  constructor(opts: BaseServerOptions)
+  clientIds: Map<string, ServerClient>
 
   /**
-   * Server options.
+   * Connected clients.
    *
    * ```js
-   * console.log('Server options', server.options.subprotocol)
+   * for (let client of server.connected.values()) {
+   *   console.log(client.remoteAddress)
+   * }
    * ```
    */
-  options: BaseServerOptions
+  connected: Map<string, ServerClient>
+
+  /**
+   * Add callback to internal HTTP server.
+   */
+  controls: {
+    [path: string]: GetProcessor | PostProcessor
+  }
 
   /**
    * Production or development mode.
@@ -656,16 +668,7 @@ export class BaseServer<
    * }
    * ```
    */
-  env: 'production' | 'development'
-
-  /**
-   * Server unique ID.
-   *
-   * ```js
-   * console.log('Error was raised on ' + server.nodeId)
-   * ```
-   */
-  nodeId: string
+  env: 'development' | 'production'
 
   /**
    * Server actions log.
@@ -677,23 +680,33 @@ export class BaseServer<
   log: ServerLog
 
   /**
-   * Connected clients.
+   * Console for custom log records. It uses `pino` API.
    *
    * ```js
-   * for (let client of server.connected.values()) {
-   *   console.log(client.remoteAddress)
-   * }
+   * server.on('connected', client => {
+   *   server.logger.info(
+   *     { domain: client.httpHeaders.domain },
+   *     'Client domain'
+   *   )
+   * })
    * ```
    */
-  connected: Map<string, ServerClient>
+  logger: {
+    debug: LogFn
+    error: LogFn
+    fatal: LogFn
+    info: LogFn
+    warn: LogFn
+  }
 
   /**
-   * Connected client by client ID.
+   * Server unique ID.
    *
-   * Do not rely on this data, when you have multiple Logux servers.
-   * Each server will have a different list.
+   * ```js
+   * console.log('Error was raised on ' + server.nodeId)
+   * ```
    */
-  clientIds: Map<string, ServerClient>
+  nodeId: string
 
   /**
    * Connected client by node ID.
@@ -704,12 +717,13 @@ export class BaseServer<
   nodeIds: Map<string, ServerClient>
 
   /**
-   * Connected client by user ID.
+   * Server options.
    *
-   * Do not rely on this data, when you have multiple Logux servers.
-   * Each server will have a different list.
+   * ```js
+   * console.log('Server options', server.options.subprotocol)
+   * ```
    */
-  userIds: Map<string, ServerClient[]>
+  options: BaseServerOptions
 
   /**
    * Clients subscribed to some channel.
@@ -720,38 +734,37 @@ export class BaseServer<
   subscribers: {
     [channel: string]: {
       [nodeId: string]: {
-        filter: ChannelFilter<{}> | true
+        filters: Record<string, ChannelFilter<{}> | true>
         unsubscribe?: (action: LoguxUnsubscribeAction, meta: ServerMeta) => void
       }
     }
   }
 
   /**
-   * Add callback to internal HTTP server.
+   * Connected client by user ID.
+   *
+   * Do not rely on this data, when you have multiple Logux servers.
+   * Each server will have a different list.
    */
-  controls: {
-    [path: string]: GetProcessor | PostProcessor
-  }
+  userIds: Map<string, ServerClient[]>
 
   /**
-   * Console for custom log records. It uses `pino` API.
+   * @param opts Server options.
+   */
+  constructor(opts: BaseServerOptions)
+
+  /**
+   * Add new client for server. You should call this method manually
+   * mostly for test purposes.
    *
    * ```js
-   * server.on('connected', client => {
-   *   server.logger.info(
-   *     { domain: client.httpHeaders.domain },
-   *     'Client domain'
-   *   )
-   * })
+   * server.addClient(test.right)
    * ```
+   *
+   * @param connection Logux connection to client.
+   * @returns Client ID.
    */
-  logger: {
-    fatal: LogFn
-    error: LogFn
-    warn: LogFn
-    info: LogFn
-    debug: LogFn
-  }
+  addClient(connection: ServerConnection): number
 
   /**
    * Set authenticate function. It will receive client credentials
@@ -769,11 +782,75 @@ export class BaseServer<
   auth(authenticator: Authenticator<Headers>): void
 
   /**
-   * Start WebSocket server and listen for clients.
+   * Define the channel.
    *
-   * @returns When the server has been bound.
+   * ```js
+   * server.channel('user/:id', {
+   *   access (ctx, action, meta) {
+   *     return ctx.params.id === ctx.userId
+   *   }
+   *   filter (ctx, action, meta) {
+   *     return (otherCtx, otherAction, otherMeta) => {
+   *       return !action.hidden
+   *     }
+   *   }
+   *   async load (ctx, action, meta) {
+   *     const user = await db.loadUser(ctx.params.id)
+   *     ctx.sendBack({ type: 'USER_NAME', name: user.name })
+   *   }
+   * })
+   * ```
+   *
+   * @param pattern Pattern for channel name.
+   * @param callbacks Callback during subscription process.
    */
-  listen(): Promise<void>
+  channel<
+    ChannelParams extends object = {},
+    Data extends object = {},
+    SubscribeAction extends LoguxSubscribeAction = LoguxSubscribeAction
+  >(
+    pattern: string,
+    callbacks: ChannelCallbacks<SubscribeAction, Data, ChannelParams, Headers>
+  ): void
+
+  /**
+   * @param pattern Regular expression for channel name.
+   * @param callbacks Callback during subscription process.
+   */
+  channel<
+    ChannelParams extends string[] = string[],
+    Data extends object = {},
+    SubscribeAction extends LoguxSubscribeAction = LoguxSubscribeAction
+  >(
+    pattern: RegExp,
+    callbacks: ChannelCallbacks<SubscribeAction, Data, ChannelParams, Headers>
+  ): void
+
+  /**
+   * Send runtime error stacktrace to all clients.
+   *
+   * ```js
+   * process.on('uncaughtException', e => {
+   *   server.debugError(e)
+   * })
+   * ```
+   *
+   * @param error Runtime error instance.
+   */
+  debugError(error: Error): void
+
+  /**
+   * Stop server and unbind all listeners.
+   *
+   * ```js
+   * afterEach(() => {
+   *   testServer.destroy()
+   * })
+   * ```
+   *
+   * @returns Promise when all listeners will be removed.
+   */
+  destroy(): Promise<void>
 
   /**
    * Add non-WebSocket HTTP request processor.
@@ -795,6 +872,59 @@ export class BaseServer<
    */
   http(listener: (req: IncomingMessage, res: ServerResponse) => void): void
 
+  /**
+   * Start WebSocket server and listen for clients.
+   *
+   * @returns When the server has been bound.
+   */
+  listen(): Promise<void>
+
+  /**
+   * @param event The event name.
+   * @param listener Event listener.
+   */
+  on(event: 'subscriptionCancelled', listener: () => void): Unsubscribe
+
+  /**
+   * @param event The event name.
+   * @param listener Subscription listener.
+   */
+  on(
+    event: 'subscribing',
+    listener: (action: LoguxSubscribeAction, meta: Readonly<ServerMeta>) => void
+  ): Unsubscribe
+
+  /**
+   * @param event The event name.
+   * @param listener Processing listener.
+   */
+  on(
+    event: 'backendGranted' | 'backendProcessed' | 'processed',
+    listener: (
+      action: Action,
+      meta: Readonly<ServerMeta>,
+      latencyMilliseconds: number
+    ) => void
+  ): Unsubscribe
+
+  /**
+   * @param event The event name.
+   * @param listener Action listener.
+   */
+  on(
+    event: 'add' | 'backendSent' | 'clean',
+    listener: (action: Action, meta: Readonly<ServerMeta>) => void
+  ): Unsubscribe
+
+  /**
+   * @param event The event name.
+   * @param listener Client listener.
+   */
+  on(
+    event: 'connected' | 'disconnected',
+    listener: (client: ServerClient) => void
+  ): Unsubscribe
+
   /**
    * Subscribe for synchronization events. It implements nanoevents API.
    * Supported events:
@@ -827,7 +957,7 @@ export class BaseServer<
    * @returns Unbind listener from event.
    */
   on(
-    event: 'fatal' | 'clientError',
+    event: 'clientError' | 'fatal',
     listener: (err: Error) => void
   ): Unsubscribe
 
@@ -840,15 +970,6 @@ export class BaseServer<
     listener: (err: Error, action: Action, meta: Readonly<ServerMeta>) => void
   ): Unsubscribe
 
-  /**
-   * @param event The event name.
-   * @param listener Client listener.
-   */
-  on(
-    event: 'connected' | 'disconnected',
-    listener: (client: ServerClient) => void
-  ): Unsubscribe
-
   /**
    * @param event The event name.
    * @param listener Client listener.
@@ -858,15 +979,6 @@ export class BaseServer<
     listener: (client: ServerClient, latencyMilliseconds: number) => void
   ): Unsubscribe
 
-  /**
-   * @param event The event name.
-   * @param listener Action listener.
-   */
-  on(
-    event: 'add' | 'clean' | 'backendSent',
-    listener: (action: Action, meta: Readonly<ServerMeta>) => void
-  ): Unsubscribe
-
   /**
    * @param event The event name.
    * @param listener Action listener.
@@ -876,19 +988,6 @@ export class BaseServer<
     listener: (action: Action, meta: ServerMeta) => void
   ): Unsubscribe
 
-  /**
-   * @param event The event name.
-   * @param listener Processing listener.
-   */
-  on(
-    event: 'processed' | 'backendGranted' | 'backendProcessed',
-    listener: (
-      action: Action,
-      meta: Readonly<ServerMeta>,
-      latencyMilliseconds: number
-    ) => void
-  ): Unsubscribe
-
   /**
    * @param event The event name.
    * @param listener Subscription listener.
@@ -902,15 +1001,6 @@ export class BaseServer<
     ) => void
   ): Unsubscribe
 
-  /**
-   * @param event The event name.
-   * @param listener Subscription listener.
-   */
-  on(
-    event: 'subscribing',
-    listener: (action: LoguxSubscribeAction, meta: Readonly<ServerMeta>) => void
-  ): Unsubscribe
-
   /**
    * @param event The event name.
    * @param listener Subscription listener.
@@ -923,12 +1013,6 @@ export class BaseServer<
     ) => void
   ): Unsubscribe
 
-  /**
-   * @param event The event name.
-   * @param listener Event listener.
-   */
-  on(event: 'subscriptionCancelled', listener: () => void): Unsubscribe
-
   /**
    * @param event The event name.
    * @param listener Report listener.
@@ -936,52 +1020,26 @@ export class BaseServer<
   on(event: 'report', listener: Reporter): Unsubscribe
 
   /**
-   * Stop server and unbind all listeners.
-   *
-   * ```js
-   * afterEach(() => {
-   *   testServer.destroy()
-   * })
-   * ```
-   *
-   * @returns Promise when all listeners will be removed.
-   */
-  destroy(): Promise<void>
-
-  /**
-   * Define action type’s callbacks.
+   * Set callbacks for unknown channel subscription.
    *
-   * ```js
-   * server.type('CHANGE_NAME', {
-   *   access (ctx, action, meta) {
-   *     return action.user === ctx.userId
-   *   },
-   *   resend (ctx, action) {
-   *     return `user/${ action.user }`
-   *   }
-   *   process (ctx, action, meta) {
-   *     if (isFirstOlder(lastNameChange(action.user), meta)) {
-   *       return db.changeUserName({ id: action.user, name: action.name })
+   *```js
+   * server.otherChannel({
+   *   async access (ctx, action, meta) {
+   *     const res = await phpBackend.checkChannel(ctx.params[0], ctx.userId)
+   *     if (res.code === 404) {
+   *       this.wrongChannel(action, meta)
+   *       return false
+   *     } else {
+   *       return response.body === 'granted'
    *     }
    *   }
    * })
    * ```
    *
-   * @param name The action’s type or action’s type matching rule as RegExp..
-   * @param callbacks Callbacks for actions with this type.
-   */
-  type<TypeAction extends Action = AnyAction, Data extends object = {}>(
-    name: TypeAction['type'] | RegExp,
-    callbacks: ActionCallbacks<TypeAction, Data, Headers>
-  ): void
-
-  /**
-   * @param actionCreator Action creator function.
-   * @param callbacks Callbacks for action created by creator.
+   * @param callbacks Callback during subscription process.
    */
-  type<Creator extends AbstractActionCreator, Data extends object = {}>(
-    actionCreator: Creator,
-    callbacks: ActionCallbacks<ReturnType<Creator>, Data, Headers>
+  otherChannel<Data extends object = {}>(
+    callbacks: ChannelCallbacks<LoguxSubscribeAction, Data, [string], Headers>
   ): void
 
   /**
@@ -1014,74 +1072,6 @@ export class BaseServer<
     callbacks: ActionCallbacks<Action, Data, Headers>
   ): void
 
-  /**
-   * Define the channel.
-   *
-   * ```js
-   * server.channel('user/:id', {
-   *   access (ctx, action, meta) {
-   *     return ctx.params.id === ctx.userId
-   *   }
-   *   filter (ctx, action, meta) {
-   *     return (otherCtx, otherAction, otherMeta) => {
-   *       return !action.hidden
-   *     }
-   *   }
-   *   async load (ctx, action, meta) {
-   *     const user = await db.loadUser(ctx.params.id)
-   *     ctx.sendBack({ type: 'USER_NAME', name: user.name })
-   *   }
-   * })
-   * ```
-   *
-   * @param pattern Pattern for channel name.
-   * @param callbacks Callback during subscription process.
-   */
-  channel<
-    ChannelParams extends object = {},
-    Data extends object = {},
-    SubscribeAction extends LoguxSubscribeAction = LoguxSubscribeAction
-  >(
-    pattern: string,
-    callbacks: ChannelCallbacks<SubscribeAction, Data, ChannelParams, Headers>
-  ): void
-
-  /**
-   * @param pattern Regular expression for channel name.
-   * @param callbacks Callback during subscription process.
-   */
-  channel<
-    ChannelParams extends string[] = string[],
-    Data extends object = {},
-    SubscribeAction extends LoguxSubscribeAction = LoguxSubscribeAction
-  >(
-    pattern: RegExp,
-    callbacks: ChannelCallbacks<SubscribeAction, Data, ChannelParams, Headers>
-  ): void
-
-  /**
-   * Set callbacks for unknown channel subscription.
-   *
-   *```js
-   * server.otherChannel({
-   *   async access (ctx, action, meta) {
-   *     const res = await phpBackend.checkChannel(ctx.params[0], ctx.userId)
-   *     if (res.code === 404) {
-   *       this.wrongChannel(action, meta)
-   *       return false
-   *     } else {
-   *       return response.body === 'granted'
-   *     }
-   *   }
-   * })
-   * ```
-   *
-   * @param callbacks Callback during subscription process.
-   */
-  otherChannel<Data extends object = {}>(
-    callbacks: ChannelCallbacks<LoguxSubscribeAction, Data, [string], Headers>
-  ): void
-
   /**
    * Add new action to the server and return the Promise until it will be
    * resend to clients and processed.
@@ -1095,41 +1085,6 @@ export class BaseServer<
     meta?: Partial<ServerMeta>
   ): Promise<Readonly<ServerMeta>>
 
-  /**
-   * Undo action from client.
-   *
-   * ```js
-   * if (couldNotFixConflict(action, meta)) {
-   *   server.undo(action, meta)
-   * }
-   * ```
-   *
-   * @param action The original action to undo.
-   * @param meta The action’s metadata.
-   * @param reason Optional code for reason. Default is `'error'`.
-   * @param extra Extra fields to `logux/undo` action.
-   * @returns When action was saved to the log.
-   */
-  undo(
-    action: Action,
-    meta: ServerMeta,
-    reason?: string,
-    extra?: object
-  ): Promise<void>
-
-  /**
-   * Send runtime error stacktrace to all clients.
-   *
-   * ```js
-   * process.on('uncaughtException', e => {
-   *   server.debugError(e)
-   * })
-   * ```
-   *
-   * @param error Runtime error instance.
-   */
-  debugError(error: Error): void
-
   /**
    * Send action, received by other server, to all clients of current server.
    * This method is for multi-server configuration only.
@@ -1148,7 +1103,7 @@ export class BaseServer<
    * @param action New action.
    * @param meta Action’s metadata.
    */
-  sendAction(action: Action, meta: ServerMeta): void | Promise<void>
+  sendAction(action: Action, meta: ServerMeta): Promise<void> | void
 
   /**
    * Send `logux/subscribed` if client was not already subscribed.
@@ -1163,17 +1118,62 @@ export class BaseServer<
   subscribe(nodeId: string, channel: string): void
 
   /**
-   * Add new client for server. You should call this method manually
-   * mostly for test purposes.
+   * @param actionCreator Action creator function.
+   * @param callbacks Callbacks for action created by creator.
+   */
+  type<Creator extends AbstractActionCreator, Data extends object = {}>(
+    actionCreator: Creator,
+    callbacks: ActionCallbacks<ReturnType<Creator>, Data, Headers>
+  ): void
+
+  /**
+   * Define action type’s callbacks.
    *
    * ```js
-   * server.addClient(test.right)
+   * server.type('CHANGE_NAME', {
+   *   access (ctx, action, meta) {
+   *     return action.user === ctx.userId
+   *   },
+   *   resend (ctx, action) {
+   *     return `user/${ action.user }`
+   *   }
+   *   process (ctx, action, meta) {
+   *     if (isFirstOlder(lastNameChange(action.user), meta)) {
+   *       return db.changeUserName({ id: action.user, name: action.name })
+   *     }
+   *   }
+   * })
    * ```
    *
-   * @param connection Logux connection to client.
-   * @returns Client ID.
+   * @param name The action’s type or action’s type matching rule as RegExp..
+   * @param callbacks Callbacks for actions with this type.
    */
-  addClient(connection: ServerConnection): number
+  type<TypeAction extends Action = AnyAction, Data extends object = {}>(
+    name: RegExp | TypeAction['type'],
+    callbacks: ActionCallbacks<TypeAction, Data, Headers>
+  ): void
+
+  /**
+   * Undo action from client.
+   *
+   * ```js
+   * if (couldNotFixConflict(action, meta)) {
+   *   server.undo(action, meta)
+   * }
+   * ```
+   *
+   * @param action The original action to undo.
+   * @param meta The action’s metadata.
+   * @param reason Optional code for reason. Default is `'error'`.
+   * @param extra Extra fields to `logux/undo` action.
+   * @returns When action was saved to the log.
+   */
+  undo(
+    action: Action,
+    meta: ServerMeta,
+    reason?: string,
+    extra?: object
+  ): Promise<void>
 
   /**
    * If you receive action with unknown type, this method will mark this action