@logux/server 0.12.3 → 0.12.5

package/bind-backend-proxy/index.js

@@ -1,8 +1,8 @@
 import { LoguxError } from '@logux/core'
+import http from 'http'
+import https from 'https'
 import JSONStream from 'JSONStream'
 import { nanoid } from 'nanoid'
-import https from 'https'
-import http from 'http'
 
 const VERSION = 4
 
@@ -19,21 +19,21 @@ const RESEND_KEYS = [
 
 function send(backend, command, events) {
   let body = JSON.stringify({
-    version: VERSION,
     commands: [command],
-    secret: backend.secret
+    secret: backend.secret,
+    version: VERSION
   })
   let protocol = backend.protocol === 'https:' ? https : http
   let req = protocol.request(
     {
-      method: 'POST',
+      headers: {
+        'Content-Length': Buffer.byteLength(body),
+        'Content-Type': 'application/json'
+      },
       host: backend.hostname,
-      port: backend.port,
+      method: 'POST',
       path: backend.pathname + backend.search,
-      headers: {
-        'Content-Type': 'application/json',
-        'Content-Length': Buffer.byteLength(body)
-      }
+      port: backend.port
     },
     res => {
       if (res.statusCode < 200 || res.statusCode > 299) {
@@ -83,20 +83,20 @@ function send(backend, command, events) {
 export function bindBackendProxy(app) {
   if (app.options.controlSecret) {
     app.controls['POST /'] = {
-      isValid({ command, action, meta }) {
-        return (
-          command === 'action' &&
-          typeof action === 'object' &&
-          typeof action.type === 'string' &&
-          typeof meta === 'object'
-        )
-      },
       command({ action, meta }, req) {
         if (!app.types[action.type] && !app.getRegexProcessor(action.type)) {
           meta.status = 'processed'
         }
         meta.backend = req.connection.remoteAddress
         return app.log.add(action, meta)
+      },
+      isValid({ action, command, meta }) {
+        return (
+          command === 'action' &&
+          typeof action === 'object' &&
+          typeof action.type === 'string' &&
+          typeof meta === 'object'
+        )
       }
     }
   }
@@ -159,28 +159,8 @@ export function bindBackendProxy(app) {
     app.emitter.emit('backendSent', action, meta)
     send(
       backend,
-      { command: 'action', action, meta, headers },
+      { action, command: 'action', headers, meta },
       {
-        filter({ id }) {
-          return id === meta.id
-        },
-        resend(answer) {
-          if (checked) {
-            error = true
-            currentReject(new Error('Resend answer was sent after access'))
-          } else if (action.type === 'logux/subscribe') {
-            error = true
-            accessReject(new Error('Resend can be called on subscription'))
-          } else {
-            let resend = {}
-            for (let key of RESEND_KEYS) {
-              if (typeof answer[key] !== 'undefined') {
-                resend[key] = answer[key]
-              }
-            }
-            resendResolve(resend)
-          }
-        },
         action(data) {
           let promise = app.log.add(data.action, {
             status: 'processed',
@@ -198,6 +178,18 @@ export function bindBackendProxy(app) {
           checked = true
           accessResolve(true)
         },
+        end() {
+          if (!error && (!checked || !processed)) {
+            currentReject(new Error('Back-end do not send required answers'))
+          }
+        },
+        error(e) {
+          error = true
+          currentReject(e)
+        },
+        filter({ id }) {
+          return id === meta.id
+        },
         forbidden() {
           if (resendResolve) resendResolve()
           error = true
@@ -219,6 +211,23 @@ export function bindBackendProxy(app) {
             processResolve()
           }
         },
+        resend(answer) {
+          if (checked) {
+            error = true
+            currentReject(new Error('Resend answer was sent after access'))
+          } else if (action.type === 'logux/subscribe') {
+            error = true
+            accessReject(new Error('Resend can be called on subscription'))
+          } else {
+            let resend = {}
+            for (let key of RESEND_KEYS) {
+              if (typeof answer[key] !== 'undefined') {
+                resend[key] = answer[key]
+              }
+            }
+            resendResolve(resend)
+          }
+        },
         unknownAction() {
           resendResolve()
           error = true
@@ -229,47 +238,27 @@ export function bindBackendProxy(app) {
           error = true
           app.wrongChannel(action, meta)
           accessResolve(false)
-        },
-        error(e) {
-          error = true
-          currentReject(e)
-        },
-        end() {
-          if (!error && (!checked || !processed)) {
-            currentReject(new Error('Back-end do not send required answers'))
-          }
         }
       }
     )
   }
 
   app.auth(
-    ({ userId, headers, cookie, token, client }) =>
+    ({ client, cookie, headers, token, userId }) =>
       new Promise((resolve, reject) => {
         let random = nanoid()
         send(
           backend,
           {
-            command: 'auth',
             authId: random,
-            userId,
-            token,
-            headers,
+            command: 'auth',
             cookie,
-            subprotocol: client.node.remoteSubprotocol
+            headers,
+            subprotocol: client.node.remoteSubprotocol,
+            token,
+            userId
           },
           {
-            filter({ authId }) {
-              return random === authId
-            },
-            wrongSubprotocol({ supported }) {
-              reject(
-                new LoguxError('wrong-subprotocol', {
-                  used: client.node.remoteSubprotocol,
-                  supported
-                })
-              )
-            },
             authenticated({ subprotocol }) {
               if (subprotocol) {
                 app.options.subprotocol = subprotocol
@@ -282,6 +271,17 @@ export function bindBackendProxy(app) {
             },
             error(e) {
               reject(e)
+            },
+            filter({ authId }) {
+              return random === authId
+            },
+            wrongSubprotocol({ supported }) {
+              reject(
+                new LoguxError('wrong-subprotocol', {
+                  supported,
+                  used: client.node.remoteSubprotocol
+                })
+              )
             }
           }
         )
@@ -292,20 +292,20 @@ export function bindBackendProxy(app) {
       sendAction(action, meta, ctx.headers)
       return accessing.get(meta.id)
     },
-    resend(ctx, action, meta) {
-      if (!resending.has(meta.id)) {
-        sendAction(action, meta, ctx.headers)
-      }
-      return resending.get(meta.id)
-    },
-    process(ctx, action, meta) {
-      return processing.get(meta.id)
-    },
     finally(ctx, action, meta) {
       actions.delete(meta.id)
       resending.delete(meta.id)
       accessing.delete(meta.id)
       processing.delete(meta.id)
+    },
+    process(ctx, action, meta) {
+      return processing.get(meta.id)
+    },
+    resend(ctx, action, meta) {
+      if (!resending.has(meta.id)) {
+        sendAction(action, meta, ctx.headers)
+      }
+      return resending.get(meta.id)
     }
   })
   app.otherChannel({
@@ -313,13 +313,13 @@ export function bindBackendProxy(app) {
       sendAction(action, meta, ctx.headers)
       return accessing.get(meta.id)
     },
-    load(ctx, action, meta) {
-      return processing.get(meta.id)
-    },
     finally(ctx, action, meta) {
       actions.delete(meta.id)
       accessing.delete(meta.id)
       processing.delete(meta.id)
+    },
+    load(ctx, action, meta) {
+      return processing.get(meta.id)
     }
   })
 }

package/bind-control-server/index.js

@@ -20,7 +20,7 @@ export function bindControlServer(app, custom) {
   if (app.options.disableHttpServer) {
     if (app.options.controlSecret) {
       let err = new Error(
-        '`controlSecret` can be set together with `disableHttpServer` option'
+        '`controlSecret` can not be set together with `disableHttpServer` option'
       )
       err.logux = true
       throw err

package/context/index.d.ts

@@ -1,4 +1,5 @@
 import type { AnyAction } from '@logux/core'
+
 import type { ServerMeta } from '../base-server/index.js'
 import type { Server } from '../server/index.js'
 
@@ -15,14 +16,13 @@ import type { Server } from '../server/index.js'
  */
 export class Context<Data extends object = {}, Headers extends object = {}> {
   /**
-   * @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
+   * Unique persistence client ID.
+   *
+   * ```js
+   * server.clientIds.get(node.clientId)
+   * ```
    */
-  constructor(server: Server, meta: ServerMeta)
+  clientId: string
 
   /**
    * Open structure to save some data between different steps of processing.
@@ -54,43 +54,27 @@ export class Context<Data extends object = {}, Headers extends object = {}> {
   headers: Headers
 
   /**
-   * Unique node ID.
-   *
-   * ```js
-   * server.nodeIds.get(node.nodeId)
-   * ```
-   */
-  nodeId: string
-
-  /**
-   * User ID taken node ID.
+   * Was action created by Logux server.
    *
    * ```js
-   * async access (ctx, action, meta) {
-   *   const user = await db.getUser(ctx.userId)
-   *   return user.admin
-   * }
+   * access: (ctx, action, meta) => ctx.isServer
    * ```
    */
-  userId: 'server' | string
+  isServer: boolean
 
   /**
-   * Unique persistence client ID.
+   * Unique node ID.
    *
    * ```js
-   * server.clientIds.get(node.clientId)
+   * server.nodeIds.get(node.nodeId)
    * ```
    */
-  clientId: string
+  nodeId: string
 
   /**
-   * Was action created by Logux server.
-   *
-   * ```js
-   * access: (ctx, action, meta) => ctx.isServer
-   * ```
+   * Logux server
    */
-  isServer: boolean
+  server: Server
 
   /**
    * Action creator application subprotocol version in SemVer format.
@@ -99,9 +83,26 @@ export class Context<Data extends object = {}, Headers extends object = {}> {
   subprotocol: string
 
   /**
-   * Logux server
+   * User ID taken node ID.
+   *
+   * ```js
+   * async access (ctx, action, meta) {
+   *   const user = await db.getUser(ctx.userId)
+   *   return user.admin
+   * }
+   * ```
    */
-  server: Server
+  userId: 'server' | 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

package/context/index.js

@@ -33,8 +33,8 @@ export class Context {
 
   sendBack(action, meta = {}) {
     return this.server.log.add(action, {
-      status: 'processed',
       clients: [this.clientId],
+      status: 'processed',
       ...meta
     })
   }

package/create-http-server/index.js

@@ -1,7 +1,7 @@
-import { isAbsolute, join } from 'path'
 import { promises as fs } from 'fs'
-import https from 'https'
 import http from 'http'
+import https from 'https'
+import { isAbsolute, join } from 'path'
 
 const PEM_PREAMBLE = '-----BEGIN'
 
@@ -30,9 +30,9 @@ export async function createHttpServer(opts) {
     if (cert && !isPem(cert)) cert = await readFrom(opts.root, cert)
 
     if (key && key.pem) {
-      server = https.createServer({ key: key.pem, cert })
+      server = https.createServer({ cert, key: key.pem })
     } else if (key) {
-      server = https.createServer({ key, cert })
+      server = https.createServer({ cert, key })
     } else {
       server = http.createServer()
     }

package/create-reporter/index.js

@@ -1,7 +1,7 @@
-import pino from 'pino'
 import os from 'os'
 import { dirname, join, sep } from 'path'
 import pico from 'picocolors'
+import pino from 'pino'
 import { fileURLToPath } from 'url'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
@@ -11,19 +11,34 @@ export const PATH_TO_PRETTIFYING_PINO_TRANSPORT = join(
 )
 
 const ERROR_CODES = {
+  EACCES: (e, environment) => {
+    let wayToFix = {
+      development:
+        'In dev mode it can be done with sudo:\n' + '$ sudo npm start',
+      production: '$ su - `<username>`\n' + `$ npm start -p ${e.port}`
+    }
+
+    return {
+      msg: `You are not allowed to run server on port \`${e.port}\``,
+      note:
+        "Non-privileged users can't start a listening socket on ports " +
+        'below 1024. Try to change user or take another port.\n\n' +
+        (wayToFix[environment] || wayToFix.production)
+    }
+  },
   EADDRINUSE: e => {
     let wayToFix = {
-      win32:
-        'Run `cmd.exe` as an administrator\n' +
-        'C:\\> netstat -a -b -n -o\n' +
-        'C:\\> taskkill /F /PID `<processid>`',
       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` +
-        '# sudo kill -9 `777`'
+        '# sudo kill -9 `777`',
+      win32:
+        'Run `cmd.exe` as an administrator\n' +
+        'C:\\> netstat -a -b -n -o\n' +
+        'C:\\> taskkill /F /PID `<processid>`'
     }
 
     return {
@@ -35,21 +50,6 @@ const ERROR_CODES = {
         (wayToFix[os.platform()] || '')
     }
   },
-  EACCES: (e, environment) => {
-    let wayToFix = {
-      development:
-        'In dev mode it can be done with sudo:\n' + '$ sudo npm start',
-      production: '$ su - `<username>`\n' + `$ npm start -p ${e.port}`
-    }
-
-    return {
-      msg: `You are not allowed to run server on port \`${e.port}\``,
-      note:
-        "Non-privileged users can't start a listening socket on ports " +
-        'below 1024. Try to change user or take another port.\n\n' +
-        (wayToFix[environment] || wayToFix.production)
-    }
-  },
   LOGUX_NO_CONTROL_SECRET: e => ({
     msg: e.message,
     note:
@@ -59,10 +59,81 @@ const ERROR_CODES = {
 }
 
 const REPORTERS = {
+  add: () => ({ msg: 'Action was added' }),
+
+  addClean: () => ({ msg: 'Action was added and cleaned' }),
+
+  authenticated: () => ({ msg: 'User was authenticated' }),
+
+  clean: () => ({ msg: 'Action was cleaned' }),
+
+  clientError: record => {
+    let result = {
+      details: {},
+      level: 'warn'
+    }
+    if (record.err.received) {
+      result.msg = `Client error: ${record.err.description}`
+    } else {
+      result.msg = `Sync error: ${record.err.description}`
+    }
+    for (let i in record) {
+      if (i !== 'err') {
+        result.details[i] = record[i]
+      }
+    }
+    return result
+  },
+
+  connect: () => ({ msg: 'Client was connected' }),
+
+  denied: () => ({ level: 'warn', msg: 'Action was denied' }),
+
+  destroy: () => ({ msg: 'Shutting down Logux server' }),
+
+  disconnect: () => ({ msg: 'Client was disconnected' }),
+
+  error: record => {
+    let result = {
+      details: {
+        err: {
+          message: record.err.message,
+          name: record.err.name,
+          stack: record.err.stack
+        }
+      },
+      level: record.fatal ? 'fatal' : 'error',
+      msg: record.err.message
+    }
+
+    let helper = ERROR_CODES[record.err.code]
+    if (helper) {
+      let help = helper(record.err, record.environment)
+      result.msg = help.msg
+      result.details.note = help.note
+      delete result.details.err.stack
+    } else if (record.err.logux) {
+      result.details.note = record.err.note
+      delete result.details.err
+    }
+
+    if (record.err.name === 'LoguxError') {
+      delete result.details.err.stack
+    }
+
+    for (let i in record) {
+      if (i !== 'err' && i !== 'fatal') {
+        result.details[i] = record[i]
+      }
+    }
+
+    return result
+  },
+
   listen: r => {
     let details = {
-      loguxServer: r.loguxServer,
       environment: r.environment,
+      loguxServer: r.loguxServer,
       nodeId: r.nodeId,
       subprotocol: r.subprotocol,
       supports: r.supports
@@ -99,38 +170,25 @@ const REPORTERS = {
 
     for (let i in r.notes) details[i] = r.notes[i]
 
-    return { msg: 'Logux server is listening', details }
+    return { details, msg: 'Logux server is listening' }
   },
 
-  connect: () => ({ msg: 'Client was connected' }),
-
-  authenticated: () => ({ msg: 'User was authenticated' }),
-
-  disconnect: () => ({ msg: 'Client was disconnected' }),
-
-  destroy: () => ({ msg: 'Shutting down Logux server' }),
-
-  add: () => ({ msg: 'Action was added' }),
-
-  addClean: () => ({ msg: 'Action was added and cleaned' }),
-
-  clean: () => ({ msg: 'Action was cleaned' }),
-
   subscribed: () => ({ msg: 'Client was subscribed' }),
 
-  unsubscribed: () => ({ msg: 'Client was unsubscribed' }),
-
   unauthenticated: () => ({ level: 'warn', msg: 'Bad authentication' }),
 
-  useless: () => ({ level: 'warn', msg: 'Useless action' }),
+  unknownType: record => ({
+    level: /^ server(:| )/.test(record.actionId) ? 'error' : 'warn',
+    msg: 'Action with unknown type'
+  }),
 
-  denied: () => ({ level: 'warn', msg: 'Action was denied' }),
+  unsubscribed: () => ({ msg: 'Client was unsubscribed' }),
 
-  zombie: () => ({ level: 'warn', msg: 'Zombie client was disconnected' }),
+  useless: () => ({ level: 'warn', msg: 'Useless action' }),
 
-  wrongControlSecret: () => ({
+  wrongChannel: () => ({
     level: 'warn',
-    msg: 'Wrong secret in control request'
+    msg: 'Wrong channel name'
   }),
 
   wrongControlIp: () => ({
@@ -138,70 +196,12 @@ const REPORTERS = {
     msg: 'IP address of control request do not pass the mask'
   }),
 
-  unknownType: record => ({
-    level: /^ server(:| )/.test(record.actionId) ? 'error' : 'warn',
-    msg: 'Action with unknown type'
-  }),
-
-  wrongChannel: () => ({
+  wrongControlSecret: () => ({
     level: 'warn',
-    msg: 'Wrong channel name'
+    msg: 'Wrong secret in control request'
   }),
 
-  clientError: record => {
-    let result = {
-      level: 'warn',
-      details: {}
-    }
-    if (record.err.received) {
-      result.msg = `Client error: ${record.err.description}`
-    } else {
-      result.msg = `Sync error: ${record.err.description}`
-    }
-    for (let i in record) {
-      if (i !== 'err') {
-        result.details[i] = record[i]
-      }
-    }
-    return result
-  },
-
-  error: record => {
-    let result = {
-      level: record.fatal ? 'fatal' : 'error',
-      msg: record.err.message,
-      details: {
-        err: {
-          message: record.err.message,
-          name: record.err.name,
-          stack: record.err.stack
-        }
-      }
-    }
-
-    let helper = ERROR_CODES[record.err.code]
-    if (helper) {
-      let help = helper(record.err, record.environment)
-      result.msg = help.msg
-      result.details.note = help.note
-      delete result.details.err.stack
-    } else if (record.err.logux) {
-      result.details.note = record.err.note
-      delete result.details.err
-    }
-
-    if (record.err.name === 'LoguxError') {
-      delete result.details.err.stack
-    }
-
-    for (let i in record) {
-      if (i !== 'err' && i !== 'fatal') {
-        result.details[i] = record[i]
-      }
-    }
-
-    return result
-  }
+  zombie: () => ({ level: 'warn', msg: 'Zombie client was disconnected' })
 }
 
 function createLogger(options) {
@@ -214,12 +214,12 @@ function createLogger(options) {
 
     let logger = pino(
       pino.transport({
-        target: PATH_TO_PRETTIFYING_PINO_TRANSPORT,
         options: {
           basepath,
           color,
           destination: options.logger.destination
-        }
+        },
+        target: PATH_TO_PRETTIFYING_PINO_TRANSPORT
       })
     )