comq 0.8.0 → 0.10.0

package/types/io.d.ts

@@ -1,3 +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'
@@ -5,59 +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, stream: Readable, encoding?: _encoding.Encoding): Promise<Readable>
+
+    fetch (queue: string, payload: any, encoding?: _encoding.Encoding): Promise<Readable>
+
+    consume<T = any> (exchange: string, group: string, consumer: Consumer<T>): Promise<void>
 
-    request(
-      queue: string,
-      payload: any,
-      encoding?: _encoding.encoding,
-      replyToFormatter?: ReplyToPropertyFormatter)
-      : Promise<any>
+    consume<T = any> (exchange: string, consumer: Consumer<T>): Promise<void>
 
-    consume(exchange: string, group: string, consumer: consumer): Promise<void>
+    emit (exchange: string, payload: any, encoding?: _encoding.Encoding): Promise<void>
 
-    consume(exchange: string, consumer: consumer): Promise<void>
+    emit (exchange: string, payload: any, properties?: _amqp.Properties): Promise<void>
 
-    emit(exchange: string, payload: any, encoding?: _encoding.encoding): Promise<void>
+    emit (exchange: string, stream: Readable, encoding?: _encoding.Encoding): Promise<void>
 
-    emit(exchange: string, payload: any, 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)
+    diagnose (event: 'open', listener: (index?: number) => void): void
 
-    diagnose(event: 'close', listener: (index?: number) => void)
+    diagnose (event: 'close', listener: (index?: number) => void): void
 
-    diagnose(event: 'flow', listener: (channel: _topology.type, index?: number) => void)
+    diagnose (event: 'flow', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'drain', listener: (channel: _topology.type, index?: number) => void)
+    diagnose (event: 'drain', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'remove', listener: (index?: number) => void)
+    diagnose (event: 'remove', listener: (index?: number) => void): void
 
-    diagnose(event: 'recover', listener: (channel: _topology.type, index?: number) => void)
+    diagnose (event: 'recover', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'discard', listener: (channel: _topology.type, message: any, index?: number) => 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