@hastehaul/common 1.0.13 → 1.0.15

package/build/connections-wrappers/nats-wrapper.d.ts

@@ -1,8 +1,27 @@
 import { ConnectionOptions, NatsConnection } from 'nats';
+/**
+ * A wrapper class for the NATS client to manage connections and provide a centralized client instance.
+ */
 declare class NatsWrapper {
     private _client?;
+    /**
+     * Get the NATS client instance.
+     *
+     * @throws {Error} - Throws an error if the NATS client is accessed before connecting.
+     * @returns {NatsConnection} - The NATS client instance.
+     */
     get client(): NatsConnection;
+    /**
+     * Connect to the NATS server using the specified connection options.
+     *
+     * The client instance will be stored in the `_client` property for later access.
+     *
+     * @param {ConnectionOptions} opts - The options for connecting to the NATS server.
+     */
     connect(opts?: ConnectionOptions): Promise<void>;
 }
+/**
+ * Singleton instance of the NatsWrapper class to provide a centralized NATS client connection.
+ */
 export declare const natsWrapper: NatsWrapper;
 export {};

package/build/connections-wrappers/nats-wrapper.js

@@ -11,12 +11,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.natsWrapper = void 0;
 const nats_1 = require("nats");
+/**
+ * A wrapper class for the NATS client to manage connections and provide a centralized client instance.
+ */
 class NatsWrapper {
+    /**
+     * Get the NATS client instance.
+     *
+     * @throws {Error} - Throws an error if the NATS client is accessed before connecting.
+     * @returns {NatsConnection} - The NATS client instance.
+     */
     get client() {
         if (!this._client)
             throw new Error("Cannot access NATS CLIENT before connecting");
         return this._client;
     }
+    /**
+     * Connect to the NATS server using the specified connection options.
+     *
+     * The client instance will be stored in the `_client` property for later access.
+     *
+     * @param {ConnectionOptions} opts - The options for connecting to the NATS server.
+     */
     connect(opts) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -28,4 +44,7 @@ class NatsWrapper {
         });
     }
 }
+/**
+ * Singleton instance of the NatsWrapper class to provide a centralized NATS client connection.
+ */
 exports.natsWrapper = new NatsWrapper();

package/build/errors/bad-request-error.d.ts

@@ -1,10 +1,32 @@
 import { StatusCodes } from "../utils/enums";
 import { CustomError } from "./custom-error";
+/**
+ * Class representing a "Bad Request" error.
+ *
+ * This error class extends the `CustomError` abstract class and provides specific error details for a "Bad Request" scenario.
+ * Instances of this class are thrown when the client's request is malformed or contains invalid data.
+ */
 export declare class BadRequestError extends CustomError {
     message: string;
+    /**
+     * The HTTP status code associated with the "Bad Request" error (400).
+     */
     statusCode: StatusCodes;
+    /**
+     * Constructs a new instance of the "Bad Request" error.
+     *
+     * @param {string} message - The error message providing details about the "Bad Request" error.
+     */
     constructor(message: string);
-    serializeErrors(): {
+    /**
+     * Method to serialize the "Bad Request" error details into an array of error objects.
+     *
+     * This method returns an array containing a single error object with the error message provided during construction.
+     * The array format is consistent with the `CustomError` class's expectation for error serialization.
+     *
+     * @returns {Array<{ message: string }>} - An array containing a single error object with the error message.
+     */
+    serializeErrors(): Array<{
         message: string;
-    }[];
+    }>;
 }

package/build/errors/bad-request-error.js

@@ -3,13 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BadRequestError = void 0;
 const enums_1 = require("../utils/enums");
 const custom_error_1 = require("./custom-error");
+/**
+ * Class representing a "Bad Request" error.
+ *
+ * This error class extends the `CustomError` abstract class and provides specific error details for a "Bad Request" scenario.
+ * Instances of this class are thrown when the client's request is malformed or contains invalid data.
+ */
 class BadRequestError extends custom_error_1.CustomError {
+    /**
+     * Constructs a new instance of the "Bad Request" error.
+     *
+     * @param {string} message - The error message providing details about the "Bad Request" error.
+     */
     constructor(message) {
         super(message);
         this.message = message;
+        /**
+         * The HTTP status code associated with the "Bad Request" error (400).
+         */
         this.statusCode = enums_1.StatusCodes.BAD_REQUEST;
         Object.setPrototypeOf(this, BadRequestError.prototype);
     }
+    /**
+     * Method to serialize the "Bad Request" error details into an array of error objects.
+     *
+     * This method returns an array containing a single error object with the error message provided during construction.
+     * The array format is consistent with the `CustomError` class's expectation for error serialization.
+     *
+     * @returns {Array<{ message: string }>} - An array containing a single error object with the error message.
+     */
     serializeErrors() {
         return [{ message: this.message }];
     }

package/build/errors/custom-error.d.ts

@@ -1,6 +1,30 @@
+/**
+ * Abstract class representing a custom error.
+ *
+ * This abstract class extends the base Error class and serves as a foundation for creating specific error classes for different types of errors.
+ * Classes that extend this abstract class must implement the `statusCode` property and the `serializeErrors` method.
+ */
 export declare abstract class CustomError extends Error {
+    /**
+     * The HTTP status code associated with the error.
+     *
+     * Classes extending `CustomError` must provide a value for this property.
+     */
     abstract statusCode: number;
+    /**
+     * Constructs a new instance of the custom error.
+     *
+     * @param {string} message - The error message.
+     */
     constructor(message?: string);
+    /**
+     * Abstract method that must be implemented in classes extending `CustomError`.
+     *
+     * This method returns an array of error objects containing error messages and optional field information.
+     * The specific implementation of this method depends on the type of custom error and how errors are serialized for responses.
+     *
+     * @returns {Array<{ message: string; field?: string }>} - An array of error objects containing error messages and optional field information.
+     */
     abstract serializeErrors(): {
         message: string;
         field?: string;

package/build/errors/custom-error.js

@@ -1,7 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomError = void 0;
+/**
+ * Abstract class representing a custom error.
+ *
+ * This abstract class extends the base Error class and serves as a foundation for creating specific error classes for different types of errors.
+ * Classes that extend this abstract class must implement the `statusCode` property and the `serializeErrors` method.
+ */
 class CustomError extends Error {
+    /**
+     * Constructs a new instance of the custom error.
+     *
+     * @param {string} message - The error message.
+     */
     constructor(message) {
         super(message);
         Object.setPrototypeOf(this, CustomError.prototype);

package/build/errors/database-error.d.ts

@@ -1,9 +1,31 @@
 import { StatusCodes } from '../utils/enums';
 import { CustomError } from './custom-error';
+/**
+ * Class representing a database-related error.
+ *
+ * This error class extends the `CustomError` abstract class and provides specific error details for database-related errors.
+ * Instances of this class are thrown when there are errors related to connecting to or interacting with the database.
+ */
 export declare class DatabaseError extends CustomError {
+    /**
+     * The HTTP status code associated with the database-related error (500 - Internal Server Error).
+     */
     statusCode: StatusCodes;
+    /**
+     * Constructs a new instance of the database-related error.
+     *
+     * @param {string} message - The error message providing details about the database-related error.
+     */
     constructor(message?: string);
-    serializeErrors: () => {
+    /**
+     * Method to serialize the database-related error details into an array of error objects.
+     *
+     * This method returns an array containing a single error object with the error message provided during construction.
+     * The array format is consistent with the `CustomError` class's expectation for error serialization.
+     *
+     * @returns {Array<{ message: string }>} - An array containing a single error object with the error message.
+     */
+    serializeErrors: () => Array<{
         message: string;
-    }[];
+    }>;
 }

package/build/errors/database-error.js

@@ -3,10 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseError = void 0;
 const enums_1 = require("../utils/enums");
 const custom_error_1 = require("./custom-error");
+/**
+ * Class representing a database-related error.
+ *
+ * This error class extends the `CustomError` abstract class and provides specific error details for database-related errors.
+ * Instances of this class are thrown when there are errors related to connecting to or interacting with the database.
+ */
 class DatabaseError extends custom_error_1.CustomError {
+    /**
+     * Constructs a new instance of the database-related error.
+     *
+     * @param {string} message - The error message providing details about the database-related error.
+     */
     constructor(message = "Error connecting to database") {
         super(message);
-        this.statusCode = enums_1.StatusCodes.INTERNALE_SERVER_ERROR;
+        /**
+         * The HTTP status code associated with the database-related error (500 - Internal Server Error).
+         */
+        this.statusCode = enums_1.StatusCodes.INTERNAL_SERVER_ERROR;
+        /**
+         * Method to serialize the database-related error details into an array of error objects.
+         *
+         * This method returns an array containing a single error object with the error message provided during construction.
+         * The array format is consistent with the `CustomError` class's expectation for error serialization.
+         *
+         * @returns {Array<{ message: string }>} - An array containing a single error object with the error message.
+         */
         this.serializeErrors = () => [{ message: this.message }];
         Object.setPrototypeOf(this, DatabaseError.prototype);
     }

package/build/errors/index.d.ts

@@ -1,5 +1,30 @@
+/**
+ * Re-exports the "BadRequestError" class from the "bad-request-error" file.
+ *
+ * The "BadRequestError" class represents a specific "Bad Request" error and is used to handle client requests with invalid or malformed data.
+ */
 export * from "./bad-request-error";
+/**
+ * Re-exports the "CustomError" abstract class from the "custom-error" file.
+ *
+ * The "CustomError" abstract class serves as the foundation for creating specific error classes for different types of errors.
+ */
 export * from "./custom-error";
+/**
+ * Re-exports the "DatabaseError" class from the "database-error" file.
+ *
+ * The "DatabaseError" class represents a specific error related to database operations or connectivity issues.
+ */
 export * from "./database-error";
+/**
+ * Re-exports the "NotFoundError" class from the "not-found-error" file.
+ *
+ * The "NotFoundError" class represents a specific "Not Found" error and is used when a requested resource is not found.
+ */
 export * from "./not-found-error";
+/**
+ * Re-exports the "SystemError" class from the "system-error" file.
+ *
+ * The "SystemError" class represents a specific "System Error" that can occur due to unexpected issues in the system.
+ */
 export * from "./system-error";

package/build/errors/index.js

@@ -1,4 +1,5 @@
 "use strict";
+// Import and re-export custom error classes for easier access.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -14,8 +15,33 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Re-exports the "BadRequestError" class from the "bad-request-error" file.
+ *
+ * The "BadRequestError" class represents a specific "Bad Request" error and is used to handle client requests with invalid or malformed data.
+ */
 __exportStar(require("./bad-request-error"), exports);
+/**
+ * Re-exports the "CustomError" abstract class from the "custom-error" file.
+ *
+ * The "CustomError" abstract class serves as the foundation for creating specific error classes for different types of errors.
+ */
 __exportStar(require("./custom-error"), exports);
+/**
+ * Re-exports the "DatabaseError" class from the "database-error" file.
+ *
+ * The "DatabaseError" class represents a specific error related to database operations or connectivity issues.
+ */
 __exportStar(require("./database-error"), exports);
+/**
+ * Re-exports the "NotFoundError" class from the "not-found-error" file.
+ *
+ * The "NotFoundError" class represents a specific "Not Found" error and is used when a requested resource is not found.
+ */
 __exportStar(require("./not-found-error"), exports);
+/**
+ * Re-exports the "SystemError" class from the "system-error" file.
+ *
+ * The "SystemError" class represents a specific "System Error" that can occur due to unexpected issues in the system.
+ */
 __exportStar(require("./system-error"), exports);

package/build/errors/not-found-error.d.ts

@@ -1,9 +1,31 @@
 import { StatusCodes } from "../utils/enums";
 import { CustomError } from "./custom-error";
+/**
+ * Class representing a "Not Found" error.
+ *
+ * This error class extends the `CustomError` abstract class and provides specific error details for a "Not Found" scenario.
+ * Instances of this class are thrown when a requested resource is not found.
+ */
 export declare class NotFoundError extends CustomError {
+    /**
+     * The HTTP status code associated with the "Not Found" error (404).
+     */
     statusCode: StatusCodes;
+    /**
+     * Constructs a new instance of the "Not Found" error.
+     *
+     * @param {string} message - The error message providing details about the "Not Found" error.
+     */
     constructor(message: string);
-    serializeErrors: () => {
+    /**
+     * Method to serialize the "Not Found" error details into an array of error objects.
+     *
+     * This method returns an array containing a single error object with the error message provided during construction.
+     * The array format is consistent with the `CustomError` class's expectation for error serialization.
+     *
+     * @returns {Array<{ message: string }>} - An array containing a single error object with the error message.
+     */
+    serializeErrors: () => Array<{
         message: string;
-    }[];
+    }>;
 }

package/build/errors/not-found-error.js

@@ -3,10 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotFoundError = void 0;
 const enums_1 = require("../utils/enums");
 const custom_error_1 = require("./custom-error");
+/**
+ * Class representing a "Not Found" error.
+ *
+ * This error class extends the `CustomError` abstract class and provides specific error details for a "Not Found" scenario.
+ * Instances of this class are thrown when a requested resource is not found.
+ */
 class NotFoundError extends custom_error_1.CustomError {
+    /**
+     * Constructs a new instance of the "Not Found" error.
+     *
+     * @param {string} message - The error message providing details about the "Not Found" error.
+     */
     constructor(message) {
         super(message);
+        /**
+         * The HTTP status code associated with the "Not Found" error (404).
+         */
         this.statusCode = enums_1.StatusCodes.NOT_FOUND;
+        /**
+         * Method to serialize the "Not Found" error details into an array of error objects.
+         *
+         * This method returns an array containing a single error object with the error message provided during construction.
+         * The array format is consistent with the `CustomError` class's expectation for error serialization.
+         *
+         * @returns {Array<{ message: string }>} - An array containing a single error object with the error message.
+         */
         this.serializeErrors = () => [{ message: this.message }];
         Object.setPrototypeOf(this, NotFoundError.prototype);
     }

package/build/errors/system-error.d.ts

@@ -1,9 +1,32 @@
 import { StatusCodes } from "../utils/enums";
 import { CustomError } from "./custom-error";
+/**
+ * Class representing a "System Error".
+ *
+ * This error class extends the `CustomError` abstract class and provides specific error details for a "System Error".
+ * Instances of this class are thrown when there are unexpected issues in the system.
+ */
 export declare class SystemError extends CustomError {
+    /**
+     * The HTTP status code associated with the "System Error" (500 - Internal Server Error).
+     */
     statusCode: StatusCodes;
+    /**
+     * Constructs a new instance of the "System Error".
+     *
+     * @param {string} message - The error message providing details about the "System Error".
+     *                           If no message is provided, the default message "Something went wrong" is used.
+     */
     constructor(message?: string);
-    serializeErrors: () => {
+    /**
+     * Method to serialize the "System Error" details into an array of error objects.
+     *
+     * This method returns an array containing a single error object with the error message provided during construction.
+     * The array format is consistent with the `CustomError` class's expectation for error serialization.
+     *
+     * @returns {Array<{ message: string }>} - An array containing a single error object with the error message.
+     */
+    serializeErrors: () => Array<{
         message: string;
-    }[];
+    }>;
 }

package/build/errors/system-error.js

@@ -3,10 +3,33 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SystemError = void 0;
 const enums_1 = require("../utils/enums");
 const custom_error_1 = require("./custom-error");
+/**
+ * Class representing a "System Error".
+ *
+ * This error class extends the `CustomError` abstract class and provides specific error details for a "System Error".
+ * Instances of this class are thrown when there are unexpected issues in the system.
+ */
 class SystemError extends custom_error_1.CustomError {
+    /**
+     * Constructs a new instance of the "System Error".
+     *
+     * @param {string} message - The error message providing details about the "System Error".
+     *                           If no message is provided, the default message "Something went wrong" is used.
+     */
     constructor(message = "Something went wrong") {
         super(message);
-        this.statusCode = enums_1.StatusCodes.INTERNALE_SERVER_ERROR;
+        /**
+         * The HTTP status code associated with the "System Error" (500 - Internal Server Error).
+         */
+        this.statusCode = enums_1.StatusCodes.INTERNAL_SERVER_ERROR;
+        /**
+         * Method to serialize the "System Error" details into an array of error objects.
+         *
+         * This method returns an array containing a single error object with the error message provided during construction.
+         * The array format is consistent with the `CustomError` class's expectation for error serialization.
+         *
+         * @returns {Array<{ message: string }>} - An array containing a single error object with the error message.
+         */
         this.serializeErrors = () => [{ message: this.message }];
         Object.setPrototypeOf(this, SystemError.prototype);
     }

package/build/events/base/base-consumer.d.ts

@@ -1,26 +1,83 @@
 import { NatsConnection, ConsumerConfig, JsMsg } from "nats";
 import { DurableName, Subjects, Streams } from "../common/enums";
 import { MainSubjects, ValidateSubjectFormat } from "../common/enums/subjects/main-subjects";
+/**
+ * Interface representing an event published to NATS.
+ */
 interface Event {
     subject: ValidateSubjectFormat<Subjects, MainSubjects>;
     durableName?: DurableName;
     stream: Streams;
     data: any;
 }
+/**
+ * Abstract class representing a NATS consumer for processing messages from a JetStream stream.
+ *
+ * @typeparam {T} - The type of event to be consumed, extending the Event interface.
+ */
 export declare abstract class NatsConsumer<T extends Event> {
     protected client: NatsConnection;
     protected jc: import("nats").Codec<T>;
     protected sc: import("nats").Codec<string>;
+    /**
+     * The name of the JetStream stream to consume messages from.
+    */
     abstract stream: T["stream"];
+    /**
+     * The subject to filter messages for this consumer.
+    */
     abstract subject: T["subject"];
+    /**
+    * The name of the durable consumer, if applicable.
+    */
     abstract durableName: T["durableName"];
+    /**
+     * The maximum number of messages that can be processed concurrently.
+    */
     abstract maxConcurrentMessages: number;
     protected ackWait: number;
+    /**
+     * Creates an instance of NatsConsumer.
+     *
+     * @param {NatsConnection} client - The NATS connection instance.
+     */
     constructor(client: NatsConnection);
+    /**
+     * Provides the consumer options for JetStream.
+     *
+     * @returns {Partial<ConsumerConfig>} - The partial consumer options.
+     */
     get consumerOptions(): Partial<ConsumerConfig>;
+    /**
+     * Consume messages from the JetStream stream and process them concurrently.
+     *
+     * Messages are processed asynchronously up to the maximum concurrent limit.
+     */
     consume(): Promise<void>;
+    /**
+      * Abstract method to process a single message received from the stream.
+      *
+      * This method should be implemented by subclasses to define custom logic for processing messages.
+      *
+      * @param {T["data"]} data - The data representing the message payload.
+      * @param {JsMsg} msg - The message object received from the stream.
+      * @returns {Promise<void>} - A Promise that resolves once the message processing is completed successfully.
+    */
     abstract processMessage(data: T["data"], msg: JsMsg): Promise<void>;
+    /**
+     * Closes the NATS connection when message processing is finished.
+     *
+     * @protected
+     * @returns {Promise<void>} - A Promise that resolves once the NATS connection is drained and closed.
+   */
     protected close(): Promise<void>;
+    /**
+     * Utility method to parse the message data using the appropriate codec (JSON or string).
+     *
+     * @protected
+     * @param {JsMsg} msg - The message object received from the stream.
+     * @returns {T["data"]} - The parsed message data.
+   */
     protected parsedMessage: (msg: JsMsg) => string | T;
 }
 export {};

package/build/events/base/base-consumer.js

@@ -18,14 +18,36 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NatsConsumer = void 0;
 const nats_1 = require("nats");
+/**
+ * Abstract class representing a NATS consumer for processing messages from a JetStream stream.
+ *
+ * @typeparam {T} - The type of event to be consumed, extending the Event interface.
+ */
 class NatsConsumer {
+    /**
+     * Creates an instance of NatsConsumer.
+     *
+     * @param {NatsConnection} client - The NATS connection instance.
+     */
     constructor(client) {
         this.jc = (0, nats_1.JSONCodec)();
         this.sc = (0, nats_1.StringCodec)();
         this.ackWait = (0, nats_1.nanos)(5 * 1000);
+        /**
+         * Utility method to parse the message data using the appropriate codec (JSON or string).
+         *
+         * @protected
+         * @param {JsMsg} msg - The message object received from the stream.
+         * @returns {T["data"]} - The parsed message data.
+       */
         this.parsedMessage = (msg) => typeof msg.data === "string" ? this.sc.decode(msg.data) : this.jc.decode(msg.data);
         this.client = client;
     }
+    /**
+     * Provides the consumer options for JetStream.
+     *
+     * @returns {Partial<ConsumerConfig>} - The partial consumer options.
+     */
     get consumerOptions() {
         return {
             deliver_policy: nats_1.DeliverPolicy.All,
@@ -36,6 +58,11 @@ class NatsConsumer {
             filter_subject: this.subject,
         };
     }
+    /**
+     * Consume messages from the JetStream stream and process them concurrently.
+     *
+     * Messages are processed asynchronously up to the maximum concurrent limit.
+     */
     consume() {
         var _a, e_1, _b, _c;
         return __awaiter(this, void 0, void 0, function* () {
@@ -87,6 +114,12 @@ class NatsConsumer {
             }
         });
     }
+    /**
+     * Closes the NATS connection when message processing is finished.
+     *
+     * @protected
+     * @returns {Promise<void>} - A Promise that resolves once the NATS connection is drained and closed.
+   */
     close() {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.client.drain();

package/build/events/base/base-publisher.d.ts

@@ -1,14 +1,33 @@
 import { PubAck, NatsConnection } from "nats";
 import { Subjects } from "../common/enums";
 import { MainSubjects, ValidateSubjectFormat } from "../common/enums/subjects/main-subjects";
+/**
+ * Interface representing an event to be published to NATS.
+ */
 interface Event {
     subject: ValidateSubjectFormat<Subjects, MainSubjects>;
     data: any;
 }
+/**
+ * Abstract class representing a NATS publisher for publishing events to NATS.
+ *
+ * @typeparam {T} - The type of event to be published, extending the Event interface.
+ */
 export declare abstract class NatsPublisher<T extends Event> {
     private jc;
     private sc;
+    /**
+     * The subject representing the event type to be published.
+     */
     abstract subject: T["subject"];
+    /**
+   * Publishes an event to NATS using the provided NATS connection.
+   *
+   * @param {NatsConnection} nc - The NATS connection instance.
+   * @param {T["data"]} data - The data to be published as part of the event.
+   * @returns {Promise<PubAck>} - A Promise that resolves with the PubAck response from NATS.
+   * @throws {Error} - Throws an error if there is an issue while publishing the event.
+   */
     publish(nc: NatsConnection, data: T["data"]): Promise<PubAck>;
 }
 export {};