comq 0.16.1 → 0.17.0

package/source/attributes/lazy.js

@@ -1,8 +1,18 @@
 'use strict'
 
+/**
+ * Runs the initializers once per distinct set of arguments before the method.
+ *
+ * The record of what has been initialized is kept per context, so that a context
+ * that is dropped takes its record with it, and it is looked up by argument rather
+ * than scanned — a channel publishing to a thousand queues asks for the thousandth
+ * as fast as for the first.
+ *
+ * @param {object} context
+ * @param {Function | Function[]} initializers
+ * @param {(...args: unknown[]) => Promise<unknown>} method
+ */
 function lazy (context, initializers, method) {
-  if (context[LOCK] === undefined) context[LOCK] = Symbol('methods locking key')
-
   if (!Array.isArray(initializers)) initializers = [initializers]
 
   return async function (...args) {
@@ -24,7 +34,7 @@ async function call (context, initializers, args) {
   let override
 
   for (const init of initializers) {
-    const result = await resolve(context, init, args)
+    const result = await lock(context, init, args)
 
     if (result !== undefined) override = result
   }
@@ -33,46 +43,76 @@ async function call (context, initializers, args) {
 }
 
 /**
+ * An initializer expecting N arguments is run once per distinct N leading
+ * arguments, which are the keys of a trie of Maps N levels deep.
+ *
  * @param {object} context
- * @param {Function} init
- * @param {any[]} args
- * @returns {Promise}
+ * @param {(...args: unknown[]) => Promise<unknown>} init
+ * @param {unknown[]} args
+ * @returns {Promise<unknown>}
  */
-function resolve (context, init, args) {
-  const key = context[LOCK]
-  const expected = args.slice(0, init.length)
+function lock (context, init, args) {
+  const arity = init.length
+
+  let node = table(context, init)
+
+  for (let i = 0; i < arity - 1; i++) node = branch(node, args[i])
+
+  const key = arity === 0 ? NONE : args[arity - 1]
+  const found = node.get(key)
+
+  if (found !== undefined) return found
+
+  const promise = init.apply(context, args.slice(0, arity))
+
+  node.set(key, promise)
 
-  return lock(context, init, expected, key)
+  return promise
 }
 
 /**
  * @param {object} context
- * @param {(...args: unknown[]) => Promise<unknown>} init
- * @param {unknown[]} args
- * @param {Symbol} key
- * @returns {Promise<unknown>}
+ * @param {Function} init
+ * @return {Map<unknown, unknown>}
  */
-function lock (context, init, args, key) {
-  if (init[key] === undefined) init[key] = []
+function table (context, init) {
+  let tables = TABLES.get(context)
 
-  const locks = init[key]
-  const found = locks.find((lock) => lock.args.reduce((match, argument, i) => match && argument === args[i], true))
+  if (tables === undefined) {
+    tables = new Map()
+    TABLES.set(context, tables)
+  }
 
-  if (found !== undefined) return found.promise
+  return branch(tables, init)
+}
 
-  const promise = init.apply(context, args)
-  const lock = { args, promise }
+/**
+ * @param {Map<unknown, unknown>} node
+ * @param {unknown} key
+ * @return {Map<unknown, unknown>}
+ */
+function branch (node, key) {
+  let next = node.get(key)
 
-  locks.push(lock)
+  if (next === undefined) {
+    next = new Map()
+    node.set(key, next)
+  }
 
-  return promise
+  return /** @type {Map<unknown, unknown>} */ next
 }
 
+/**
+ * @param {object} context
+ */
 function reset (context) {
-  context[LOCK] = context[LOCK] = Symbol('methods locking key')
+  TABLES.delete(context)
 }
 
-const LOCK = Symbol('context locking key')
+/** @type {WeakMap<object, Map<Function, Map<unknown, unknown>>>} */
+const TABLES = new WeakMap()
+
+const NONE = Symbol('no arguments')
 
 lazy.reset = reset
 

package/source/attributes/lazy.test.js

@@ -297,3 +297,42 @@ describe('reset', () => {
     expect(initialize2).toHaveBeenCalledTimes(2)
   })
 })
+
+class Exposed {
+  do = lazy(this, this.initialize, async () => undefined)
+
+  async initialize (_) {}
+}
+
+// an initializer is a method shared by every instance of its class, so a record
+// kept on it would outlive the instances it was made for
+it('should keep no record on the initializer or the context', async () => {
+  const instance = new Exposed()
+
+  await instance.do(generate())
+  lazy.reset(instance)
+  await instance.do(generate())
+
+  expect(Object.getOwnPropertySymbols(Exposed.prototype.initialize)).toHaveLength(0)
+  expect(Object.getOwnPropertySymbols(instance)).toHaveLength(0)
+})
+
+it('should tell arguments apart by identity', async () => {
+  let calls = 0
+
+  class Counted {
+    do = lazy(this, this.initialize, async () => undefined)
+
+    async initialize (_) {
+      calls++
+    }
+  }
+
+  const instance = new Counted()
+
+  await instance.do(undefined)
+  await instance.do('undefined')
+  await instance.do(undefined)
+
+  expect(calls).toStrictEqual(2)
+})

package/source/attributes/recall.js

@@ -36,7 +36,24 @@ async function replay (context) {
   await Promise.all(promises)
 }
 
+/**
+ * Forgets the recorded calls, and the arguments they hold on to.
+ *
+ * @param {object} context
+ */
+function reset (context) {
+  const methods = context[METHODS]
+
+  if (methods === undefined) return
+
+  for (const method of methods) method[CALLS] = undefined
+
+  context[METHODS] = undefined
+}
+
 const METHODS = Symbol('context methods')
 const CALLS = Symbol('method calls')
 
+recall.reset = reset
+
 exports.recall = recall

package/source/attributes/recall.test.js

@@ -90,3 +90,46 @@ it('should not re-call those thrown exceptions', async () => {
 
   expect(method).toHaveBeenCalledTimes(3)
 })
+
+describe('reset', () => {
+  it('should be', async () => {
+    expect(recall.reset).toBeDefined()
+  })
+
+  it('should forget recorded calls', async () => {
+    const context = {}
+    const func = recall(context, method)
+
+    await func(generate())
+
+    recall.reset(context)
+    method.mockClear()
+
+    await recall(context)
+
+    expect(method).not.toHaveBeenCalled()
+  })
+
+  it('should record again after reset', async () => {
+    const context = {}
+    const func = recall(context, method)
+
+    await func(generate())
+
+    recall.reset(context)
+
+    const args = [generate()]
+
+    await func(...args)
+    method.mockClear()
+
+    await recall(context)
+
+    expect(method).toHaveBeenCalledTimes(1)
+    expect(method).toHaveBeenCalledWith(...args)
+  })
+
+  it('should not throw on a context without records', async () => {
+    expect(() => recall.reset({})).not.toThrow()
+  })
+})

package/source/channel.js

@@ -44,17 +44,22 @@ class Channel {
 
   #closed = false
 
+  /** @type {(channel: comq.Channel) => void} */
+  #release
+
   /**
    * @param {comq.amqp.Connection} connection
    * @param {comq.Topology} topology
-   * @param {number} index
+   * @param {number} [index]
+   * @param {(channel: comq.Channel) => void} [release] called once the channel is given back
    */
-  constructor (connection, topology, index) {
+  constructor (connection, topology, index, release = noop) {
     this.index = index
 
     this.#connection = connection
     this.#topology = topology
     this.#failfast = index !== undefined
+    this.#release = release
 
     if (this.#failfast) failsafe.disable(this.send, this.publish)
   }
@@ -63,6 +68,9 @@ class Channel {
     if (this.#topology.confirms) this.#channel = await this.#connection.createConfirmChannel()
     else this.#channel = await this.#connection.createChannel()
 
+    // the consumers of the previous channel went down with it, their tags mean nothing here
+    this.#tags = []
+
     await this.#channel.prefetch(this.#topology.prefetch)
 
     this.#channel.on('drain', this.#unpause)
@@ -93,6 +101,24 @@ class Channel {
           if (!this.#sealed) await this.#consume(queue, callback)
         })))
 
+  /**
+   * Consumes a named queue bound to a direct exchange under a routing key, where `subscribe`
+   * binds to a fanout and takes everything published to it.
+   */
+  bound = recall(this,
+    failsafe(this, this.#recover,
+      lazy(this, [this.#assertRouted, this.#assertKeyedQueue],
+        /**
+         * @param {string} exchange
+         * @param {string} queue
+         * @param {string} key
+         * @param {comq.channels.Consumer} callback
+         * @returns {Promise<void>}
+         */
+        async (exchange, queue, key, callback) => {
+          if (!this.#sealed) await this.#consume(queue, callback)
+        })))
+
   send = failsafe(this, this.#recover,
     lazy(this, this.#assertQueue,
       /**
@@ -115,6 +141,21 @@ class Channel {
         await this.#publish(exchange, DEFAULT, buffer, options)
       }))
 
+  /**
+   * Publishes to a direct exchange under a routing key, where `publish` fans out.
+   */
+  route = failsafe(this, this.#recover,
+    lazy(this, this.#assertRouted,
+      /**
+       * @param {string} exchange
+       * @param {string} key
+       * @param {Buffer} buffer
+       * @param {comq.amqp.options.Publish} [options]
+       */
+      async (exchange, key, buffer, options) => {
+        await this.#publish(exchange, key, buffer, options)
+      }))
+
   async fire (queue, buffer, options) {
     try {
       await this.#publish(DEFAULT, queue, buffer, options)
@@ -141,6 +182,8 @@ class Channel {
 
     // a channel that went down with its connection is the outcome this asks for
     await this.#channel?.close().catch(noop)
+
+    this.#release(this)
   }
 
   async seal () {
@@ -149,6 +192,10 @@ class Channel {
     const cancellations = this.#tags.map((tag) => this.#channel.cancel(tag))
 
     await Promise.all(cancellations).catch(noop) // won't recover anyway
+
+    // a sealed channel is not going to consume again, so what it has consumed
+    // and the callbacks it was given are of no use anymore
+    recall.reset(this)
   }
 
   diagnose (event, listener) {
@@ -216,6 +263,33 @@ class Channel {
     await this.#channel.assertExchange(exchange, 'fanout', options)
   }
 
+  /**
+   * A routed exchange is `direct`: a message reaches the queues bound under the key it was
+   * published with, and none of the others.
+   *
+   * @param {string} exchange
+   * @returns {Promise<void>}
+   */
+  async #assertRouted (exchange) {
+    /** @type {comq.amqp.options.Exchange} */
+    const options = { durable: this.#topology.durable }
+
+    await this.#channel.assertExchange(exchange, 'direct', options)
+  }
+
+  /**
+   * @param {string} exchange
+   * @param {string} queue
+   * @param {string} key
+   * @returns {Promise<string[]>}
+   */
+  async #assertKeyedQueue (exchange, queue, key) {
+    queue = (await this.#assertQueue(queue))[0]
+    await this.#channel.bindQueue(queue, exchange, key)
+
+    return [exchange, queue, key]
+  }
+
   /**
    *
    * @param {string} exchange
@@ -260,12 +334,12 @@ class Channel {
    */
   #confirmation () {
     const confirmation = new Promex()
+    const settled = () => this.#confirmations.delete(confirmation)
 
     this.#confirmations.add(confirmation)
 
-    confirmation
-      .catch(noop) // have no idea why, but this is required
-      .finally(() => this.#confirmations.delete(confirmation))
+    // one derived promise per publish, and a rejection handled with it
+    confirmation.then(settled, settled)
 
     return confirmation
   }
@@ -372,10 +446,11 @@ class Channel {
  * @param {comq.amqp.Connection} connection
  * @param {comq.Topology} topology
  * @param {number} [index]
+ * @param {(channel: comq.Channel) => void} [release]
  * @return {Promise<comq.Channel>}
  */
-async function create (connection, topology, index) {
-  const channel = new Channel(connection, topology, index)
+async function create (connection, topology, index, release) {
+  const channel = new Channel(connection, topology, index, release)
 
   await channel.create()
 

package/source/connection.js

@@ -20,8 +20,8 @@ class Connection {
   /** @type {comq.amqp.Connection} */
   #connection
 
-  /** @type {comq.Channel[]} */
-  #channels = []
+  /** @type {Set<comq.Channel>} */
+  #channels = new Set()
 
   /** @type {Promex} */
   #recovery = new Promex()
@@ -90,10 +90,13 @@ class Connection {
       if (this.#connection === undefined) await this.#recovery
 
       const topology = presets[type]
-      const channel = await channels.create(this.#connection, topology, index)
 
-      this.#channels = this.#channels.filter((channel) => !channel.closed)
-      this.#channels.push(channel)
+      // a closed channel held here would hold its IO, and a shared connection is
+      // in no hurry to make another channel that would have swept it out
+      const release = (channel) => this.#channels.delete(channel)
+      const channel = await channels.create(this.#connection, topology, index, release)
+
+      this.#channels.add(channel)
 
       return channel
     })
@@ -102,6 +105,10 @@ class Connection {
     this.#diagnostics.on(event, listener)
   }
 
+  forget (event, listener) {
+    this.#diagnostics.off(event, listener)
+  }
+
   #open = async (retry) => {
     if (this.#closed) return
 
@@ -134,9 +141,10 @@ class Connection {
     this.#diagnostics.emit('open')
 
     try {
-      this.#channels = this.#channels.filter((channel) => !channel.closed)
-
-      for (const channel of this.#channels) await channel.recover(connection)
+      for (const channel of this.#channels) {
+        if (channel.closed) this.#channels.delete(channel)
+        else await channel.recover(connection)
+      }
     } catch (exception) {
       this.#diagnostics.emit('error', exception)
       this.#drop(connection)