@logux/server 0.13.0 → 0.14.0

package/base-server/index.js

@@ -2,14 +2,13 @@ import { LoguxNotFoundError } from '@logux/actions'
 import { Log, MemoryStore, parseId, ServerConnection } from '@logux/core'
 import { createNanoEvents } from 'nanoevents'
 import { nanoid } from 'nanoid'
-import { promises as fs } from 'node:fs'
+import { readFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import UrlPattern from 'url-pattern'
 import { WebSocketServer } from 'ws'
 
-import { bindBackendProxy } from '../bind-backend-proxy/index.js'
-import { bindControlServer } from '../bind-control-server/index.js'
+import { addHttpPages } from '../add-http-pages/index.js'
 import { Context } from '../context/index.js'
 import { createHttpServer } from '../create-http-server/index.js'
 import { ServerClient } from '../server-client/index.js'
@@ -24,17 +23,6 @@ function optionError(msg) {
   throw error
 }
 
-let helloCache
-async function readHello() {
-  if (!helloCache) {
-    let hello = await fs.readFile(
-      join(fileURLToPath(import.meta.url), '..', 'hello.html')
-    )
-    helloCache = hello.toString()
-  }
-  return helloCache
-}
-
 export async function wasNot403(cb) {
   try {
     await cb()
@@ -103,17 +91,11 @@ export class BaseServer {
     this.options = opts
     this.env = this.options.env || process.env.NODE_ENV || 'development'
 
-    if (
-      typeof this.options.subprotocol === 'undefined' &&
-      typeof this.options.backend === 'undefined'
-    ) {
+    if (typeof this.options.subprotocol === 'undefined') {
       throw optionError('Missed `subprotocol` option in server constructor')
     }
-    if (
-      typeof this.options.supports === 'undefined' &&
-      typeof this.options.backend === 'undefined'
-    ) {
-      throw optionError('Missed `supports` option in server constructor')
+    if (typeof this.options.minSubprotocol === 'undefined') {
+      throw optionError('Missed `minSubprotocol` option in server constructor')
     }
 
     if (this.options.key && !this.options.cert) {
@@ -135,7 +117,9 @@ export class BaseServer {
     }
 
     this.options.root = this.options.root || process.cwd()
-    this.options.controlMask = this.options.controlMask || '127.0.0.1/8'
+    if (typeof this.options.port === 'string') {
+      this.options.port = parseInt(this.options.port, 10)
+    }
 
     let store = this.options.store || new MemoryStore()
 
@@ -167,7 +151,6 @@ export class BaseServer {
         }
         if (
           !isLogux &&
-          !this.options.backend &&
           !this.types[action.type] &&
           !this.getRegexProcessor(action.type)
         ) {
@@ -339,27 +322,11 @@ export class BaseServer {
     this.queues = new Map()
     this.actionToQueue = new Map()
 
-    this.controls = {
-      'GET /': {
-        async request() {
-          return {
-            body: await readHello(),
-            headers: { 'Content-Type': 'text/html' }
-          }
-        },
-        safe: true
-      },
-      'GET /health': {
-        request: () => ({
-          body: 'Logux Server: OK\n',
-          headers: { 'Content-Type': 'text/plain' }
-        }),
-        safe: true
-      }
-    }
+    this.httpListeners = {}
+    this.httpAllListeners = []
+    addHttpPages(this)
 
     this.listenNotes = {}
-    bindBackendProxy(this)
 
     let end = (actionId, queue, queueKey, ...args) => {
       this.actionToQueue.delete(actionId)
@@ -555,13 +522,17 @@ export class BaseServer {
     return undefined
   }
 
-  http(listener) {
+  http(method, url, listener) {
     if (this.options.disableHttpServer) {
       throw new Error(
         '`server.http()` can not be called when `disableHttpServer` enabled'
       )
     }
-    this.httpListener = listener
+    if (!url) {
+      this.httpAllListeners.push(method)
+    } else {
+      this.httpListeners[`${method} ${url}`] = listener
+    }
   }
 
   internalUnknownType(action, meta) {
@@ -618,29 +589,39 @@ export class BaseServer {
         this.httpServer.listen(this.options.port, this.options.host, resolve)
       })
     }
-    bindControlServer(this, this.httpListener)
 
-    this.unbind.push(
-      () =>
-        new Promise(resolve => {
-          this.ws.on('close', resolve)
-          this.ws.close()
-        })
-    )
-    if (this.httpServer) {
-      this.unbind.push(
-        () =>
-          new Promise(resolve => {
-            this.httpServer.on('close', resolve)
-            this.httpServer.close()
-          })
-      )
+    let processing = 0
+    let waiting
+    this.unbind.push(() => {
+      return new Promise(resolve => {
+        let end = () => {
+          this.ws.close(resolve)
+          this.httpServer.close()
+        }
+        if (processing === 0) {
+          end()
+        } else {
+          waiting = end
+        }
+      })
+    })
+
+    if (!this.options.disableHttpServer) {
+      this.httpServer.on('request', async (req, res) => {
+        if (this.destroying) {
+          res.writeHead(503, { 'Content-Type': 'text/plain' })
+          res.end('The server is shutting down\n')
+          return
+        }
+        processing += 1
+        await this.processHttp(req, res)
+        processing -= 1
+        if (processing === 0 && waiting) waiting()
+      })
     }
 
     let pkg = JSON.parse(
-      await fs.readFile(
-        join(fileURLToPath(import.meta.url), '..', '..', 'package.json')
-      )
+      await readFile(join(import.meta.dirname, '..', 'package.json'))
     )
 
     this.ws.on('connection', (ws, req) => {
@@ -648,20 +629,17 @@ export class BaseServer {
       this.addClient(new ServerConnection(ws))
     })
     this.emitter.emit('report', 'listen', {
-      backend: this.options.backend,
       cert: !!this.options.cert,
-      controlMask: this.options.controlMask,
-      controlSecret: this.options.controlSecret,
       environment: this.env,
       host: this.options.host,
       loguxServer: pkg.version,
+      minSubprotocol: this.options.minSubprotocol,
       nodeId: this.nodeId,
       notes: this.listenNotes,
       port: this.options.port,
       redis: this.options.redis,
       server: !!this.options.server,
-      subprotocol: this.options.subprotocol,
-      supports: this.options.supports
+      subprotocol: this.options.subprotocol
     })
   }
 
@@ -772,6 +750,32 @@ export class BaseServer {
     this.emitter.emit('processed', action, meta, latency)
   }
 
+  async processHttp(req, res) {
+    let urlString = req.url
+    if (/^\/\w+%3F/.test(urlString)) {
+      urlString = decodeURIComponent(urlString)
+    }
+    let reqUrl = new URL(urlString, 'http://localhost')
+    let rule = this.httpListeners[req.method + ' ' + reqUrl.pathname]
+
+    if (!rule) {
+      let processed = false
+      for (let listener of this.httpAllListeners) {
+        let result = await listener(req, res)
+        if (result === true) {
+          processed = true
+          break
+        }
+      }
+      if (!processed) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' })
+        res.end('Not found\n')
+      }
+    } else {
+      await rule(req, res)
+    }
+  }
+
   rememberBadAuth(ip) {
     this.authAttempts[ip] = (this.authAttempts[ip] || 0) + 1
     this.setTimeout(() => {
@@ -869,6 +873,10 @@ export class BaseServer {
     }
   }
 
+  sendOnConnect(loader) {
+    this.connectLoader = loader
+  }
+
   setTimeout(callback, ms) {
     this.lastTimeout += 1
     let id = this.lastTimeout

package/context/index.d.ts

@@ -1,20 +1,10 @@
 import type { AnyAction } from '@logux/core'
 
 import type { ServerMeta } from '../base-server/index.js'
+import type { ServerClient } from '../server-client/index.js'
 import type { Server } from '../server/index.js'
 
-/**
- * Action context.
- *
- * ```js
- * server.type('FOO', {
- *   access (ctx, action, meta) {
- *     return ctx.isSubprotocol('3.x') ? check3(action) : check4(action)
- *   }
- * })
- * ```
- */
-export class Context<Data extends object = {}, Headers extends object = {}> {
+export class ConnectContext<Headers extends object = unknown> {
   /**
    * Unique persistence client ID.
    *
@@ -24,23 +14,6 @@ export class Context<Data extends object = {}, Headers extends object = {}> {
    */
   clientId: string
 
-  /**
-   * Open structure to save some data between different steps of processing.
-   *
-   * ```js
-   * server.type('RENAME', {
-   *   access (ctx, action, meta) {
-   *     ctx.data.user = findUser(ctx.userId)
-   *     return ctx.data.user.hasAccess(action.projectId)
-   *   }
-   *   process (ctx, action, meta) {
-   *     return ctx.data.user.rename(action.projectId, action.name)
-   *   }
-   * })
-   * ```
-   */
-  data: Data
-
   /**
    * Client’s headers.
    *
@@ -53,15 +26,6 @@ export class Context<Data extends object = {}, Headers extends object = {}> {
    */
   headers: Headers
 
-  /**
-   * Was action created by Logux server.
-   *
-   * ```js
-   * access: (ctx, action, meta) => ctx.isServer
-   * ```
-   */
-  isServer: boolean
-
   /**
    * Unique node ID.
    *
@@ -77,10 +41,9 @@ export class Context<Data extends object = {}, Headers extends object = {}> {
   server: Server
 
   /**
-   * Action creator application subprotocol version in SemVer format.
-   * Use {@link Context#isSubprotocol} to check it.
+   * Action creator application subprotocol version.
    */
-  subprotocol: string
+  subprotocol: number
 
   /**
    * User ID taken node ID.
@@ -92,32 +55,9 @@ export class Context<Data extends object = {}, Headers extends object = {}> {
    * }
    * ```
    */
-  userId: 'server' | string
+  userId: string
 
-  /**
-   * @param nodeId Unique node ID.
-   * @param clientId Unique persistence client ID.
-   * @param userId User ID taken node ID.
-   * @param subprotocol Action creator application subprotocol version
-   *                    in SemVer format.
-   * @param server Logux server
-   */
-  constructor(server: Server, meta: ServerMeta)
-
-  /**
-   * Check creator subprotocol version. It uses `semver` npm package
-   * to parse requirements.
-   *
-   * ```js
-   * if (ctx.isSubprotocol('2.x')) {
-   *   useOldAPI()
-   * }
-   * ```
-   *
-   * @param range npm’s version requirements.
-   * @returns Is version satisfies requirements.
-   */
-  isSubprotocol(range: string): boolean
+  constructor(server: Server, client: ServerClient)
 
   /**
    * Send action back to the client.
@@ -135,6 +75,43 @@ export class Context<Data extends object = {}, Headers extends object = {}> {
   sendBack(action: AnyAction, meta?: Partial<ServerMeta>): Promise<void>
 }
 
+/**
+ * Action context.
+ * ```
+ */
+export class Context<
+  Data extends object = unknown,
+  Headers extends object = unknown
+> extends ConnectContext<Headers> {
+  /**
+   * Open structure to save some data between different steps of processing.
+   *
+   * ```js
+   * server.type('RENAME', {
+   *   access (ctx, action, meta) {
+   *     ctx.data.user = findUser(ctx.userId)
+   *     return ctx.data.user.hasAccess(action.projectId)
+   *   }
+   *   process (ctx, action, meta) {
+   *     return ctx.data.user.rename(action.projectId, action.name)
+   *   }
+   * })
+   * ```
+   */
+  data: Data
+
+  /**
+   * Was action created by Logux server.
+   *
+   * ```js
+   * access: (ctx, action, meta) => ctx.isServer
+   * ```
+   */
+  isServer: boolean
+
+  constructor(server: Server, meta: ServerMeta)
+}
+
 /**
  * Subscription context.
  *

package/context/index.js

@@ -1,23 +1,29 @@
 import { parseId } from '@logux/core'
-import semver from 'semver'
 
 export class Context {
   constructor(server, meta) {
     this.server = server
     this.data = {}
 
-    let parsed = parseId(meta.id)
-    this.nodeId = parsed.nodeId
-    this.userId = parsed.userId
-    this.clientId = parsed.clientId
-    this.isServer = this.userId === 'server'
-
-    let client = server.clientIds.get(this.clientId)
-
-    if (meta.subprotocol) {
-      this.subprotocol = meta.subprotocol
-    } else if (client) {
+    let client
+    if (meta.node) {
+      client = meta
+      this.nodeId = client.nodeId
+      this.userId = client.userId
+      this.clientId = client.clientId
       this.subprotocol = client.node.remoteSubprotocol
+    } else {
+      let parsed = parseId(meta.id)
+      this.nodeId = parsed.nodeId
+      this.userId = parsed.userId
+      this.clientId = parsed.clientId
+      this.isServer = this.userId === 'server'
+      client = server.clientIds.get(this.clientId)
+      if (meta.subprotocol) {
+        this.subprotocol = meta.subprotocol
+      } else if (client) {
+        this.subprotocol = client.node.remoteSubprotocol
+      }
     }
 
     if (client) {
@@ -27,10 +33,6 @@ export class Context {
     }
   }
 
-  isSubprotocol(range) {
-    return semver.satisfies(this.subprotocol, range)
-  }
-
   sendBack(action, meta = {}) {
     return this.server.log.add(action, {
       clients: [this.clientId],

package/create-reporter/index.js

@@ -1,14 +1,7 @@
 import os from 'node:os'
-import { dirname, join, sep } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import pico from 'picocolors'
-import pino from 'pino'
+import { sep } from 'node:path'
 
-const __dirname = dirname(fileURLToPath(import.meta.url))
-export const PATH_TO_PRETTIFYING_PINO_TRANSPORT = join(
-  __dirname,
-  '../human-formatter/index.js'
-)
+import humanFormatter from '../human-formatter/index.js'
 
 const ERROR_CODES = {
   EACCES: (e, environment) => {
@@ -27,13 +20,14 @@ const ERROR_CODES = {
     }
   },
   EADDRINUSE: e => {
+    let port = String(e.port)
     let wayToFix = {
       darwin: `$ sudo lsof -i ${e.port}\n` + '$ sudo kill -9 `<processid>`',
       linux:
         '$ su - root\n' +
         `# netstat -nlp | grep ${e.port}\n` +
         'Proto   Local Address   State    PID/Program name\n' +
-        `tcp     0.0.0.0:${e.port}    LISTEN   \`777\`/node\n` +
+        `tcp     0.0.0.0:${port.padEnd(8)}LISTEN   \`777\`/node\n` +
         '# sudo kill -9 `777`',
       win32:
         'Run `cmd.exe` as an administrator\n' +
@@ -49,13 +43,7 @@ const ERROR_CODES = {
         'or previous version of this server was not killed.\n\n' +
         (wayToFix[os.platform()] || '')
     }
-  },
-  LOGUX_NO_CONTROL_SECRET: e => ({
-    msg: e.message,
-    note:
-      'Call `npx nanoid` and set result as `controlSecret` ' +
-      'or `LOGUX_CONTROL_SECRET` environment variable'
-  })
+  }
 }
 
 const REPORTERS = {
@@ -134,9 +122,9 @@ const REPORTERS = {
     let details = {
       environment: r.environment,
       loguxServer: r.loguxServer,
+      minSubprotocol: r.minSubprotocol,
       nodeId: r.nodeId,
-      subprotocol: r.subprotocol,
-      supports: r.supports
+      subprotocol: r.subprotocol
     }
 
     if (r.environment === 'development') {
@@ -155,15 +143,6 @@ const REPORTERS = {
       details.healthCheck = `${httpProtocol}${r.host}:${r.port}/health`
     }
 
-    if (r.controlSecret) {
-      details.controlListen = `http://${r.host}:${r.port}/`
-      details.controlMask = r.controlMask
-    }
-
-    if (r.backend) {
-      details.backendSend = r.backend
-    }
-
     if (r.redis) {
       details.redis = r.redis
     }
@@ -191,53 +170,9 @@ const REPORTERS = {
     msg: 'Wrong channel name'
   }),
 
-  wrongControlIp: () => ({
-    level: 'warn',
-    msg: 'IP address of control request do not pass the mask'
-  }),
-
-  wrongControlSecret: () => ({
-    level: 'warn',
-    msg: 'Wrong secret in control request'
-  }),
-
   zombie: () => ({ level: 'warn', msg: 'Zombie client was disconnected' })
 }
 
-function createLogger(options) {
-  if (options.logger === 'human' || options.logger.type === 'human') {
-    let env = options.env || process.env.NODE_ENV || 'development'
-    let color =
-      env !== 'development' ? false : pico.createColors().isColorSupported
-    let basepath = options.root || process.cwd()
-    if (basepath.slice(-1) !== sep) basepath += sep
-
-    let logger = pino(
-      pino.transport({
-        options: {
-          basepath,
-          color,
-          destination: options.logger.destination
-        },
-        target: PATH_TO_PRETTIFYING_PINO_TRANSPORT
-      })
-    )
-
-    // NOTE: needed only for tests
-    logger._basepath = basepath
-    logger._color = color
-
-    return logger
-  }
-  return pino(
-    {
-      name: 'logux-server',
-      timestamp: pino.stdTimeFunctions.isoTime
-    },
-    options.logger.stream || pino.destination()
-  )
-}
-
 function cleanFromKeys(obj, regexp, seen) {
   let result = {}
   for (let key in obj) {
@@ -270,12 +205,56 @@ export function createReporter(options) {
     )
   }
 
-  let customLoggerProvided =
-    typeof options.logger !== 'string' && 'info' in options.logger
-  if (customLoggerProvided) {
+  if (typeof options.logger !== 'string' && 'info' in options.logger) {
     reporter.logger = options.logger
   } else {
-    reporter.logger = createLogger(options)
+    let format
+    if (options.logger === 'human' || options.logger.type === 'human') {
+      let basepath = options.root || process.cwd()
+      if (basepath.slice(-1) !== sep) basepath += sep
+      format = humanFormatter({ basepath })
+    } else {
+      format = record => JSON.stringify(record) + '\n'
+    }
+    let stream = options.logger?.stream ?? process.stderr
+
+    function createRecord(level, details, msg) {
+      /* c8 ignore next 4 */
+      if (typeof details === 'string') {
+        msg = details
+        details = {}
+      }
+      return {
+        level,
+        time: new Date().toISOString(),
+        pid: process.pid,
+        ...details,
+        msg
+      }
+    }
+
+    reporter.logger = {
+      /* c8 ignore next 3 */
+      debug(details, msg) {
+        stream.write(format(createRecord(20, details, msg)))
+      },
+      info(details, msg) {
+        stream.write(format(createRecord(30, details, msg)))
+      },
+      warn(details, msg) {
+        stream.write(format(createRecord(40, details, msg)))
+      },
+      error(details, msg) {
+        stream.write(format(createRecord(50, details, msg)))
+      },
+      fatal(details, msg) {
+        if (stream.flushSync) {
+          stream.flushSync(format(createRecord(60, details, msg)))
+        } else {
+          stream.write(format(createRecord(60, details, msg)))
+        }
+      }
+    }
   }
   return reporter
 }