@logux/server 0.13.1 → 0.15.0

package/request/index.js

@@ -1,45 +1,7 @@
-import fetch from 'node-fetch'
-
-function argsToString(url, opts, response) {
-  let { method, ...other } = opts
-  return `${method || 'GET'} ${url} ${JSON.stringify(other)} ${response}`
-}
-
 export class ResponseError extends Error {
-  constructor(statusCode, url, opts, response) {
-    super(`${statusCode} response on ${argsToString(url, opts, response)}`)
+  constructor(statusCode, url) {
+    super(`${statusCode} response on ${url}`)
     this.name = 'ResponseError'
     this.statusCode = statusCode
   }
 }
-
-export async function request(url, opts = {}, fetcher = fetch) {
-  let response = await fetcher(url, opts)
-  if (response.status === 204) {
-    return undefined
-  } else if (response.status >= 200 && response.status <= 299) {
-    return response.json()
-  } else {
-    throw new ResponseError(response.status, url, opts, await response.text())
-  }
-}
-
-export function get(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'GET' }, fetcher)
-}
-
-export function post(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'POST' }, fetcher)
-}
-
-export function put(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'PUT' }, fetcher)
-}
-
-export function patch(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'PATCH' }, fetcher)
-}
-
-export function del(url, opts = {}, fetcher = fetch) {
-  return request(url, { ...opts, method: 'DELETE' }, fetcher)
-}

package/server/index.d.ts

@@ -1,21 +1,31 @@
-import {
+import type { Log } from '@logux/core'
+
+import type {
   BaseServer,
-  type BaseServerOptions,
-  type Logger
+  BaseServerOptions,
+  Logger,
+  ServerMeta
 } from '../base-server/index.js'
 
+export interface LogStream {
+  /**
+   * Used to synchronously write log messages on application failure.
+   */
+  flushSync?(): void
+
+  write(str: string): void
+}
+
 export interface LoggerOptions {
   /**
-   * Stream to be used by logger to write log.
+   * Use color for human output.
    */
-  stream?: {
-    /**
-     * Used by pino to synchronously write log messages on application failure.
-     */
-    flushSync?(): void
+  color?: boolean
 
-    write(str: string): void
-  }
+  /**
+   * Stream to be used by logger to write log.
+   */
+  stream?: LogStream
 
   /**
    * Logger message format.
@@ -28,28 +38,6 @@ export interface ServerOptions extends BaseServerOptions {
    * Logger with custom settings.
    *
    * You can either configure built-in logger or provide your own.
-   * Custom logger example: pino logger that streams logs to
-   * elasticsearch
-   *
-   * ```js
-   * import pino from 'pino'
-   * import pinoElastic from 'pino-elasticsearch'
-   *
-   * const streamToElastic = pinoElastic({
-   *   consistency: 'one',
-   *   node: 'http://localhost:9200',
-   *   ecs: true
-   * })
-   *
-   * const server = new Server(
-   *   Server.loadOptions(process, {
-   *     …,
-   *     logger: pino({ level: 'info' }, streamToElastic)
-   *   })
-   * )
-   * ```
-   *
-   * Other logger examples can be found here http://getpino.io/#/docs/ecosystem
    */
   logger?: Logger | LoggerOptions
 }
@@ -68,15 +56,18 @@ export interface ServerOptions extends BaseServerOptions {
  * }
  *
  * const server = new Server(Object.assign({
- *   subprotocol: '1.0.0',
- *   supports: '1.x || 0.x',
- *   fileUrl: import.meta.url
+ *   subprotocol: 1,
+ *   minSubprotocol: 1,
+ *   root: import.meta.dirname
  * }, envOptions))
  *
  * server.listen()
  * ```
  */
-export class Server<Headers extends object = {}> extends BaseServer<Headers> {
+export class Server<
+  Headers extends object = unknown,
+  ClientData extends object = unknown
+> extends BaseServer<Headers, Log<ServerMeta>, ClientData> {
   /**
    * Server options.
    *
@@ -96,9 +87,9 @@ export class Server<Headers extends object = {}> extends BaseServer<Headers> {
    *
    * ```js
    * const server = new Server(Server.loadOptions(process, {
-   *   subprotocol: '1.0.0',
-   *   supports: '1.x',
-   *   fileUrl: import.meta.url,
+   *   minSubprotocol: 1,
+   *   subprotocol: 1,
+   *   root: import.meta.dirname,
    *   port: 31337
    * }))
    * ```

package/server/index.js

@@ -1,6 +1,6 @@
-import glob from 'fast-glob'
-import { join, relative } from 'node:path'
-import pico from 'picocolors'
+import { glob } from 'node:fs/promises'
+import { join, matchesGlob, relative } from 'node:path'
+import { styleText } from 'node:util'
 
 import { BaseServer } from '../base-server/index.js'
 import { createReporter } from '../create-reporter/index.js'
@@ -13,18 +13,9 @@ let cliOptionsSpec = {
     'LOGUX_PORT=1337 LOGUX_HOST=127.0.0.1 $0'
   ],
   options: {
-    backend: {
-      description: 'Backend to process actions'
-    },
     cert: {
       description: 'Path to SSL certificate'
     },
-    controlMask: {
-      description: 'CIDR masks of control servers'
-    },
-    controlSecret: {
-      description: 'Secret to control Logux server'
-    },
     host: {
       alias: 'h',
       description: 'Host to bind server'
@@ -37,6 +28,9 @@ let cliOptionsSpec = {
       description: 'Logger type',
       parse: value => oneOf(['human', 'json'], value)
     },
+    minSubprotocol: {
+      description: 'Check supported client subprotocols'
+    },
     port: {
       alias: 'p',
       description: 'Port to bind server',
@@ -47,9 +41,6 @@ let cliOptionsSpec = {
     },
     subprotocol: {
       description: 'Server subprotocol'
-    },
-    supports: {
-      description: 'Range of supported client subprotocols'
     }
   }
 }
@@ -106,7 +97,7 @@ export class Server extends BaseServer {
     let [help, options] = loadOptions(
       cliOptionsSpec,
       process,
-      defaults.root ? { path: join(defaults.root, '.env') } : undefined
+      defaults.root ? join(defaults.root, '.env') : undefined
     )
     if (help) {
       process.stdout.write(help + '\n')
@@ -116,7 +107,10 @@ export class Server extends BaseServer {
       return Object.assign(defaults, options)
     } catch (e) {
       process.stderr.write(
-        `${pico.bgRed(pico.black(' FATAL '))} ${e.message}\n`
+        styleText(
+          'red',
+          styleText('bgRed', styleText('black', ' FATAL ')) + `${e.message}\n`
+        )
       )
       return process.exit(1)
     }
@@ -125,14 +119,24 @@ export class Server extends BaseServer {
   async autoloadModules(
     files = ['modules/*/index.js', 'modules/*.js', '!**/*.{test,spec}.js']
   ) {
-    let matches = await glob(files, {
-      absolute: true,
+    if (!Array.isArray(files)) files = [files]
+    let ignore = files.filter(i => i.startsWith('!')).map(i => i.slice(1))
+    let patterns = files.filter(i => !i.startsWith('!'))
+
+    let matches = new Set()
+    for await (let entry of glob(patterns, {
       cwd: this.options.root,
-      onlyFiles: true
-    })
+      withFileTypes: true
+    })) {
+      if (!entry.isFile()) continue
+      let file = join(entry.parentPath, entry.name)
+      let path = relative(this.options.root, file)
+      if (ignore.some(i => matchesGlob(path, i))) continue
+      matches.add(file)
+    }
 
     await Promise.all(
-      matches.map(async file => {
+      [...matches].map(async file => {
         let serverModule = (await import(file)).default
         if (typeof serverModule === 'function') {
           await serverModule(this)

package/server-client/index.d.ts

@@ -9,7 +9,7 @@ import type { BaseServer } from '../base-server/index.js'
  * const client = server.connected.get(0)
  * ```
  */
-export class ServerClient {
+export class ServerClient<ClientData extends object = unknown> {
   /**
    * Server, which received client.
    */
@@ -30,6 +30,23 @@ export class ServerClient {
    */
   connection: ServerConnection
 
+  /**
+   * Open structure to save data for the whole connection.
+   *
+   * ```js
+   * server.auth(async ({ client, userId, token }) => {
+   *   let session = await findSession(token)
+   *   if (!session) return false
+   *   client.data.sessionId = session.id
+   *   return true
+   * })
+   * server.on('disconnected', client => {
+   *   touchSession(client.data.sessionId)
+   * })
+   * ```
+   */
+  data: ClientData
+
   /**
    * HTTP headers of WS connection.
    *
@@ -102,17 +119,9 @@ export class ServerClient {
   destroy(): void
 
   /**
-   * Check client subprotocol version. It uses `semver` npm package
-   * to parse requirements.
-   *
-   * ```js
-   * if (client.isSubprotocol('4.x')) {
-   *   useOldAPI()
-   * }
-   * ```
+   * Wait until the client will confirm all sent actions.
    *
-   * @param range npm’s version requirements.
-   * @returns Is version satisfies requirements.
+   * @returns Promise with `false` if the client was disconnected.
    */
-  isSubprotocol(range: string): boolean
+  drain(): Promise<boolean>
 }

package/server-client/index.js

@@ -1,9 +1,9 @@
 import { LoguxError, parseId } from '@logux/core'
-import cookie from 'cookie'
+import { parseCookie } from 'cookie'
 import fastq from 'fastq'
-import semver from 'semver'
 
 import { ALLOWED_META } from '../allowed-meta/index.js'
+import { Context } from '../context/index.js'
 import { filterMeta } from '../filter-meta/index.js'
 import { FilteredNode } from '../filtered-node/index.js'
 
@@ -11,6 +11,8 @@ async function onSend(action, meta) {
   return [action, filterMeta(meta)]
 }
 
+function ignore() {}
+
 function reportDetails(client) {
   return {
     connectionId: client.key,
@@ -70,7 +72,9 @@ export class ServerClient {
     this.userId = undefined
     this.clientId = undefined
     this.nodeId = undefined
+    this.data = {}
     this.processing = false
+    this.sending = new Set()
     this.connection = connection
     this.key = key.toString()
     if (connection.ws) {
@@ -81,18 +85,35 @@ export class ServerClient {
       this.httpHeaders = {}
     }
 
-    this.node = new FilteredNode(this, app.nodeId, app.log, connection, {
+    let Node = app.options.Node || FilteredNode
+
+    this.node = new Node(this, app.nodeId, app.log, connection, {
       auth: this.auth.bind(this),
       onReceive: this.onReceive.bind(this),
       onSend,
       ping: app.options.ping,
       subprotocol: app.options.subprotocol,
+      syncBatch: app.options.syncBatch,
       timeout: app.options.timeout
     })
     if (this.app.env === 'development') {
       this.node.setLocalHeaders({ env: 'development' })
     }
 
+    if (app.connectLoader) {
+      this.node.syncSinceQuery = async lastSynced => {
+        let context = new Context(app, this)
+        let entries = await app.connectLoader(context, lastSynced)
+        let added = 0
+        for (let entry of entries) {
+          // `added` should be taken before `filterMeta()` removes it
+          if (entry[1].added > added) added = entry[1].added
+          entry[1] = filterMeta(entry[1])
+        }
+        return { added, entries }
+      }
+    }
+
     this.node.catch(err => {
       err.connectionId = this.key
       this.app.emitter.emit('error', err)
@@ -116,10 +137,10 @@ export class ServerClient {
     this.clientId = clientId
     this.userId = userId
 
-    if (this.app.options.supports) {
-      if (!this.isSubprotocol(this.app.options.supports)) {
+    if (this.app.options.minSubprotocol) {
+      if (this.node.remoteSubprotocol < this.app.options.minSubprotocol) {
         throw new LoguxError('wrong-subprotocol', {
-          supported: this.app.options.supports,
+          supported: this.app.options.minSubprotocol,
           used: this.node.remoteSubprotocol
         })
       }
@@ -142,13 +163,14 @@ export class ServerClient {
     try {
       result = await this.app.authenticator({
         client: this,
-        cookie: cookie.parse(headers.cookie || ''),
+        cookie: parseCookie(headers.cookie || ''),
         headers: this.node.remoteHeaders,
         token,
         userId: this.userId
       })
     } catch (e) {
       if (e.name === 'LoguxError') {
+        /* c8 ignore next 1 */
         throw e
       } else {
         e.nodeId = nodeId
@@ -223,8 +245,21 @@ export class ServerClient {
     this.app.connected.delete(this.key)
   }
 
-  isSubprotocol(range) {
-    return semver.satisfies(this.node.remoteSubprotocol, range)
+  async drain() {
+    if (this.sending.size > 0) await Promise.all(this.sending)
+    if (this.destroyed || !this.node.connected) return false
+    if (this.node.syncing === 0) return true
+    return new Promise(resolve => {
+      let unbind = this.node.on('state', () => {
+        if (this.node.state === 'synchronized') {
+          unbind()
+          resolve(true)
+        } else if (!this.node.connected) {
+          unbind()
+          resolve(false)
+        }
+      })
+    })
   }
 
   onReceive(action, meta) {
@@ -251,8 +286,10 @@ export class ServerClient {
 
       if (isChannel) {
         for (let channel of this.app.channels) {
-          let pattern = channel.regexp || channel.pattern.regex
-          if (action.channel.match(pattern)) {
+          let match = channel.regexp
+            ? action.channel.match(channel.regexp)
+            : channel.pattern(action.channel)
+          if (match) {
             queueName = channel.queue
             break
           }
@@ -287,4 +324,12 @@ export class ServerClient {
       })
     })
   }
+
+  track(sending) {
+    let done = Promise.resolve(sending).then(ignore, ignore)
+    this.sending.add(done)
+    void done.then(() => {
+      this.sending.delete(done)
+    })
+  }
 }

package/test-client/index.d.ts

@@ -1,5 +1,14 @@
-import type { LoguxSubscribeAction, LoguxUnsubscribeAction } from '@logux/actions'
-import type { Action, AnyAction, TestLog, TestPair } from '@logux/core'
+import type {
+  LoguxSubscribeAction,
+  LoguxUnsubscribeAction
+} from '@logux/actions'
+import type {
+  Action,
+  AnyAction,
+  ClientNode,
+  TestLog,
+  TestPair
+} from '@logux/core'
 
 import type { ServerMeta } from '../base-server/index.js'
 import type { TestServer } from '../test-server/index.js'
@@ -12,7 +21,7 @@ export interface TestClientOptions {
   cookie?: object
   headers?: object
   httpHeaders?: { [key: string]: string }
-  subprotocol?: string
+  subprotocol?: number
   token?: string
 }
 
@@ -77,6 +86,11 @@ export class TestClient {
    */
   log: TestLog
 
+  /**
+   * Logux node.
+   */
+  node: ClientNode<object, TestLog<ServerMeta>>
+
   /**
    * Client’s node ID.
    *
@@ -127,7 +141,7 @@ export class TestClient {
    * @param test Function, where do you expect action will be received
    * @returns Promise with all received actions
    */
-  collect(test: () => Promise<any>): Promise<Action[]>
+  collect(test: () => Promise<unknown>): Promise<Action[]>
 
   /**
    * Connect to test server.
@@ -166,7 +180,10 @@ export class TestClient {
    * @param meta Optional action’s meta.
    * @returns Promise until `logux/processed` answer.
    */
-  process(action: AnyAction, meta?: Partial<ServerMeta>): Promise<Action[]>
+  process<TypeAction extends Action = AnyAction>(
+    action: TypeAction,
+    meta?: Partial<ServerMeta>
+  ): Promise<Action[]>
 
   /**
    * Collect actions received from server during the `test` call.
@@ -181,10 +198,10 @@ export class TestClient {
    * @param test Function, where do you expect action will be received
    * @returns Promise with all received actions
    */
-  received(test: () => any | Promise<any>): Promise<Action[]>
+  received(test: () => unknown): Promise<Action[]>
 
   /**
-   * Subscribe to the channel and collect all actions dunring the subscription.
+   * Subscribe to the channel and collect all actions during the subscription.
    *
    * ```js
    * let posts = await client.subscribe('posts')

package/test-client/index.js

@@ -1,5 +1,5 @@
 import { ClientNode, TestPair } from '@logux/core'
-import cookie from 'cookie'
+import { stringifyCookie } from 'cookie'
 import { setTimeout } from 'node:timers/promises'
 
 import { filterMeta } from '../filter-meta/index.js'
@@ -34,9 +34,9 @@ export class TestClient {
       this.node.setLocalHeaders(opts.headers)
     }
     if (opts.cookie) {
-      this.pair.right.ws.upgradeReq.headers.cookie = Object.keys(opts.cookie)
-        .map(i => cookie.serialize(i, opts.cookie[i]))
-        .join('; ')
+      this.pair.right.ws.upgradeReq.headers.cookie = stringifyCookie(
+        opts.cookie
+      )
     }
     server.unbind.push(() => {
       this.node.destroy()
@@ -46,7 +46,7 @@ export class TestClient {
   async collect(test) {
     let added = []
     let unbind = this.node.log.on('add', (action, meta) => {
-      if (!meta.id.includes(` ${this.nodeId} `)) {
+      if (meta.id.split(' ')[1] !== this.nodeId) {
         added.push(action)
       }
     })
@@ -67,8 +67,8 @@ export class TestClient {
       })
 
       this.server.addClient(this.pair.right)
-      this.node.connection.connect()
-      this.node.waitFor('synchronized').then(() => {
+      void this.node.connection.connect()
+      void this.node.waitFor('synchronized').then(() => {
         this.node.throwsError = true
         unbind()
         resolve()
@@ -136,7 +136,7 @@ export class TestClient {
   async received(test) {
     let actions = []
     let unbind = this.log.on('add', (action, meta) => {
-      if (!meta.id.includes(` ${this.nodeId} `)) {
+      if (meta.id.split(' ')[1] !== this.nodeId) {
         actions.push(action)
       }
     })

package/test-server/index.d.ts

@@ -1,7 +1,7 @@
-import type { TestLog, TestTime } from '@logux/core'
+import type { Log, TestLog, TestTime } from '@logux/core'
 
-import { BaseServer } from '../base-server/index.js'
 import type {
+  BaseServer,
   BaseServerOptions,
   Logger,
   ServerMeta
@@ -9,8 +9,10 @@ import type {
 import type { LoggerOptions } from '../server/index.js'
 import type { TestClient, TestClientOptions } from '../test-client/index.js'
 
-export interface TestServerOptions
-  extends Omit<BaseServerOptions, 'subprotocol' | 'supports'> {
+export interface TestServerOptions extends Omit<
+  BaseServerOptions,
+  'minSubprotocol' | 'subprotocol'
+> {
   /**
    * Disable built-in auth.
    */
@@ -21,9 +23,9 @@ export interface TestServerOptions
    */
   logger?: Logger | LoggerOptions
 
-  subprotocol?: string
+  minSubprotocol?: number
 
-  supports?: string
+  subprotocol?: number
 }
 
 /**
@@ -46,8 +48,22 @@ export interface TestServerOptions
  * ```
  */
 export class TestServer<
-  Headers extends object = {}
-> extends BaseServer<Headers> {
+  Headers extends object = unknown,
+  ClientData extends object = unknown
+> extends BaseServer<Headers, Log<ServerMeta>, ClientData> {
+  /**
+   * fetch() compatible API to test HTTP endpoints.
+   *
+   * ```js
+   * server.http('GET', '/version', (req, res) => {
+   *   res.end('1.0.0')
+   * })
+   * let res = await server.fetch()
+   * expect(await res.text()).toEqual('1.0.0')
+   * ```
+   */
+  fetch: typeof fetch
+
   /**
    * Server actions log, with methods to check actions inside.
    *
@@ -93,7 +109,7 @@ export class TestServer<
    *
    * @param test Callback with subscripting or action sending.
    */
-  expectDenied(test: () => any | Promise<any>): Promise<void>
+  expectDenied(test: () => unknown): Promise<void>
 
   /**
    * Call callback and throw an error if there was no error during
@@ -102,10 +118,7 @@ export class TestServer<
    * @param text RegExp or string of error message.
    * @param test Callback with subscripting or action sending.
    */
-  expectError(
-    text: RegExp | string,
-    test: () => any | Promise<any>
-  ): Promise<void>
+  expectError(text: RegExp | string, test: () => unknown): Promise<void>
 
   /**
    * Call callback and throw an error if there was no `logux/undo` in return
@@ -120,7 +133,7 @@ export class TestServer<
    * @param reason The reason in undo action.
    * @param test Callback with subscripting or action sending.
    */
-  expectUndo(reason: string, test: () => any | Promise<any>): Promise<void>
+  expectUndo(reason: string, test: () => unknown): Promise<void>
 
   /**
    * Try to connect client and throw an error is client didn’t received