@ccci/micro-server 1.0.151 → 1.0.153

package/dist/index.d.ts

@@ -1,30 +1,32 @@
 export type { RequestQuery, QueryOptions, ResponseType, IncludeType, CommonType } from './types/BaseControllerTypes';
-export type { AttachmentMetadataType } from './types/AttachmentMetadataTypes';
-export type { ApplicationOptionType } from './types/ApplicationOptionType';
-export { default as ApplicationServer } from './utils/ApplicationServer';
-export { default as RouterFactory } from './utils/RouterFactory';
-export { default as BaseRouter } from './utils/BaseRouter';
-export { default as BaseController } from './utils/BaseController';
-export { ConstructQuery, ResponseHelper, ErrorResponseHandler, } from './utils/BaseControllerHelper';
-export { default as IBaseModel } from './utils/IBaseModel';
-export { default as BaseModel } from './utils/BaseModel';
-export { default as ErrorHandler } from './utils/ErrorHandler';
-export { generate, verify, decode } from './utils/TokenGenerator';
-export { default as DatabaseConnector } from './utils/DatabaseConnector';
+export type { AttachmentMetadataType } from '@/types/AttachmentMetadataTypes';
+export type { ApplicationOptionType } from '@/types/ApplicationOptionType';
+export { default as ApplicationServer } from '@/utils/ApplicationServer';
+export { default as RouterFactory } from '@/utils/RouterFactory';
+export { default as BaseRouter } from '@/utils/BaseRouter';
+export { default as BaseController } from '@/utils/BaseController';
+export { ConstructQuery, ResponseHelper, ErrorResponseHandler, } from '@/utils/BaseControllerHelper';
+export { default as IBaseModel } from '@/utils/IBaseModel';
+export { default as BaseModel } from '@/utils/BaseModel';
+export { default as ErrorHandler } from '@/utils/ErrorHandler';
+export { generate, verify, decode } from '@/utils/TokenGenerator';
+export { default as DatabaseConnector } from '@/utils/DatabaseConnector';
 export { default as Logger } from '@/utils/Logger';
 export { default as WebSocketServer } from '@/utils/WebsocketServer';
-export { default as BaseSocketHandler } from './utils/BaseSocketHandler';
-export type { WebSocketData } from './types/BaseSocketType';
-export type { UploadedFileType } from './types/UploadedFileType';
-export { default as Uploader } from './utils/Uploader';
-export { default as Mailer } from './utils/Mailer';
-export { default as UploaderS3 } from './utils/uploader-s3';
+export { default as BaseSocketHandler } from '@/utils/BaseSocketHandler';
+export type { WebSocketData } from '@/types/BaseSocketType';
+export type { UploadedFileType } from '@/types/UploadedFileType';
+export { default as Uploader } from '@/utils/Uploader';
+export { default as Mailer } from '@/utils/Mailer';
+export { default as UploaderS3 } from '@/utils/uploader-s3';
 export { default as Sequelize } from 'sequelize';
-export * from './utils/Mixins';
-export type { NotificationType, NotificationOptions } from './types/NotificationTypes';
-export { default as PushNotifier } from './utils/PushNotifier';
-export { PublicAccess, PrivateAccess, endpoint } from './decorators/Endpoints';
-export { BaseConsumer } from './utils/BaseConsumer';
-export { BaseProducer } from './utils/BaseProducer';
-export { KafkaServer } from './utils/KafkaServer';
+export * from '@/utils/Mixins';
+export type { NotificationType, NotificationOptions } from '@/types/NotificationTypes';
+export { default as PushNotifier } from '@/utils/PushNotifier';
+export { PublicAccess, PrivateAccess, endpoint } from '@/decorators/Endpoints';
+export { BaseConsumer } from '@/utils/BaseConsumer';
+export { BaseProducer } from '@/utils/BaseProducer';
+export { BaseKafka } from '@/utils/BaseKafka';
+export { ServeKafka } from '@/utils/ServeKafka';
+export type { MessageHandler, MessageType, PublishType } from '@/types/BrokerType';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -298227,70 +298227,64 @@ class UploaderS3 {
   }
 }
 
-// src/utils/KafkaServer.ts
+// src/utils/ServeKafka.ts
 import fs7 from "fs";
 import path4 from "path";
 
-class KafkaServer {
-  consumersPath;
-  producersPath;
-  consumers = [];
-  producers = [];
-  kafkaBroker;
-  constructor(config) {
-    this.consumersPath = config.consumersPath ?? "consumers";
-    this.producersPath = config.producersPath ?? "producers";
-    this.kafkaBroker = config.kafkaBroker ?? [];
+class ServeKafka {
+  consumerPath;
+  producerPath;
+  config;
+  constructor(config, consumerPath = "kafka/consumers", producerPath = "kafka/producers") {
+    this.config = config;
+    this.consumerPath = consumerPath;
+    this.producerPath = producerPath;
   }
   async startConsumers() {
-    const consumerFiles = fs7.readdirSync(this.consumersPath).filter((file) => file.endsWith(".consumer.ts"));
-    for (const file of consumerFiles) {
-      const filePath = path4.resolve(this.consumersPath, file);
-      console.log("filePath :>> ", filePath);
-      const baseName = file.replace(".consumer.ts", "");
-      const clientId = `${baseName}-client`;
-      const groupId = `${baseName}-group`;
-      const ConsumerClass = (await import(filePath)).default;
-      if (!ConsumerClass) {
-        console.warn(`File ${file} does not export a default class.`);
-        continue;
-      }
-      const consumer = new ConsumerClass(clientId, this.kafkaBroker, groupId);
-      if (typeof consumer.connect === "function") {
-        await consumer.connect();
-        await consumer.handleMessages();
-        console.log(`${file} connected with clientId: ${clientId}, groupId: ${groupId}`);
-      } else {
-        console.warn(`${file} does not have a connect method.`);
+    try {
+      const consumerFiles = fs7.readdirSync(this.consumerPath).filter((file) => file.endsWith(".consumer.ts"));
+      for (const file of consumerFiles) {
+        const filePath = path4.resolve(this.consumerPath, file);
+        const baseName = file.replace(".consumer.ts", "");
+        const groupId = `${baseName}-group`;
+        try {
+          const ConsumerClass = (await import(filePath)).default;
+          if (!ConsumerClass || typeof ConsumerClass !== "function") {
+            throw new Error(`File ${file} does not export a valid class.`);
+          }
+          new ConsumerClass(this.config);
+          await ConsumerClass._.connect(groupId);
+          ConsumerClass.init();
+          console.log(`Started consumer: ${baseName}, groupId: ${groupId}`);
+        } catch (error) {
+          console.error(`Failed to start consumer from ${file}:`, error);
+        }
       }
+    } catch (error) {
+      console.error("Error reading consumer files:", error);
     }
   }
   async startProducers() {
-    const producerFiles = fs7.readdirSync(this.producersPath).filter((file) => file.endsWith(".producer.ts"));
-    for (const file of producerFiles) {
-      const filePath = path4.resolve(this.producersPath, file);
-      console.log("filePath :>> ", filePath);
-      const baseName = file.replace(".producer.ts", "");
-      const clientId = `${baseName}-client`;
-      const ProducerClass = (await import(filePath)).default;
-      if (!ProducerClass) {
-        console.warn(`File ${file} does not export a default class.`);
-        continue;
-      }
-      const producer = new ProducerClass(clientId, this.kafkaBroker);
-      if (typeof producer.connect === "function") {
-        console.log(`${file} connected with clientId: ${clientId}`);
-      } else {
-        console.warn(`${file} does not have a connect method.`);
+    try {
+      const producerFiles = fs7.readdirSync(this.producerPath).filter((file) => file.endsWith(".producer.ts"));
+      for (const file of producerFiles) {
+        const filePath = path4.resolve(this.producerPath, file);
+        const baseName = file.replace(".producer.ts", "");
+        const clientId = this.config.clientId;
+        try {
+          const ProducerClass = (await import(filePath)).default;
+          if (!ProducerClass) {
+            throw new Error(`File ${file} does not export a valid class.`);
+          }
+          new ProducerClass(this.config);
+          await ProducerClass._.connect(clientId);
+          console.log(`Started producer: ${baseName}, clientId: ${clientId}`);
+        } catch (error) {
+          console.error(`Failed to start producer from ${file}:`, error);
+        }
       }
-    }
-  }
-  async disconnectAll() {
-    for (const producer of this.producers) {
-      await producer.disconnect();
-    }
-    for (const consumer of this.consumers) {
-      await consumer.disconnect();
+    } catch (error) {
+      console.error("Error reading producer files:", error);
     }
   }
 }
@@ -298322,9 +298316,10 @@ class ApplicationServer {
         await Uploader.init(options);
       }
       if (options?.enableKafka) {
-        const kafkaServer = new KafkaServer(options);
-        await kafkaServer.startConsumers();
-        await kafkaServer.startProducers();
+        const config = { clientId: options.clientId, brokers: options.brokers ?? [] };
+        const serveKafka = new ServeKafka(config);
+        await serveKafka.startConsumers();
+        await serveKafka.startProducers();
       }
       if (options?.enableS3) {
         await UploaderS3.init(options);
@@ -298980,82 +298975,123 @@ var PrivateAccess = (constructor) => {
   };
 };
 // src/utils/BaseConsumer.ts
-var import_kafkajs = __toESM(require_kafkajs(), 1);
-
 class BaseConsumer {
+  consumer = null;
   kafka;
-  consumer;
-  groupId;
-  isRunning = false;
-  constructor(clientId, brokers, groupId) {
-    this.kafka = new import_kafkajs.Kafka({ clientId, brokers });
-    this.consumer = this.kafka.consumer({ groupId });
-    this.groupId = groupId;
-  }
-  async connect() {
+  constructor(baseKafka) {
+    this.kafka = baseKafka.getKafka();
+  }
+  async connect(groupId, config) {
+    if (this.consumer) {
+      console.log("Consumer already connected");
+      return;
+    }
+    this.consumer = this.kafka.consumer({
+      groupId,
+      ...config
+    });
     await this.consumer.connect();
-    console.log(`Consumer connected to group: ${this.groupId}`);
+    console.log("Consumer connected");
   }
-  async subscribe(topic, fromBeginning = true) {
-    await this.consumer.subscribe({ topic, fromBeginning });
-    console.log(`Subscribed to topic: ${topic}`);
+  async disconnect() {
+    if (this.consumer) {
+      await this.consumer.disconnect();
+      this.consumer = null;
+    }
   }
-  async run(eachMessageHandler) {
-    this.isRunning = true;
+  async subscribe(topic, messageHandler) {
+    if (!this.consumer) {
+      throw new Error("Consumer not connected");
+    }
+    await this.consumer.subscribe({ topic, fromBeginning: true });
     await this.consumer.run({
-      eachMessage: async (payload) => {
-        if (!this.isRunning) {
-          return;
-        }
-        try {
-          await eachMessageHandler(payload);
-        } catch (error) {
-          console.error("Error in message handler:", error);
-        }
+      eachMessage: async ({ topic: topic2, partition, message }) => {
+        const parsedMessage = {
+          headers: message.headers,
+          event: message.key?.toString() || "",
+          data: message.value ? JSON.parse(message.value.toString()) : null
+        };
+        await messageHandler(parsedMessage);
+        await this.consumer?.commitOffsets([
+          { topic: topic2, partition, offset: (Number(message.offset) + 1).toString() }
+        ]);
       }
     });
-    console.log(`Consumer is running.`);
-  }
-  async disconnect() {
-    this.isRunning = false;
-    await this.consumer.disconnect();
-    await this.consumer.stop();
-    console.log("Consumer disconnected.");
   }
 }
 // src/utils/BaseProducer.ts
-var import_kafkajs2 = __toESM(require_kafkajs(), 1);
+var import_kafkajs = __toESM(require_kafkajs(), 1);
 
 class BaseProducer {
-  static instance = null;
+  producer = null;
   kafka;
-  producer;
-  clientId;
-  constructor(clientId, brokers) {
-    this.kafka = new import_kafkajs2.Kafka({ clientId, brokers });
-    this.producer = this.kafka.producer();
-    this.clientId = clientId;
+  constructor(baseKafka) {
+    this.kafka = baseKafka.getKafka();
   }
-  static getInstance(clientId, brokers) {
-    if (!BaseProducer.instance) {
-      BaseProducer.instance = new BaseProducer(clientId, brokers);
+  async connect(config) {
+    if (this.producer) {
+      console.log("Producer already connected");
+      return;
     }
-    return BaseProducer.instance;
-  }
-  async connect() {
+    this.producer = this.kafka.producer({
+      createPartitioner: import_kafkajs.Partitioners.DefaultPartitioner,
+      ...config
+    });
     await this.producer.connect();
-    console.log(`Producer connected with clientId: ${this.clientId}`);
+    console.log("Producer connected");
   }
-  async produceMessage(topic, message) {
-    await this.producer.send({
-      topic,
-      messages: [{ value: message }]
+  async disconnect() {
+    if (this.producer) {
+      await this.producer.disconnect();
+      this.producer = null;
+    }
+  }
+  async publish(data) {
+    if (!this.producer) {
+      throw new Error("Producer not connected");
+    }
+    const result = await this.producer.send({
+      topic: data.topic,
+      messages: [
+        {
+          headers: data.headers,
+          key: data.event,
+          value: JSON.stringify(data.message)
+        }
+      ]
     });
-    console.log(`Message sent to topic: ${topic}`);
+    console.log("Publishing result:", result);
+    return result.length > 0;
   }
-  async disconnect() {
-    await this.producer.disconnect();
-    console.log("Producer disconnected.");
+}
+// src/utils/BaseKafka.ts
+var import_kafkajs2 = __toESM(require_kafkajs(), 1);
+
+class BaseKafka {
+  kafka;
+  consumerPath = "kafka/consumers";
+  producerPath = "kafka/producerPath";
+  constructor(config) {
+    this.kafka = new import_kafkajs2.Kafka({
+      ...config,
+      logLevel: config.logLevel || import_kafkajs2.logLevel.INFO
+    });
+  }
+  getKafka() {
+    return this.kafka;
+  }
+  async createTopics(topics) {
+    const admin2 = this.kafka.admin();
+    await admin2.connect();
+    const existingTopics = await admin2.listTopics();
+    for (const { topic, partitions, replicationFactor } of topics) {
+      if (!existingTopics.includes(topic)) {
+        await admin2.createTopics({
+          topics: [{ topic, numPartitions: partitions, replicationFactor }]
+        });
+      }
+    }
+    await admin2.disconnect();
   }
 }
 export {
@@ -299070,6 +299106,7 @@ export {
   WebSocketServer,
   UploaderS3,
   Uploader,
+  ServeKafka,
   lib_default as Sequelize,
   RouterFactory,
   ResponseHelper,
@@ -299078,7 +299115,6 @@ export {
   PrivateAccess,
   Mailer,
   Logger,
-  KafkaServer,
   ErrorResponseHandler,
   ErrorHandler,
   DatabaseConnector,
@@ -299087,6 +299123,7 @@ export {
   BaseRouter,
   BaseProducer,
   BaseModel,
+  BaseKafka,
   BaseController,
   BaseConsumer,
   ApplicationServer

package/dist/types/ApplicationOptionType.d.ts

@@ -13,7 +13,8 @@ export type ApplicationOptionType = {
     enableWebSocket?: boolean;
     enableFirebase?: boolean;
     enableEmail?: boolean;
-    kafkaBroker?: string[];
+    clientId?: string;
+    brokers?: string[];
     consumersPath?: string;
     producersPath?: string;
     minioHost?: string;

package/dist/types/BrokerType.d.ts

@@ -0,0 +1,13 @@
+export type PublishType = {
+    topic: string;
+    headers?: Record<string, string>;
+    event: string;
+    message: Record<string, any>;
+};
+export type MessageType = {
+    headers?: Record<string, string>;
+    event: string;
+    data: any;
+};
+export type MessageHandler = (message: MessageType) => Promise<void>;
+//# sourceMappingURL=BrokerType.d.ts.map

package/dist/utils/BaseConsumer.d.ts

@@ -1,42 +1,44 @@
-import { type EachMessagePayload } from 'kafkajs';
+import { type ConsumerConfig } from "kafkajs";
+import { BaseKafka } from "./BaseKafka";
+import type { MessageHandler } from "../types/BrokerType";
 /**
- * BaseConsumer class to handle Kafka consumer operations such as connecting,
- * subscribing to topics, consuming messages, and disconnecting.
+ * BaseConsumer class provides basic functionality for consuming messages from a Kafka topic.
+ * It manages the connection, subscription, and message handling logic for Kafka consumers.
  */
 export declare class BaseConsumer {
-    private kafka;
     private consumer;
-    private groupId;
-    private isRunning;
-    /**
-     * @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>;
+    private kafka;
     /**
-     * Subscribes the consumer to a Kafka topic.
+     * Creates an instance of BaseConsumer using a BaseKafka instance.
      *
-     * @param topic - The Kafka topic to subscribe to.
-     * @param fromBeginning - Whether to start reading from the beginning of the topic (default: true).
+     * @param {BaseKafka} baseKafka - The instance of the BaseKafka class which provides access to the Kafka client.
      */
-    subscribe(topic: string, fromBeginning?: boolean): Promise<void>;
+    constructor(baseKafka: BaseKafka);
     /**
-     * Starts consuming messages from the Kafka topic.
-     * The provided `eachMessageHandler` will be executed for each consumed message.
+     * Connects the consumer to the Kafka cluster with the specified group ID and optional consumer configuration.
+     * If the consumer is already connected, it logs a message and does nothing.
      *
-     * @param eachMessageHandler - A callback function that processes each consumed message.
+     * @param {string} groupId - The consumer group ID to join.
+     * @param {ConsumerConfig} [config] - Optional additional configuration for the consumer.
+     * @returns {Promise<void>} - A promise that resolves once the consumer is connected.
      */
-    run(eachMessageHandler: (payload: EachMessagePayload) => Promise<void>): Promise<void>;
+    connect(groupId: string, config?: ConsumerConfig): Promise<void>;
     /**
      * Disconnects the consumer from the Kafka cluster.
-     * This method gracefully shuts down the consumer connection.
+     * If the consumer is already disconnected, it logs a message and does nothing.
+     *
+     * @returns {Promise<void>} - A promise that resolves once the consumer is disconnected.
      */
     disconnect(): Promise<void>;
+    /**
+     * Subscribes the consumer to a Kafka topic and starts processing messages from the topic.
+     * The consumer runs the provided message handler for each received message.
+     *
+     * @param {string} topic - The Kafka topic to subscribe to.
+     * @param {MessageHandler} messageHandler - A function to handle the processed messages.
+     * @returns {Promise<void>} - A promise that resolves once the consumer has successfully subscribed and started processing messages.
+     * @throws {Error} - Throws an error if the consumer is not connected before subscribing.
+     */
+    subscribe(topic: string, messageHandler: MessageHandler): Promise<void>;
 }
 //# sourceMappingURL=BaseConsumer.d.ts.map

package/dist/utils/BaseKafka.d.ts

@@ -0,0 +1,37 @@
+import { Kafka, type KafkaConfig } from "kafkajs";
+/**
+ * BaseKafka class provides basic functionality for interacting with a Kafka cluster.
+ * It allows creating Kafka topics and fetching the Kafka instance for producing/consuming messages.
+ */
+export declare class BaseKafka {
+    private kafka;
+    private consumerPath;
+    private producerPath;
+    /**
+     * Creates an instance of BaseKafka with the provided Kafka configuration.
+     *
+     * @param {KafkaConfig} config - Kafka configuration object containing client settings.
+     */
+    constructor(config: KafkaConfig);
+    /**
+     * Returns the Kafka instance to be used for producing and consuming messages.
+     *
+     * @returns {Kafka} - Kafka instance.
+     */
+    getKafka(): Kafka;
+    /**
+     * Creates Kafka topics if they don't already exist.
+     *
+     * This method checks if the specified topics exist, and if not, it creates them with the given
+     * number of partitions and replication factor.
+     *
+     * @param {Array<{ topic: string; partitions: number; replicationFactor: number }>} topics - List of topics to be created with their partitions and replication factor.
+     * @returns {Promise<void>} - A promise that resolves once the topics are created (or skipped if they already exist).
+     */
+    createTopics(topics: {
+        topic: string;
+        partitions: number;
+        replicationFactor: number;
+    }[]): Promise<void>;
+}
+//# sourceMappingURL=BaseKafka.d.ts.map

package/dist/utils/BaseProducer.d.ts

@@ -1,45 +1,42 @@
+import { type ProducerConfig } from "kafkajs";
+import { BaseKafka } from "./BaseKafka";
+import type { PublishType } from "../types/BrokerType";
 /**
- * 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.
+ * BaseProducer class provides basic functionality for producing messages to a Kafka topic.
+ * It manages the connection, disconnection, and message publishing logic for Kafka producers.
  */
 export declare class BaseProducer {
-    protected static instance: BaseProducer | null;
-    private kafka;
     private producer;
-    private clientId;
+    private kafka;
     /**
-     * Constructs a new producer instance with the given client ID and Kafka brokers.
+     * Creates an instance of BaseProducer using a BaseKafka instance.
      *
-     * @param clientId - The client ID to uniquely identify the producer instance.
-     * @param brokers - An array of Kafka broker addresses to connect to.
+     * @param {BaseKafka} baseKafka - The instance of the BaseKafka class which provides access to the Kafka client.
      */
-    constructor(clientId: string, brokers: string[]);
+    constructor(baseKafka: BaseKafka);
     /**
-     * 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.
+     * Connects the producer to the Kafka cluster with the specified optional configuration.
+     * If the producer is already connected, it logs a message and does nothing.
      *
-     * @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.
+     * @param {ProducerConfig} [config] - Optional additional configuration for the producer.
+     * @returns {Promise<void>} - A promise that resolves once the producer is connected.
      */
-    static getInstance(clientId: string, brokers: string[]): BaseProducer;
+    connect(config?: ProducerConfig): Promise<void>;
     /**
-     * Connects the producer to the Kafka cluster.
-     * This method establishes the connection between the producer and the Kafka brokers.
-     */
-    connect(): Promise<void>;
-    /**
-     * Sends a message to a Kafka topic.
+     * Disconnects the producer from the Kafka cluster.
+     * If the producer is already disconnected, it logs a message and does nothing.
      *
-     * @param topic - The Kafka topic to which the message will be sent.
-     * @param message - The message content to send to the topic.
+     * @returns {Promise<void>} - A promise that resolves once the producer is disconnected.
      */
-    produceMessage(topic: string, message: string): Promise<void>;
+    disconnect(): Promise<void>;
     /**
-     * Disconnects the producer from the Kafka cluster.
-     * This method gracefully shuts down the producer connection.
+     * Publishes a message to a Kafka topic.
+     * If the producer is not connected, it throws an error.
+     *
+     * @param {PublishType} data - The data to publish, including the topic, event, headers, and message content.
+     * @returns {Promise<boolean>} - A promise that resolves to true if the message was successfully sent, false otherwise.
+     * @throws {Error} - Throws an error if the producer is not connected.
      */
-    disconnect(): Promise<void>;
+    publish(data: PublishType): Promise<boolean>;
 }
 //# sourceMappingURL=BaseProducer.d.ts.map

package/dist/utils/ServeKafka.d.ts

@@ -0,0 +1,16 @@
+import type { KafkaConfig } from "kafkajs";
+export declare class ServeKafka {
+    private consumerPath;
+    private producerPath;
+    private config;
+    constructor(config: KafkaConfig, consumerPath?: string, producerPath?: string);
+    /**
+     * Starts all consumers by dynamically importing and initializing consumer classes.
+     */
+    startConsumers(): Promise<void>;
+    /**
+     * Starts all producers by dynamically importing and initializing producer classes.
+     */
+    startProducers(): Promise<void>;
+}
+//# sourceMappingURL=ServeKafka.d.ts.map

package/package.json

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