@logux/server 0.13.1 → 0.14.0

package/server/index.d.ts

@@ -4,18 +4,25 @@ import {
   type Logger
 } 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 +35,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 +53,17 @@ 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
+> extends BaseServer<Headers> {
   /**
    * Server options.
    *
@@ -96,9 +83,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 { styleText } from 'node:util'
+import { glob } from 'tinyglobby'
 
 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,6 +119,7 @@ export class Server extends BaseServer {
   async autoloadModules(
     files = ['modules/*/index.js', 'modules/*.js', '!**/*.{test,spec}.js']
   ) {
+    if (!Array.isArray(files)) files = [files]
     let matches = await glob(files, {
       absolute: true,
       cwd: this.options.root,

package/server-client/index.d.ts

@@ -100,19 +100,4 @@ export class ServerClient {
    * Disconnect client.
    */
   destroy(): void
-
-  /**
-   * Check client subprotocol version. It uses `semver` npm package
-   * to parse requirements.
-   *
-   * ```js
-   * if (client.isSubprotocol('4.x')) {
-   *   useOldAPI()
-   * }
-   * ```
-   *
-   * @param range npm’s version requirements.
-   * @returns Is version satisfies requirements.
-   */
-  isSubprotocol(range: string): boolean
 }

package/server-client/index.js

@@ -1,9 +1,9 @@
 import { LoguxError, parseId } from '@logux/core'
 import cookie 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'
 
@@ -81,7 +81,9 @@ 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,
@@ -93,6 +95,19 @@ export class ServerClient {
       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 = entries.reduce((max, entry) => {
+          let meta = filterMeta(entry[1])
+          entry[1] = meta
+          return meta.added > max ? meta.added : max
+        }, 0)
+        return { added, entries }
+      }
+    }
+
     this.node.catch(err => {
       err.connectionId = this.key
       this.app.emitter.emit('error', err)
@@ -116,10 +131,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
         })
       }
@@ -149,6 +164,7 @@ export class ServerClient {
       })
     } catch (e) {
       if (e.name === 'LoguxError') {
+        /* c8 ignore next 1 */
         throw e
       } else {
         e.nodeId = nodeId
@@ -223,10 +239,6 @@ export class ServerClient {
     this.app.connected.delete(this.key)
   }
 
-  isSubprotocol(range) {
-    return semver.satisfies(this.node.remoteSubprotocol, range)
-  }
-
   onReceive(action, meta) {
     if (this.app.actionToQueue.has(meta.id)) {
       return Promise.resolve(false)

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.
    *
@@ -181,10 +195,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-server/index.d.ts

@@ -10,7 +10,7 @@ import type { LoggerOptions } from '../server/index.js'
 import type { TestClient, TestClientOptions } from '../test-client/index.js'
 
 export interface TestServerOptions
-  extends Omit<BaseServerOptions, 'subprotocol' | 'supports'> {
+  extends Omit<BaseServerOptions, 'minSubprotocol' | 'subprotocol'> {
   /**
    * Disable built-in auth.
    */
@@ -21,9 +21,9 @@ export interface TestServerOptions
    */
   logger?: Logger | LoggerOptions
 
-  subprotocol?: string
+  minSubprotocol?: number
 
-  supports?: string
+  subprotocol?: number
 }
 
 /**
@@ -46,8 +46,21 @@ export interface TestServerOptions
  * ```
  */
 export class TestServer<
-  Headers extends object = {}
+  Headers extends object = unknown
 > extends BaseServer<Headers> {
+  /**
+   * 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 +106,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 +115,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 +130,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

package/test-server/index.js

@@ -1,4 +1,5 @@
 import { TestTime } from '@logux/core'
+import { createServer } from 'node:http'
 
 import { BaseServer } from '../base-server/index.js'
 import { createReporter } from '../create-reporter/index.js'
@@ -13,8 +14,8 @@ export class TestServer extends BaseServer {
     opts.time.lastId += 1
     super({
       id: `${opts.time.lastId}`,
-      subprotocol: '0.0.0',
-      supports: '0.0.0',
+      minSubprotocol: 0,
+      subprotocol: 0,
       ...opts
     })
     if (opts.logger) {
@@ -31,6 +32,8 @@ export class TestServer extends BaseServer {
     if (opts.auth !== false) this.auth(() => true)
     this.testUsers = {}
 
+    this.fetch = this.fetch.bind(this)
+
     this.on('fatal', () => {
       this.destroy()
     })
@@ -88,4 +91,20 @@ export class TestServer extends BaseServer {
       }
     }
   }
+
+  async fetch(path, init) {
+    let server = createServer(async (req, res) => {
+      await this.processHttp(req, res)
+      server.close()
+    })
+    await new Promise(resolve => {
+      server.listen(0, resolve)
+    })
+    let { port } = server.address()
+    return fetch(`http://localhost:${port}${path}`, init)
+  }
+
+  isBruteforce() {
+    return false
+  }
 }