comq 0.9.0 → 0.10.0

package/source/shards/connection.js

@@ -1,8 +1,8 @@
 'use strict'
 
-const { EventEmitter } = require('node:events')
 const events = require('../events')
 const channel = require('./channel')
+const emitter = require('../emitter')
 
 /**
  * @implements {comq.Connection}
@@ -11,7 +11,7 @@ class Connection {
   /** @type {comq.Connection[]} */
   #connections
 
-  #diagnostics = new EventEmitter()
+  #diagnostics = emitter.create()
 
   /**
    * @param {comq.Connection[]} connections

package/test/channel.test.js

@@ -67,7 +67,9 @@ describe('consume', () => {
   it('should assert queue', async () => {
     await channel.consume(queue, consumer)
 
-    const options = topology.durable ? { durable: true } : { exclusive: true }
+    const options = topology.durable
+      ? { durable: true }
+      : { exclusive: true }
 
     expect(chan.assertQueue).toHaveBeenCalledWith(queue, options)
   })

package/test/encode.test.js

@@ -11,7 +11,7 @@ it('should be', async () => {
 
 it('should throw if encoding is not supported', async () => {
   const value = 1
-  const encoding = /** @type {comq.encoding} */ 'wtf/' + generate()
+  const encoding = /** @type {comq.Encoding} */ 'wtf/' + generate()
 
   expect(() => encode(value, encoding)).toThrow('not supported')
 })
@@ -34,7 +34,7 @@ it('should encode as msgpack', async () => {
   expect(buffer).toStrictEqual(packed)
 })
 
-/** @type {[comq.encoding, string, Buffer][]} */
+/** @type {[comq.Encoding, string, Buffer][]} */
 const samples = [
   ['text/plain', 'some string', Buffer.from('some string')]
 ]

package/test/encodings.js

@@ -1,4 +1,4 @@
 'use strict'
 
-/** @type {comq.encoding[]} */
+/** @type {comq.Encoding[]} */
 exports.encodings = ['application/msgpack', 'application/json']

package/test/io.diagnostics.test.js

@@ -30,7 +30,7 @@ describe.each(['request', 'reply', 'event'])('%s channel events',
   (type) => {
     it.each(['flow', 'drain', 'recover', 'discard', 'pause', 'resume'])('should re-emit %s',
       /**
-       * @param {comq.diagnostics.event} event
+       * @param {comq.diagnostics.Event} event
        */
       async (event) => {
         const listener = /** @type {Function} */ jest.fn()
@@ -56,7 +56,7 @@ describe.each(['request', 'reply', 'event'])('%s channel events',
 
 it.each(['open', 'close'])('should re-emit %s from connection',
   /**
-   * @param {comq.diagnostics.event} event
+   * @param {comq.diagnostics.Event} event
    */
   async (event) => {
     const listener = /** @type {Function} */ jest.fn(() => undefined)

package/test/io.request.test.js

@@ -89,25 +89,6 @@ describe('send', () => {
     expect(properties.replyTo).toMatch(rx)
   })
 
-  it('should set replyTo using specified formatter', async () => {
-    jest.clearAllMocks()
-
-    /** @type {comq.encoding} */
-    const prefix = generate()
-    const encoding = 'application/json'
-    const formatter = (replyTo) => prefix + replyTo
-
-    promise = io.request(queue, payload, encoding, formatter)
-
-    await immediate()
-
-    call = requests.send.mock.calls[0]
-
-    const properties = requests.send.mock.calls[0][2]
-
-    expect(properties.replyTo).toMatch(new RegExp(`${prefix}${queue}..[a-z0-9]+`))
-  })
-
   it('should consume replyTo', async () => {
     const properties = call[2]
     const queue = replies.consume.mock.calls[0][0]
@@ -116,7 +97,7 @@ describe('send', () => {
   })
 
   it('should encode message with msgpack by default', async () => {
-    /** @type {comq.encoding} */
+    /** @type {comq.Encoding} */
     const contentType = 'application/msgpack'
     const buffer = encode(payload, contentType)
 
@@ -125,7 +106,7 @@ describe('send', () => {
   })
 
   it('should throw if encoding is not supported', async () => {
-    const encoding = /** @type {comq.encoding} */ 'wtf/' + generate()
+    const encoding = /** @type {comq.Encoding} */ 'wtf/' + generate()
 
     await expect(io.request(queue, payload, encoding)).rejects.toThrow('is not supported')
   })
@@ -153,7 +134,7 @@ describe('send', () => {
 
     setImmediate(reply)
 
-    await io.request(queue, payload, /** @type {comq.encoding} */ encoding)
+    await io.request(queue, payload, /** @type {comq.Encoding} */ encoding)
 
     const [, buffer, properties] = requests.send.mock.calls[0]
 
@@ -244,7 +225,7 @@ describe('reply', () => {
 
   it.each(encodings)('should decode %s',
     /**
-     * @param {comq.encoding}contentType
+     * @param {comq.Encoding}contentType
      */
     async (contentType) => {
       const value = generate()

package/test/shards/channel.test.js

@@ -289,7 +289,7 @@ describe('seal', () => {
 })
 
 describe('diagnose', () => {
-  const events = /** @type {comq.diagnostics.event[]} */ ['flow', 'drain', 'recover', 'discard']
+  const events = /** @type {comq.diagnostics.Event[]} */ ['flow', 'drain', 'recover', 'discard']
 
   /** @type {jest.MockedObject<comq.Channel>[]} */
   let channels

package/test/shards/connection.test.js

@@ -106,7 +106,7 @@ describe('createChannel', () => {
   })
 })
 
-describe.each(/** @type {comq.diagnostics.event[]} */ ['open', 'close'])('diagnose %s event',
+describe.each(/** @type {comq.diagnostics.Event[]} */ ['open', 'close'])('diagnose %s event',
   (event) => {
     it('should re-emit event', async () => {
       const index = random(connections.length)

package/types/channel.d.ts

@@ -5,7 +5,7 @@ declare namespace comq {
 
   namespace channels {
 
-    type consumer = (message: Message) => void | Promise<void>
+    type Consumer = (message: Message) => void | Promise<void>
 
   }
 
@@ -13,26 +13,28 @@ declare namespace comq {
     index?: number
     sharded?: boolean
 
-    create(): Promise<void>
+    create (): Promise<void>
 
-    consume(queue: string, consumer: channels.consumer): Promise<void>
+    consume (queue: string, consumer: channels.Consumer): Promise<string>
 
-    subscribe(exchange: string, queue: string, consumer: channels.consumer): Promise<void>
+    subscribe (exchange: string, queue: string, consumer: channels.Consumer): Promise<void>
 
-    send(queue: string, buffer: Buffer, options?: Options.Publish): Promise<void>
+    send (queue: string, buffer: Buffer, options?: Options.Publish): Promise<void>
 
-    publish(exchange: string, buffer: Buffer, options?: Options.Publish): Promise<void>
+    publish (exchange: string, buffer: Buffer, options?: Options.Publish): Promise<void>
 
-    fire(queue: string, buffer: Buffer, options?: Options.Publish): Promise<void>
+    fire (queue: string, buffer: Buffer, options?: Options.Publish): Promise<boolean>
 
-    seal(): Promise<void>
+    seal (): Promise<void>
 
-    diagnose(event: _diagnostics.event, listener: Function): void
+    diagnose (event: _diagnostics.Event, listener: Function): void
 
-    recover(connection: Connection): Promise<void>
+    forget (event: _diagnostics.Event, listener: Function): void
+
+    recover (connection: Connection): Promise<void>
   }
 
 }
 
 export type Channel = comq.Channel
-export type consumer = comq.channels.consumer
+export type Consumer = comq.channels.Consumer

package/types/connection.d.ts

@@ -14,11 +14,11 @@ declare namespace comq {
 
     createChannel(type: _topology.type, index: number): Promise<_channel.Channel>
 
-    diagnose(event: _diagnostics.event, listener: Function): void
+    diagnose(event: _diagnostics.Event, listener: Function): void
   }
 
-  type connect = (...urls: string[]) => Promise<_io.IO>
+  type Connect = (...urls: string[]) => Promise<_io.IO>
 
 }
 
-export type connect = comq.connect
+export type Connect = comq.Connect

package/types/diagnostic.d.ts

@@ -1,12 +1,13 @@
 declare namespace comq.diagnostics {
 
-  type event = 'open' | 'close' | 'flow' | 'drain' | 'remove' | 'recover' | 'discard' | 'pause' | 'resume'
+  type Event = 'open' | 'close' | 'flow' | 'drain' | 'remove' | 'recover' | 'discard' |
+    'pause' | 'resume' | 'return'
 
   interface Diagnosable {
-    diagnose(event: event, listener: Function): void
+    diagnose(event: Event, listener: Function): void
   }
 
 }
 
-export type event = comq.diagnostics.event
+export type Event = comq.diagnostics.Event
 export type Diagnosable = comq.diagnostics.Diagnosable

package/types/encoding.d.ts

@@ -1,6 +1,6 @@
 declare namespace comq {
 
-  type encoding =
+  type Encoding =
     'application/msgpack'
     | 'application/json'
     | 'application/octet-stream'
@@ -8,4 +8,4 @@ declare namespace comq {
 
 }
 
-export type encoding = comq.encoding
+export type Encoding = comq.Encoding

package/types/index.d.ts

@@ -1,6 +1,6 @@
-import { connect } from './connection'
+import { Connect } from './connection'
 
-export type { IO, consumer, producer } from './io'
+export type { IO, Consumer, Producer } from './io'
 
-export const connect: connect
-export const assert: connect
+export const connect: Connect
+export const assert: Connect

package/types/io.d.ts

@@ -1,4 +1,5 @@
 import type { Readable } from 'node:stream'
+import type { EventEmitter } from 'node:events'
 import * as _diagnostics from './diagnostic'
 import * as _encoding from './encoding'
 import * as _topology from './topology'
@@ -6,70 +7,65 @@ import * as _amqp from './amqp'
 
 declare namespace comq {
 
-  type producer = (message: any) => any | Promise<any>
-  type consumer = (message: any, headers?: _amqp.Properties) => void | Promise<void>
+  type Producer<Input = any, Output = any> = (message: Input) => Output | Promise<Output>
+  type Consumer<T = any> = (message: T, headers?: _amqp.Properties) => void | Promise<void>
 
-  interface ReplyEmitter {
-    queue: string
-
-    once(name: string, callback: Function): void
-
-    emit(name: string, value: any): void
+  interface ReplyEmitter extends EventEmitter {
+    readonly queue: string
+  }
 
-    clear(): void
+  interface Destroyable extends EventEmitter {
+    destroy (): void
   }
 
-  type ReplyToPropertyFormatter = (queue: string) => string
+  interface Request {
+    buffer: Buffer
+    emitter: ReplyEmitter
+    properties: _amqp.Properties
+    reply: any
+  }
 
   interface IO extends _diagnostics.Diagnosable {
-    reply(queue: string, produce: producer): Promise<void>
+    reply (queue: string, produce: Producer): Promise<void>
+
+    request<Reply = any, Request = any> (queue: string, payload: Request, encoding?: _encoding.Encoding): Promise<Reply>
 
-    request(
-      queue: string,
-      payload: any,
-      encoding?: _encoding.encoding,
-      replyToFormatter?: ReplyToPropertyFormatter)
-      : Promise<any>
+    request (queue: string, stream: Readable, encoding?: _encoding.Encoding): Promise<Readable>
 
-    request(
-      queue: string,
-      stream: Readable,
-      encoding?: _encoding.encoding,
-      replyToFormatter?: ReplyToPropertyFormatter)
-      : Promise<Readable>
+    fetch (queue: string, payload: any, encoding?: _encoding.Encoding): Promise<Readable>
 
-    consume(exchange: string, group: string, consumer: consumer): Promise<void>
+    consume<T = any> (exchange: string, group: string, consumer: Consumer<T>): Promise<void>
 
-    consume(exchange: string, consumer: consumer): Promise<void>
+    consume<T = any> (exchange: string, consumer: Consumer<T>): Promise<void>
 
-    emit(exchange: string, payload: any, encoding?: _encoding.encoding): Promise<void>
+    emit (exchange: string, payload: any, encoding?: _encoding.Encoding): Promise<void>
 
-    emit(exchange: string, payload: any, properties?: _amqp.Properties): Promise<void>
+    emit (exchange: string, payload: any, properties?: _amqp.Properties): Promise<void>
 
-    emit(exchange: string, stream: Readable, encoding?: _encoding.encoding): Promise<void>
+    emit (exchange: string, stream: Readable, encoding?: _encoding.Encoding): Promise<void>
 
-    emit(exchange: string, stream: Readable, properties?: _amqp.Properties): Promise<void>
+    emit (exchange: string, stream: Readable, properties?: _amqp.Properties): Promise<void>
 
-    seal(): Promise<void>
+    seal (): Promise<void>
 
-    close(): Promise<void>
+    close (): Promise<void>
 
-    diagnose(event: 'open', listener: (index?: number) => void): void
+    diagnose (event: 'open', listener: (index?: number) => void): void
 
-    diagnose(event: 'close', listener: (index?: number) => void): void
+    diagnose (event: 'close', listener: (index?: number) => void): void
 
-    diagnose(event: 'flow', listener: (channel: _topology.type, index?: number) => void): void
+    diagnose (event: 'flow', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'drain', listener: (channel: _topology.type, index?: number) => void): void
+    diagnose (event: 'drain', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'remove', listener: (index?: number) => void): void
+    diagnose (event: 'remove', listener: (index?: number) => void): void
 
-    diagnose(event: 'recover', listener: (channel: _topology.type, index?: number) => void): void
+    diagnose (event: 'recover', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'discard', listener: (channel: _topology.type, message: any, index?: number) => void): void
+    diagnose (event: 'discard', listener: (channel: _topology.type, message: any, index?: number) => void): void
   }
 }
 
-export type producer = comq.producer
-export type consumer = comq.consumer
+export type Producer = comq.Producer
+export type Consumer = comq.Consumer
 export type IO = comq.IO