@logux/server 0.13.1 → 0.15.0

package/context/index.d.ts

@@ -1,20 +1,10 @@
-import type { AnyAction } from '@logux/core'
+import type { Action, 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,27 @@ 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)
+  constructor(server: Server, client: ServerClient)
 
   /**
-   * Check creator subprotocol version. It uses `semver` npm package
-   * to parse requirements.
+   * Wait until the client will confirm all actions, which were sent to it.
+   *
+   * Use it to send a long history without loading it all into the memory:
+   * the client’s speed will limit how fast you read the database.
    *
    * ```js
-   * if (ctx.isSubprotocol('2.x')) {
-   *   useOldAPI()
+   * while (await ctx.drain()) {
+   *   let page = await cursor.next(100)
+   *   if (!page.length) break
+   *   ctx.sendBack(page.map(i => i.action))
    * }
    * ```
    *
-   * @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>
 
   /**
    * Send action back to the client.
@@ -126,13 +84,64 @@ export class Context<Data extends object = {}, Headers extends object = {}> {
    * ctx.sendBack({ type: 'login/success', token })
    * ```
    *
+   * An array of actions will be sent in a single message. Use it to send
+   * a big history page by page instead of a message per action.
+   *
+   * ```js
+   * ctx.sendBack(page.map(i => i.action))
+   * ```
+   *
+   * Every action in the array can have own meta as `[action, meta]`.
+   *
    * Action will not be processed by server’s callbacks from `Server#type`.
    *
-   * @param action The action.
+   * @param action The action or the array of actions.
    * @param meta Action’s meta.
    * @returns Promise until action was added to the server log.
    */
-  sendBack(action: AnyAction, meta?: Partial<ServerMeta>): Promise<void>
+  sendBack<TypeAction extends Action = AnyAction>(
+    action:
+      | (TypeAction | [TypeAction, Partial<ServerMeta>])[]
+      | TypeAction,
+    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)
 }
 
 /**

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,15 +33,22 @@ export class Context {
     }
   }
 
-  isSubprotocol(range) {
-    return semver.satisfies(this.subprotocol, range)
+  drain() {
+    return this.server.drain(this.clientId)
   }
 
-  sendBack(action, meta = {}) {
-    return this.server.log.add(action, {
-      clients: [this.clientId],
-      status: 'processed',
-      ...meta
-    })
+  sendBack(actions, meta = {}) {
+    let common = { clients: [this.clientId], status: 'processed', ...meta }
+    if (Array.isArray(actions)) {
+      return this.server.log.add(
+        actions.map(item => {
+          // Every action can have own meta as `[action, meta]`
+          return Array.isArray(item)
+            ? [item[0], { ...common, ...item[1] }]
+            : [item, { ...common }]
+        })
+      )
+    }
+    return this.server.log.add(actions, common)
   }
 }

package/create-reporter/index.js

@@ -1,21 +1,14 @@
 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'
+import { BINARY, isBinary } from '../human-formatter/utils.js'
 
 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}`
+      development: 'In dev mode it can be done with sudo:\n$ sudo npm start',
+      production: `$ su - \`<username>\`\n$ npm start -p ${e.port}`
     }
 
     return {
@@ -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>`',
+      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,73 +170,52 @@ 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) {
-    let v = obj[key]
-    if (typeof v === 'string') {
-      result[key] = v.replace(regexp, '[SECRET]')
-    } else if (typeof v === 'object' && !Array.isArray(v) && v !== null) {
-      if (seen.includes(v)) {
-        throw new Error('Circular reference in action')
-      }
-      seen.push(v)
-      result[key] = cleanFromKeys(v, regexp, seen)
-      seen.pop()
-    } else {
-      result[key] = v
-    }
+    result[key] = cleanValue(obj[key], regexp, seen)
   }
   return result
 }
 
+function cleanValue(value, regexp, seen) {
+  if (typeof value === 'string') {
+    return value.replace(regexp, '[SECRET]')
+  } else if (isBinary(value)) {
+    return BINARY
+  } else if (typeof value === 'object' && value !== null) {
+    if (seen.includes(value)) {
+      throw new Error('Circular reference in action')
+    }
+    seen.push(value)
+    let cleaned = Array.isArray(value)
+      ? value.map(i => cleanValue(i, regexp, seen))
+      : cleanFromKeys(value, regexp, seen)
+    seen.pop()
+    return cleaned
+  } else {
+    return value
+  }
+}
+
+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
+  }
+}
+
 export function createReporter(options) {
   let cleanFromLog = options.cleanFromLog || /Bearer [^\s"]+/g
   function reporter(type, details) {
@@ -270,12 +228,41 @@ 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
+
+    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
 }