KafkaJS v2

CODEOWNERS

@@ -23,3 +23,5 @@
 
 /definitions/npm/sequelize_*/**/* @jedwards1211
 
+/definitions/npm/kafkajs_*/**/* @edoardo-bluframe
+/definitions/npm/react-helmet_v6*/**/* @edoardo-bluframe

definitions/npm/kafkajs_v2.x.x/flow_v0.83.x-/kafkajs_v2.x.x.js

@@ -0,0 +1,143 @@
+// @flow
+
+declare module "kafkajs" {
+  declare type KafkaOptions = {|
+    brokers: string[],
+    clientId?: string,
+    connectionTimeout?: number,
+    logLevel?: number,
+    retry?: {|
+      initialRetryTime?: number,
+      maxRetryTime?: number,
+      retries?: number
+    |},
+    sasl?: {|
+      mechanism: string,
+      password: string,
+      username: string
+    |},
+    +ssl?:
+      | boolean
+      | {|
+          ca?: string | string[],
+          cert?: string,
+          key?: string,
+          passphrase?: string,
+          pfx?: string | Buffer,
+          rejectUnauthorized?: boolean,
+          secureProtocol?: string,
+          servername?: string
+        |}
+  |}
+
+  declare type ConsumerOptions = {|
+    +groupId: string,
+    +sessionTimeout?: number,
+    +heartbeatInterval?: number,
+    +maxBytesPerPartition?: number,
+    +minBytes?: number,
+    +maxBytes?: number,
+    +maxWaitTimeInMs?: number,
+    +rebalanceTimeout?: number
+  |}
+
+  declare type Message = {|
+    +key?: string,
+    +value: string,
+    +timestamp?: string
+  |}
+
+  declare type ConsumerEachMessageOptions = {|
+    +message: Message,
+    +partition: number,
+    +topic: string
+  |}
+
+  declare export type ConsumerRunOptions = {|
+    +eachMessage: (options: ConsumerEachMessageOptions) => Promise<void>
+  |}
+
+  declare export type ConsumerSubscribeOptions = {|
+    +fromBeginning?: boolean,
+    +topic: string
+  |}
+
+  declare export interface ConsumerInterface {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    run(options: ConsumerRunOptions): Promise<void>;
+    subscribe(options: ConsumerSubscribeOptions): Promise<void>;
+  }
+
+  declare export class Consumer implements ConsumerInterface {
+    constructor(options: ConsumerOptions): this;
+
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    run: (options: ConsumerRunOptions) => Promise<void>;
+    subscribe: (options: ConsumerSubscribeOptions) => Promise<void>;
+  }
+
+  declare type ProducerOptions = {|
+    +allowAutoTopicCreation?: boolean,
+    +createPartitioner?: Partitioner,
+    +idempotent?: boolean,
+    +maxQueueSize?: number,
+    +retry?: {|
+      retries?: number
+    |}
+  |}
+
+  declare export type ProducerSendOptions = {|
+    +messages: Message[],
+    +topic: string
+  |}
+
+  declare export interface ProducerInterface {
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    send(options: ProducerSendOptions): Promise<void>;
+  }
+
+  declare export class Producer implements ProducerInterface {
+    constructor(options: ProducerOptions): this;
+
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    send: (options: ProducerSendOptions) => Promise<void>;
+  }
+
+  declare export class Kafka {
+    constructor(options: KafkaOptions): this;
+
+    consumer: (options: ConsumerOptions) => Consumer;
+    producer: (options: ProducerOptions) => Producer;
+  }
+
+  declare export type Partitioner = (args: {|
+    +topic: string,
+    +partitionMetadata: Array<{|
+      +partitionId: number,
+      +leader: number,
+      +replicas: number[],
+      +isr: number[],
+      +isPreferredLeader: boolean,
+      +isUnderReplicated: boolean
+    |}>,
+    +message: Message
+  |}) => number
+
+  declare export var Partitioners: {|
+    +DefaultPartitioner: Partitioner,
+    +RoundRobinPartitioner: Partitioner,
+    +RandomPartitioner: Partitioner
+  |}
+
+  declare export var logLevel: {|
+    +NOTHING: number,
+    +ERROR: number,
+    +WARN: number,
+    +INFO: number,
+    +DEBUG: number
+  |}
+}

definitions/npm/kafkajs_v2.x.x/test_kafkajs_v2.x.x.js

@@ -0,0 +1,87 @@
+// @flow
+import { describe, it } from "flow-typed-test";
+import { Kafka, Producer, Consumer, Partitioners, logLevel } from "kafkajs";
+
+describe("kafkajs", () => {
+  it("creates Kafka instance", () => {
+    const kafka = new Kafka({
+      clientId: "my-app",
+      brokers: ["kafka1:9092", "kafka2:9092"],
+    });
+  });
+
+  it("creates Consumer instance", () => {
+    const kafka = new Kafka({
+      clientId: "my-app",
+      brokers: ["kafka1:9092", "kafka2:9092"],
+    });
+
+    const consumer: Consumer = kafka.consumer({ groupId: "test-group" });
+  });
+
+  it("creates Producer instance", () => {
+    const kafka = new Kafka({
+      clientId: "my-app",
+      brokers: ["kafka1:9092", "kafka2:9092"],
+    });
+
+    const producer: Producer = kafka.producer();
+  });
+
+  it("uses Consumer methods", async () => {
+    const kafka = new Kafka({
+      clientId: "my-app",
+      brokers: ["kafka1:9092", "kafka2:9092"],
+    });
+    const consumer: Consumer = kafka.consumer({ groupId: "test-group" });
+
+    await consumer.connect();
+    await consumer.subscribe({ topic: "test-topic", fromBeginning: true });
+
+    await consumer.run({
+      eachMessage: async ({ topic, partition, message }) => {
+        console.log(`Received message: ${message.value}`);
+      },
+    });
+
+    await consumer.disconnect();
+  });
+
+  it("uses Producer methods", async () => {
+    const kafka = new Kafka({
+      clientId: "my-app",
+      brokers: ["kafka1:9092", "kafka2:9092"],
+    });
+    const producer: Producer = kafka.producer();
+
+    const message: Message = {
+      key: "key",
+      value: "value",
+      timestamp: "timestamp",
+    };
+
+    await producer.connect();
+    await producer.send({
+      topic: "test-topic",
+      messages: [message],
+    });
+
+    await producer.disconnect();
+  });
+
+  it("uses partitioners", () => {
+    const defaultPartitioner: Partitioner = Partitioners.DefaultPartitioner;
+    const roundRobinPartitioner: Partitioner = Partitioners.RoundRobinPartitioner;
+    const randomPartitioner: Partitioner = Partitioners.RandomPartitioner;
+  });
+
+  it("uses log levels", () => {
+    const logLevels = [
+      logLevel.NOTHING,
+      logLevel.ERROR,
+      logLevel.WARN,
+      logLevel.INFO,
+      logLevel.DEBUG,
+    ];
+  });
+});