@logux/server 0.10.7 → 0.12.0

package/add-sync-map/index.d.ts

@@ -0,0 +1,243 @@
+import {
+  LoguxSubscribeAction,
+  SyncMapChangeAction,
+  SyncMapCreateAction,
+  SyncMapDeleteAction,
+  SyncMapValues,
+  SyncMapTypes
+} from '@logux/actions'
+
+import { BaseServer, ServerMeta } from '../base-server/index.js'
+import { Context } from '../context/index.js'
+
+declare const WITH_TIME: unique symbol
+
+export type WithTime<Value extends SyncMapTypes | SyncMapTypes[]> = {
+  value: Value
+  time: number
+  [WITH_TIME]: true
+}
+
+export type WithoutTime<Value extends SyncMapTypes | SyncMapTypes[]> = {
+  value: Value
+  time: undefined
+  [WITH_TIME]: false
+}
+
+export type SyncMapData<Value extends SyncMapValues> = { id: string } & {
+  [Key in keyof Value]: WithTime<Value[Key]> | WithoutTime<Value[Key]>
+}
+
+/**
+ * Add last changed time to value to use in conflict resolution.
+ *
+ * If you do not know the time, use {@link NoConflictResolution}.
+ *
+ * @param value The value.
+ * @param time UNIX milliseconds.
+ * @returns Wrapper.
+ */
+export function ChangedAt<Value extends SyncMapTypes | SyncMapTypes[]>(
+  value: Value,
+  time: number
+): WithTime<Value>
+
+/**
+ * Mark that the value has no last changed date and conflict resolution
+ * can’t be applied.
+ *
+ * @param value The value.
+ * @returns Wrapper.
+ */
+export function NoConflictResolution<
+  Value extends SyncMapTypes | SyncMapTypes[]
+>(
+  value: Value
+): WithTime<Value>
+
+interface SyncMapActionFilter<Value extends SyncMapValues> {
+  (
+    ctx: Context,
+    action: SyncMapCreateAction<Value> | SyncMapDeleteAction,
+    meta: ServerMeta
+  ): Promise<boolean> | boolean
+}
+
+interface SyncMapOperations<Value extends SyncMapValues> {
+  access(
+    ctx: Context,
+    id: string,
+    action:
+      | SyncMapCreateAction
+      | SyncMapChangeAction
+      | SyncMapDeleteAction
+      | LoguxSubscribeAction,
+    meta: ServerMeta
+  ): Promise<boolean> | boolean
+
+  load?(
+    ctx: Context,
+    id: string,
+    since: number | undefined,
+    action: LoguxSubscribeAction,
+    meta: ServerMeta
+  ): Promise<SyncMapData<Value>> | SyncMapData<Value> | false | Promise<false>
+
+  create?(
+    ctx: Context,
+    id: string,
+    fields: Value,
+    time: number,
+    action: SyncMapCreateAction<Value>,
+    meta: ServerMeta
+  ): Promise<void | boolean> | void | boolean
+
+  change?(
+    ctx: Context,
+    id: string,
+    fields: Partial<Value>,
+    time: number,
+    action: SyncMapChangeAction<Value>,
+    meta: ServerMeta
+  ): Promise<void | boolean> | void | boolean
+
+  delete?(
+    ctx: Context,
+    id: string,
+    action: SyncMapDeleteAction,
+    meta: ServerMeta
+  ): Promise<void | boolean> | void | boolean
+}
+
+interface SyncMapFilterOperations<Value extends SyncMapValues> {
+  access?(
+    ctx: Context,
+    filter: Partial<Value> | undefined,
+    action: LoguxSubscribeAction,
+    meta: ServerMeta
+  ): Promise<boolean> | boolean
+
+  initial(
+    ctx: Context,
+    filter: Partial<Value> | undefined,
+    since: number | undefined,
+    action: LoguxSubscribeAction,
+    meta: ServerMeta
+  ): Promise<SyncMapData<Value>[]> | SyncMapData<Value>[]
+
+  actions?(
+    ctx: Context,
+    filter: Partial<Value> | undefined,
+    action: LoguxSubscribeAction,
+    meta: ServerMeta
+  ): Promise<SyncMapActionFilter<Value>> | SyncMapActionFilter<Value> | void
+}
+
+/**
+ * Add callbacks for client’s `SyncMap`.
+ *
+ * ```js
+ * import { addSyncMap, isFirstTimeOlder, ChangedAt } from '@logux/server'
+ * import { LoguxNotFoundError } from '@logux/actions'
+ *
+ * addSyncMap(server, 'tasks', {
+ *   async access (ctx, id) {
+ *     const task = await Task.find(id)
+ *     return ctx.userId === task.authorId
+ *   },
+ *
+ *   async load (ctx, id, since) {
+ *     const task = await Task.find(id)
+ *     if (!task) throw new LoguxNotFoundError()
+ *     return {
+ *       id: task.id,
+ *       text: ChangedAt(task.text, task.textChanged),
+ *       finished: ChangedAt(task.finished, task.finishedChanged),
+ *     }
+ *   },
+ *
+ *   async create (ctx, id, fields, time) {
+ *     await Task.create({
+ *       id,
+ *       text: fields.text,
+ *       finished: fields.finished,
+ *       authorId: ctx.userId,
+ *       textChanged: time,
+ *       finishedChanged: time
+ *     })
+ *   },
+ *
+ *   async change (ctx, id, fields, time) {
+ *     const task = await Task.find(id)
+ *     if ('text' in fields) {
+ *       if (task.textChanged < time) {
+ *         await task.update({
+ *           text: fields.text,
+ *           textChanged: time
+ *         })
+ *       }
+ *     }
+ *     if ('finished' in fields) {
+ *       if (task.finishedChanged < time) {
+ *         await task.update({
+ *           finished: fields.finished,
+ *           finishedChanged: time
+ *         })
+ *       }
+ *     }
+ *   }
+ *
+ *   async delete (ctx, id) {
+ *     await Task.delete(id)
+ *   }
+ * })
+ * ```
+ *
+ * @param server Server instance.
+ * @param plural Prefix for channel names and action types.
+ * @param operations Callbacks.
+ */
+export function addSyncMap<Values extends SyncMapValues>(
+  server: BaseServer,
+  plural: string,
+  operations: SyncMapOperations<Values>
+): void
+
+/**
+ * Add callbacks for client’s `useFilter`.
+ *
+ * ```js
+ * import { addSyncMapFilter, ChangedAt } from '@logux/server'
+ *
+ * addSyncMapFilter(server, 'tasks', {
+ *   access (ctx, filter) {
+ *     return true
+ *   },
+ *
+ *   initial (ctx, filter, since) {
+ *     let tasks = await Tasks.where({ ...filter, authorId: ctx.userId })
+ *     // You can return only data changed after `since`
+ *     return tasks.map(task => ({
+ *       id: task.id,
+ *       text: ChangedAt(task.text, task.textChanged),
+ *       finished: ChangedAt(task.finished, task.finishedChanged),
+ *     }))
+ *   },
+ *
+ *   actions (filterCtx, filter) {
+ *     return (actionCtx, action, meta) => {
+ *       return actionCtx.userId === filterCtx.userId
+ *     }
+ *   }
+ * })
+ * ```
+
+ * @param server Server instance.
+ * @param plural Prefix for channel names and action types.
+ * @param operations Callbacks.
+ */
+export function addSyncMapFilter<Values extends SyncMapValues>(
+  server: BaseServer,
+  plural: string,
+  operations: SyncMapFilterOperations<Values>
+): void

package/add-sync-map/index.js

@@ -0,0 +1,207 @@
+const WITH_TIME = Symbol('WITH_TIME')
+
+export function ChangedAt(value, time) {
+  return { value, time, [WITH_TIME]: true }
+}
+
+export function NoConflictResolution(value) {
+  return { value, [WITH_TIME]: false }
+}
+
+async function addFinished(server, ctx, type, action, meta) {
+  await server.process(
+    { ...action, type },
+    { time: meta.time, excludeClients: [ctx.clientId] }
+  )
+}
+
+function resendFinished(server, plural, type, all = true) {
+  if (all) {
+    server.type(type, {
+      access() {
+        return false
+      },
+      resend(ctx, action) {
+        return [plural, `${plural}/${action.id}`]
+      }
+    })
+  } else {
+    server.type(type, {
+      access() {
+        return false
+      },
+      resend(ctx, action) {
+        return [`${plural}/${action.id}`]
+      }
+    })
+  }
+}
+
+function buildFilter(filter) {
+  return (ctx, action) => {
+    if (action.type.endsWith('/created')) {
+      for (let key in filter) {
+        if (action.fields[key] !== filter[key]) return false
+      }
+    }
+    return true
+  }
+}
+
+async function sendMap(server, changedType, data, since) {
+  let { id, ...other } = data
+  let byTime = new Map()
+  for (let key in other) {
+    if (other[key][WITH_TIME] === true) {
+      let time = other[key].time
+      if (!byTime.has(time)) byTime.set(time, {})
+      byTime.get(time)[key] = other[key].value
+    } else if (other[key][WITH_TIME] === false) {
+      if (!byTime.has('now')) byTime.set('now', {})
+      byTime.get('now')[key] = other[key].value
+    } else {
+      throw new Error('Wrap value into ChangedAt() or NoConflictResolution()')
+    }
+  }
+  for (let [time, fields] of byTime.entries()) {
+    let changedMeta
+    if (time !== 'now') {
+      changedMeta = { time }
+      if (time < since) continue
+    }
+    await server.process(
+      {
+        type: changedType,
+        id,
+        fields
+      },
+      changedMeta
+    )
+  }
+}
+
+export function addSyncMap(server, plural, operations) {
+  let createdType = `${plural}/created`
+  let changedType = `${plural}/changed`
+  let deletedType = `${plural}/deleted`
+  resendFinished(server, plural, createdType)
+  resendFinished(server, plural, changedType)
+  resendFinished(server, plural, deletedType, false)
+
+  if (operations.load) {
+    server.channel(`${plural}/:id`, {
+      access(ctx, action, meta) {
+        return operations.access(ctx, ctx.params.id, action, meta)
+      },
+      async load(ctx, action, meta) {
+        if (action.creating) return
+        let data = await operations.load(
+          ctx,
+          ctx.params.id,
+          action.since,
+          action,
+          meta
+        )
+        if (data !== false) {
+          await sendMap(
+            server,
+            changedType,
+            data,
+            action.since ? action.since.time : 0
+          )
+        }
+      }
+    })
+  }
+
+  if (operations.create) {
+    server.type(`${plural}/create`, {
+      access(ctx, action, meta) {
+        return operations.access(ctx, action.id, action, meta)
+      },
+      async process(ctx, action, meta) {
+        let result = await operations.create(
+          ctx,
+          action.id,
+          action.fields,
+          meta.time,
+          action,
+          meta
+        )
+        if (result !== false) {
+          await addFinished(server, ctx, createdType, action, meta)
+        }
+      }
+    })
+  }
+
+  if (operations.change) {
+    server.type(`${plural}/change`, {
+      access(ctx, action, meta) {
+        return operations.access(ctx, action.id, action, meta)
+      },
+      async process(ctx, action, meta) {
+        let result = await operations.change(
+          ctx,
+          action.id,
+          action.fields,
+          meta.time,
+          action,
+          meta
+        )
+        if (result !== false) {
+          await addFinished(server, ctx, changedType, action, meta)
+        }
+      }
+    })
+  }
+
+  if (operations.delete) {
+    server.type(`${plural}/delete`, {
+      access(ctx, action, meta) {
+        return operations.access(ctx, action.id, action, meta)
+      },
+      async process(ctx, action, meta) {
+        let result = await operations.delete(ctx, action.id, action, meta)
+        if (result !== false) {
+          await addFinished(server, ctx, deletedType, action, meta)
+        }
+      }
+    })
+  }
+}
+
+export function addSyncMapFilter(server, plural, operations) {
+  let changedType = `${plural}/changed`
+
+  server.channel(plural, {
+    access(ctx, action, meta) {
+      return operations.access(ctx, action.filter, action, meta)
+    },
+    filter(ctx, action, meta) {
+      let filter = action.filter ? buildFilter(action.filter) : () => true
+      let custom = operations.actions
+        ? operations.actions(ctx, action.filter, action, meta)
+        : () => true
+      return (ctx2, action2, meta2) => {
+        return filter(ctx2, action2, meta2) && custom(ctx2, action2, meta2)
+      }
+    },
+    async load(ctx, action, meta) {
+      let data = await operations.initial(
+        ctx,
+        action.filter,
+        action.since,
+        action,
+        meta
+      )
+      let since = action.since ? action.since.time : 0
+      await Promise.all(
+        data.map(async i => {
+          await server.subscribe(ctx.nodeId, `${plural}/${i.id}`)
+          await sendMap(server, changedType, i, since)
+        })
+      )
+    }
+  })
+}

package/base-server/index.d.ts

@@ -72,7 +72,7 @@ export interface ServerMeta extends Meta {
   node?: string
 
   /**
-   * Client IDs, which will not recieve the action.
+   * Client IDs, which will not receive the action.
    */
   excludeClients?: string[]
 }
@@ -206,6 +206,14 @@ export interface BaseServerOptions {
    * By default it cleans `Bearer [^\s"]+`.
    */
   cleanFromLog?: RegExp
+
+  /**
+   * Disable health check endpoint, control HTTP API, {@link Server#http}.
+   *
+   * The server will process only WebSocket connection and ignore all other
+   * HTTP request (so they can be processed by other HTTP server).
+   */
+  disableHttpServer?: boolean
 }
 
 export interface AuthenticatorOptions<Headers extends object> {
@@ -750,8 +758,8 @@ export class BaseServer<
    * and node ID. It should return a Promise with `true` or `false`.
    *
    * ```js
-   * server.auth(async ({ userId, token }) => {
-   *   const user = await findUserByToken(token)
+   * server.auth(async ({ userId, cookie }) => {
+   *   const user = await findUserByToken(cookie.token)
    *   return !!user && userId === user.id
    * })
    * ```

package/base-server/index.js

@@ -153,6 +153,8 @@ export class BaseServer {
     this.contexts = new WeakMap()
     this.log = log
 
+    let cleaned = {}
+
     this.on('preadd', (action, meta) => {
       let isLogux = action.type.slice(0, 6) === 'logux/'
       if (!meta.server) {
@@ -178,7 +180,12 @@ export class BaseServer {
     })
     this.on('add', async (action, meta) => {
       let start = Date.now()
-      this.emitter.emit('report', 'add', { action, meta })
+      if (meta.reasons.length === 0) {
+        cleaned[meta.id] = true
+        this.emitter.emit('report', 'addClean', { action, meta })
+      } else {
+        this.emitter.emit('report', 'add', { action, meta })
+      }
 
       if (this.destroying) return
 
@@ -254,6 +261,10 @@ export class BaseServer {
       }
     })
     this.on('clean', (action, meta) => {
+      if (cleaned[meta.id]) {
+        delete cleaned[meta.id]
+        return
+      }
       this.emitter.emit('report', 'clean', { actionId: meta.id })
     })
 
@@ -371,6 +382,11 @@ export class BaseServer {
   }
 
   http(listener) {
+    if (this.options.disableHttpServer) {
+      throw new Error(
+        '`server.http()` can not be called when `disableHttpServer` enabled'
+      )
+    }
     this.httpListener = listener
   }
 
@@ -658,7 +674,6 @@ export class BaseServer {
     try {
       await processor.process(ctx, action, meta)
       latency = Date.now() - start
-      this.emitter.emit('report', 'processed', { actionId: meta.id, latency })
       this.markAsProcessed(meta)
     } catch (e) {
       this.log.changeMeta(meta.id, { status: 'error' })

package/bind-backend-proxy/index.js

@@ -37,7 +37,7 @@ function send(backend, command, events) {
     },
     res => {
       if (res.statusCode < 200 || res.statusCode > 299) {
-        events.error(new Error(`Backend responsed with ${res.statusCode} code`))
+        events.error(new Error(`Backend responded with ${res.statusCode} code`))
       } else {
         let data = false
         res

package/bind-control-server/index.js

@@ -17,6 +17,17 @@ function isValidBody(body) {
 }
 
 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'
+      )
+      err.logux = true
+      throw err
+    }
+    return
+  }
+
   let masks = app.options.controlMask.split(/,\s*/).map(i => ip.cidrSubnet(i))
   app.httpServer.on('request', async (req, res) => {
     let urlString = req.url

package/create-reporter/index.js

@@ -1,7 +1,14 @@
 import pino from 'pino'
 import os from 'os'
+import { dirname, join, sep } from 'path'
+import pico from 'picocolors'
+import { fileURLToPath } from 'url'
 
-import { humanFormatter } from '../human-formatter/index.js'
+const __dirname = dirname(fileURLToPath(import.meta.url))
+export const PATH_TO_PRETTIFYING_PINO_TRANSPORT = join(
+  __dirname,
+  '../human-formatter/index.js'
+)
 
 const ERROR_CODES = {
   EADDRINUSE: e => {
@@ -105,9 +112,9 @@ const REPORTERS = {
 
   add: () => ({ msg: 'Action was added' }),
 
-  clean: () => ({ msg: 'Action was cleaned' }),
+  addClean: () => ({ msg: 'Action was added and cleaned' }),
 
-  processed: () => ({ msg: 'Action was processed' }),
+  clean: () => ({ msg: 'Action was cleaned' }),
 
   subscribed: () => ({ msg: 'Client was subscribed' }),
 
@@ -198,27 +205,36 @@ const REPORTERS = {
 }
 
 function createLogger(options) {
-  let stream = options.logger.stream || pino.destination()
-  let prettifier = {}
   if (options.logger === 'human' || options.logger.type === 'human') {
     let env = options.env || process.env.NODE_ENV || 'development'
-    let color = env !== 'development' ? false : undefined
-    prettifier = {
-      prettyPrint: {
-        suppressFlushSyncWarning: true,
-        basepath: options.root,
-        color
-      },
-      prettifier: humanFormatter
-    }
+    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({
+        target: PATH_TO_PRETTIFYING_PINO_TRANSPORT,
+        options: {
+          basepath,
+          color,
+          destination: options.logger.destination
+        }
+      })
+    )
+
+    // NOTE: needed only for tests
+    logger._basepath = basepath
+    logger._color = color
+
+    return logger
   }
   return pino(
     {
       name: 'logux-server',
-      timestamp: pino.stdTimeFunctions.isoTime,
-      ...prettifier
+      timestamp: pino.stdTimeFunctions.isoTime
     },
-    stream
+    options.logger.stream || pino.destination()
   )
 }
 

package/human-formatter/index.js

@@ -1,16 +1,19 @@
 import stripAnsi from 'strip-ansi'
 import yyyymmdd from 'yyyy-mm-dd'
 import pico from 'picocolors'
-import path from 'path'
 import os from 'os'
+import abstractTransport from 'pino-abstract-transport'
+import { Transform } from 'stream'
+import pino from 'pino'
+import { once } from 'events'
+
+import { mulberry32, onceXmur3 } from './utils.js'
 
 const INDENT = '  '
 const PADDING = '        '
 const SEPARATOR = os.EOL + os.EOL
 const NEXT_LINE = os.EOL === '\n' ? '\r\v' : os.EOL
 
-const LATENCY_UNIT = ' ms'
-
 const PARAMS_BLACKLIST = {
   v: true,
   msg: true,
@@ -34,6 +37,8 @@ const LABELS = {
   60: (c, str) => label(c, ' FATAL ', 'red', 'bgRed', 'white', str)
 }
 
+const COLORS = ['red', 'green', 'yellow', 'blue', 'magenta', 'cyan']
+
 function rightPag(str, length) {
   let add = length - stripAnsi(str).length
   for (let i = 0; i < add; i++) str += ' '
@@ -56,15 +61,54 @@ function formatName(key) {
     .replace(/^\w/, char => char.toUpperCase())
 }
 
+function shuffledColors(str) {
+  let index = -1
+  let result = Array.from(COLORS)
+  let lastIndex = result.length - 1
+  let seed = onceXmur3(str)
+  let randomFn = mulberry32(seed)
+
+  while (++index < COLORS.length) {
+    let randIndex = index + Math.floor(randomFn() * (lastIndex - index + 1))
+    let value = result[randIndex]
+
+    result[randIndex] = result[index]
+    result[index] = value
+  }
+  return result
+}
+
+function splitAndColorize(c, partLength, str) {
+  let strBuilder = []
+  let colors = shuffledColors(str)
+
+  for (
+    let start = 0, end = partLength, n = 0, color = colors[n];
+    start < str.length;
+    start += partLength,
+      end += partLength,
+      n = n + 1,
+      color = colors[n % colors.length]
+  ) {
+    let strToColorize = str.slice(start, end)
+    if (strToColorize.length === 1) {
+      color = colors[Math.abs(n - 1) % colors.length]
+    }
+    strBuilder.push(c[color](strToColorize))
+  }
+
+  return strBuilder.join('')
+}
+
 function formatNodeId(c, nodeId) {
   let pos = nodeId.lastIndexOf(':')
-  let id, random
   if (pos === -1) {
     return nodeId
   } else {
-    id = nodeId.slice(0, pos)
-    random = nodeId.slice(pos)
-    return c.bold(id) + random
+    let s = nodeId.split(':')
+    let id = c.bold(s[0])
+    let random = splitAndColorize(c, 3, s[1])
+    return `${id}:${random}`
   }
 }
 
@@ -92,7 +136,13 @@ function formatArray(c, array) {
 
 function formatActionId(c, id) {
   let p = id.split(' ')
-  return `${c.bold(p[0])} ${formatNodeId(c, p[1])} ${c.bold(p[2])}`
+  if (p.length === 1) {
+    return p
+  }
+  return `${c.bold(splitAndColorize(c, 4, p[0]))} ${formatNodeId(
+    c,
+    p[1]
+  )} ${c.bold(p[2])}`
 }
 
 function formatParams(c, params, parent) {
@@ -108,8 +158,13 @@ function formatParams(c, params, parent) {
 
       let start = PADDING + rightPag(`${name}: `, maxName + 2)
 
-      if (name === 'Node ID') {
+      if (name === 'Node ID' || (parent === 'Meta' && name === 'server')) {
         return start + formatNodeId(c, value)
+      } else if (
+        parent === 'Meta' &&
+        (name === 'clients' || name === 'excludeClients')
+      ) {
+        return `${start}[${value.map(v => `"${formatNodeId(c, v)}"`).join()}]`
       } else if (name === 'Action ID' || (parent === 'Meta' && name === 'id')) {
         return start + formatActionId(c, value)
       } else if (Array.isArray(value)) {
@@ -124,8 +179,6 @@ function formatParams(c, params, parent) {
             .split(NEXT_LINE)
             .join(NEXT_LINE + INDENT)
         )
-      } else if (name === 'Latency' && !parent) {
-        return start + c.bold(value) + LATENCY_UNIT
       } else if (typeof value === 'string' && parent) {
         return start + '"' + c.bold(value) + '"'
       } else {
@@ -169,14 +222,11 @@ function prettyStackTrace(c, stack, basepath) {
     .join(NEXT_LINE)
 }
 
-export function humanFormatter(options) {
+function humanFormatter(options) {
   let c = pico.createColors(options.color)
-  this.color = c.isColorSupported
-  let basepath = options.basepath || process.cwd()
-  if (basepath.slice(-1) !== path.sep) basepath += path.sep
-  this.basepath = basepath
+  let basepath = options.basepath
 
-  return function (record) {
+  return function format(record) {
     let message = [LABELS[record.level](c, record.msg)]
     let params = Object.keys(record)
       .filter(key => !PARAMS_BLACKLIST[key])
@@ -213,3 +263,32 @@ export function humanFormatter(options) {
     return message.filter(i => i !== '').join(NEXT_LINE) + SEPARATOR
   }
 }
+
+export default async function (options) {
+  let format = humanFormatter(options)
+  let destination = pino.destination({
+    dest: options.destination || 1,
+    sync: options.sync || false
+  })
+  await once(destination, 'ready')
+  let transform = new Transform({
+    autoDestroy: true,
+    objectMode: true,
+    transform(chunk, encoding, callback) {
+      callback(null, format(chunk))
+    }
+  })
+
+  return abstractTransport(
+    source => {
+      source.pipe(transform)
+      transform.pipe(destination)
+    },
+    {
+      close(err, cb) {
+        transform.end()
+        transform.on('close', cb.bind(null, err))
+      }
+    }
+  )
+}

package/human-formatter/utils.js

@@ -0,0 +1,20 @@
+export function onceXmur3(str) {
+  let h = 1779033703 ^ str.length
+  for (let i = 0; i < str.length; i++) {
+    h = Math.imul(h ^ str.charCodeAt(i), 3432918353)
+    h = (h << 13) | (h >>> 19)
+  }
+  h = Math.imul(h ^ (h >>> 16), 2246822507)
+  h = Math.imul(h ^ (h >>> 13), 3266489909)
+  return (h ^ (h >>> 16)) >>> 0
+}
+
+export function mulberry32(a) {
+  return function () {
+    a |= 0
+    a = (a + 0x6d2b79f5) | 0
+    let t = Math.imul(a ^ (a >>> 15), 1 | a)
+    t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296
+  }
+}

package/index.d.ts

@@ -17,6 +17,15 @@ export {
   put,
   del
 } from './request/index.js'
+export {
+  NoConflictResolution,
+  addSyncMapFilter,
+  WithoutTime,
+  SyncMapData,
+  addSyncMap,
+  ChangedAt,
+  WithTime
+} from './add-sync-map/index.js'
 export { TestServer, TestServerOptions } from './test-server/index.js'
 export { TestClient, LoguxActionError } from './test-client/index.js'
 export { Context, ChannelContext } from './context/index.js'

package/index.js

@@ -7,6 +7,12 @@ export {
   put,
   del
 } from './request/index.js'
+export {
+  NoConflictResolution,
+  addSyncMapFilter,
+  addSyncMap,
+  ChangedAt
+} from './add-sync-map/index.js'
 export { BaseServer, wasNot403 } from './base-server/index.js'
 export { ALLOWED_META } from './allowed-meta/index.js'
 export { TestServer } from './test-server/index.js'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@logux/server",
-  "version": "0.10.7",
+  "version": "0.12.0",
   "description": "Build own Logux server or make proxy between WebSocket and HTTP backend on any language",
   "keywords": [
     "logux",
@@ -18,7 +18,7 @@
   "homepage": "https://logux.io/",
   "repository": "logux/server",
   "engines": {
-    "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+    "node": "^14.0.0 || ^16.0.0 || >=18.0.0"
   },
   "type": "module",
   "types": "./index.d.ts",
@@ -27,23 +27,24 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@logux/actions": "^0.2.1",
-    "@logux/core": "^0.7.2",
+    "@logux/actions": "^0.3.0",
+    "@logux/core": "^0.8.0",
     "JSONStream": "^1.3.5",
-    "cookie": "^0.4.1",
-    "dotenv": "^10.0.0",
-    "fast-glob": "^3.2.7",
-    "ip": "^1.1.5",
+    "cookie": "^0.5.0",
+    "dotenv": "^16.0.2",
+    "fast-glob": "^3.2.11",
+    "ip": "^1.1.8",
     "nanodelay": "^2.0.2",
-    "nanoevents": "^6.0.2",
-    "nanoid": "^3.1.30",
-    "node-fetch": "^2.6.1",
+    "nanoevents": "^7.0.1",
+    "nanoid": "^4.0.0",
+    "node-fetch": "^2.6.7",
     "picocolors": "^1.0.0",
-    "pino": "^6.13.3",
-    "semver": "^7.3.5",
+    "pino": "8.4.2",
+    "pino-abstract-transport": "^1.0.0",
+    "semver": "^7.3.7",
     "strip-ansi": "^7.0.1",
     "url-pattern": "^1.0.3",
-    "ws": "^8.2.3",
+    "ws": "^8.8.1",
     "yyyy-mm-dd": "^1.0.2"
   }
 }

package/test-client/index.d.ts

@@ -151,7 +151,7 @@ export class TestClient {
    * @param test Function, where do you expect action will be received
    * @returns Promise with all received actions
    */
-  collect(test: () => Promise<void>): Promise<Action[]>
+  collect(test: () => Promise<any>): Promise<Action[]>
 
   /**
    * Send action to the sever and collect all response actions.
@@ -180,11 +180,13 @@ export class TestClient {
    *
    * @param channel Channel name or `logux/subscribe` action.
    * @param filter Optional filter for subscription.
+   * @param since Optional time from last data.
    * @returns Promise with all actions from the server.
    */
   subscribe(
     channel: string | LoguxSubscribeAction,
-    filter?: object
+    filter?: object,
+    since?: { id: string; time: number }
   ): Promise<Action[]>
 
   /**
@@ -216,5 +218,5 @@ export class TestClient {
    * @param test Function, where do you expect action will be received
    * @returns Promise with all received actions
    */
-  received(test: () => Promise<void> | void): Promise<Action[]>
+  received(test: () => Promise<any> | any): Promise<Action[]>
 }

package/test-client/index.js

@@ -133,7 +133,7 @@ export class TestClient {
     })
   }
 
-  async subscribe(channel, filter) {
+  async subscribe(channel, filter, since) {
     let action = channel
     if (typeof channel === 'string') {
       action = { type: 'logux/subscribe', channel }
@@ -141,6 +141,9 @@ export class TestClient {
     if (filter) {
       action.filter = filter
     }
+    if (since) {
+      action.since = since
+    }
     let actions = await this.process(action)
     return actions.filter(i => i.type !== 'logux/processed')
   }

package/test-server/index.d.ts

@@ -126,4 +126,16 @@ export class TestServer<
    * @param test Callback with subscripting or action sending.
    */
   expectUndo(reason: string, test: () => any | Promise<any>): Promise<void>
+
+  /**
+   * Call callback and throw an error if there was no error during
+   * server processing.
+   *
+   * @param text RegExp or string of error message.
+   * @param test Callback with subscripting or action sending.
+   */
+  expectError(
+    text: string | RegExp,
+    test: () => any | Promise<any>
+  ): Promise<void>
 }

package/test-server/index.js

@@ -30,6 +30,10 @@ export class TestServer extends BaseServer {
     }
     if (opts.auth !== false) this.auth(() => true)
     this.testUsers = {}
+
+    this.on('fatal', () => {
+      this.destroy()
+    })
   }
 
   async connect(userId, opts = {}) {
@@ -70,4 +74,18 @@ export class TestServer extends BaseServer {
       }
     }
   }
+
+  async expectError(text, test) {
+    try {
+      await test()
+      throw new Error('Actions passed without error')
+    } catch (e) {
+      if (
+        (typeof text === 'string' && e.message !== text) ||
+        (text instanceof RegExp && !text.test(e.message))
+      ) {
+        throw e
+      }
+    }
+  }
 }