@ccci/micro-server 1.0.148 → 1.0.149

package/dist/types/ApplicationOptionType.d.ts

@@ -8,12 +8,14 @@ export type ApplicationOptionType = {
     websocketDir?: string;
     enableRedis?: boolean;
     enableMinio?: boolean;
+    enableKafka?: boolean;
     enableS3?: boolean;
     enableWebSocket?: boolean;
     enableFirebase?: boolean;
     enableEmail?: boolean;
-    kafkaProducer?: boolean;
-    kafkaConsumer?: boolean;
+    kafkaBroker?: string[];
+    consumersPath?: string;
+    producersPath?: string;
     minioHost?: string;
     minioPort?: number;
     minioAccessKey?: string;

package/dist/utils/BaseConsumer.d.ts

@@ -1,12 +1,41 @@
-import { EachMessagePayload } from 'kafkajs';
+import { type EachMessagePayload } from 'kafkajs';
+/**
+ * BaseConsumer class to handle Kafka consumer operations such as connecting,
+ * subscribing to topics, consuming messages, and disconnecting.
+ */
 export declare class BaseConsumer {
     private kafka;
     private consumer;
     private groupId;
+    /**
+     * @param clientId - The client ID used to identify the consumer instance.
+     * @param brokers - An array of Kafka brokers to connect to.
+     * @param groupId - The consumer group ID to which this consumer belongs.
+     */
     constructor(clientId: string, brokers: string[], groupId: string);
+    /**
+     * Connects the consumer to the Kafka cluster.
+     * This method establishes the connection between the consumer and the Kafka brokers.
+     */
     connect(): Promise<void>;
+    /**
+     * Subscribes the consumer to a Kafka topic.
+     *
+     * @param topic - The Kafka topic to subscribe to.
+     * @param fromBeginning - Whether to start reading from the beginning of the topic (default: true).
+     */
     subscribe(topic: string, fromBeginning?: boolean): Promise<void>;
+    /**
+     * Starts consuming messages from the Kafka topic.
+     * The provided `eachMessageHandler` will be executed for each consumed message.
+     *
+     * @param eachMessageHandler - A callback function that processes each consumed message.
+     */
     run(eachMessageHandler: (payload: EachMessagePayload) => Promise<void>): Promise<void>;
+    /**
+     * Disconnects the consumer from the Kafka cluster.
+     * This method gracefully shuts down the consumer connection.
+     */
     disconnect(): Promise<void>;
 }
 //# sourceMappingURL=BaseConsumer.d.ts.map

package/dist/utils/BaseProducer.d.ts

@@ -1,12 +1,45 @@
+/**
+ * BaseProducer class to handle Kafka producer operations such as connecting,
+ * producing messages, and disconnecting.
+ * This class uses the Singleton pattern to ensure only one instance of the producer exists.
+ */
 export declare class BaseProducer {
+    protected static instance: BaseProducer | null;
     private kafka;
     private producer;
+    private clientId;
+    /**
+     * Constructs a new producer instance with the given client ID and Kafka brokers.
+     *
+     * @param clientId - The client ID to uniquely identify the producer instance.
+     * @param brokers - An array of Kafka broker addresses to connect to.
+     */
     constructor(clientId: string, brokers: string[]);
+    /**
+     * Public method to get the single instance of BaseProducer (Singleton pattern).
+     * If no instance exists, it creates a new one. If an instance already exists, it returns the existing one.
+     *
+     * @param clientId - The client ID used to identify the producer instance.
+     * @param brokers - An array of Kafka brokers to connect to.
+     * @returns The single instance of the BaseProducer.
+     */
+    static getInstance(clientId: string, brokers: string[]): BaseProducer;
+    /**
+     * Connects the producer to the Kafka cluster.
+     * This method establishes the connection between the producer and the Kafka brokers.
+     */
     connect(): Promise<void>;
-    sendMessage(topic: string, messages: {
-        key: string;
-        value: string;
-    }[]): Promise<void>;
+    /**
+     * Sends a message to a Kafka topic.
+     *
+     * @param topic - The Kafka topic to which the message will be sent.
+     * @param message - The message content to send to the topic.
+     */
+    produceMessage(topic: string, message: string): Promise<void>;
+    /**
+     * Disconnects the producer from the Kafka cluster.
+     * This method gracefully shuts down the producer connection.
+     */
     disconnect(): Promise<void>;
 }
 //# sourceMappingURL=BaseProducer.d.ts.map

package/dist/utils/KafkaServer.d.ts

@@ -0,0 +1,34 @@
+import { ApplicationOptionType } from '@/types/ApplicationOptionType';
+/**
+ * KafkaServer class to manage Kafka consumers and producers.
+ * It automatically loads and starts consumers and producers from specified directories.
+ */
+export declare class KafkaServer {
+    private consumersPath;
+    private producersPath;
+    private consumers;
+    private producers;
+    private kafkaBroker;
+    /**
+     * @param config - Configuration for Kafka.
+     */
+    constructor(config: ApplicationOptionType);
+    /**
+     * Starts all consumers automatically by dynamically importing and instantiating consumer classes
+     * from the specified consumers directory.
+     * Each consumer is connected with a clientId and groupId generated from the file name.
+     */
+    startConsumers(): Promise<void>;
+    /**
+     * Starts all producers automatically by dynamically importing and instantiating producer classes
+     * from the specified producers directory.
+     * Each producer is connected with a clientId generated from the file name.
+     */
+    startProducers(): Promise<void>;
+    /**
+     * Disconnects all consumers and producers.
+     * This method ensures that all active consumers and producers are disconnected.
+     */
+    disconnectAll(): Promise<void>;
+}
+//# sourceMappingURL=KafkaServer.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccci/micro-server",
-  "version": "1.0.148",
+  "version": "1.0.149",
   "module": "index.ts",
   "type": "module",
   "main": "dist/index.js",