@ccci/micro-server 1.0.243 → 1.1.5

package/dist/utils/BaseRouter.d.ts

@@ -0,0 +1,91 @@
+import { Request, Response, NextFunction, Router } from 'express';
+import BaseController from './BaseController';
+import { Mappings } from '../types/BaseRouterTypes';
+export default class BaseRouter<T extends BaseController> {
+    grantPublicAccess: boolean;
+    controller: T;
+    /**
+     *
+     * @param {Controller} controller
+     */
+    constructor(controller: T);
+    /**
+     * @description GET route
+     * @param {Request} req
+     * @param {Response} res
+     * @param {NextFunction} next
+     */
+    get(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description GET ARCHIVES route
+     * @param {Request} req
+     * @param {Response} res
+     * @param {NextFunction} next
+     */
+    archives(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description POST route
+     * @param {Request} req
+     * @param {Response} res
+     * @param {NextFunction} next
+     */
+    post(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description GET route (/:id)
+     * @param {HttpRequest} req
+     * @param {HttpResponse} res
+     * @param {*} next
+     */
+    getId(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description PUT route (/:id)
+     * @param {HttpRequest} req
+     * @param {HttpResponse} res
+     * @param {*} next
+     */
+    update(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     *
+     * @param req
+     * @param res
+     * @param next
+     */
+    delete(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     *
+     * @param req
+     * @param res
+     * @param next
+     */
+    restore(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * /count route
+     * @param req
+     * @param res
+     * @param next
+     */
+    count(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * /stats get count by group
+     * @param req
+     * @param res
+     * @param next
+     */
+    stats(req: Request, res: Response, next: NextFunction): Promise<void>;
+    /**
+     * @description default mappings that will be inherited across all router class
+     * @returns {Array} mappings
+     */
+    getMapping: () => Mappings[];
+    /**
+     * @description additional mappings placeholder, designed to be overriden
+     * @returns {Array} mappings
+     */
+    getAdditionalMapping: () => Mappings[];
+    /**
+     * @description create the express router
+     * @returns {Router} router
+     */
+    getRoutes(): Router;
+}
+//# sourceMappingURL=BaseRouter.d.ts.map

package/dist/utils/BaseSocketHandler.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="bun-types" />
+/// <reference types="node" />
+/// <reference types="bun-types" />
+import type { Server, ServerWebSocket } from 'bun';
+export default class BaseSocketHandler {
+    static channel: string;
+    static server: Server;
+    static websocket: ServerWebSocket;
+    /**
+     *
+     * @param req {Request}
+     * @param server {Server}
+     * @returns
+     */
+    upgrade(req: Request, server: Server): Promise<void>;
+    /**
+     *
+     * @param ws {ServerWebSocket}
+     * @param message {String}
+     */
+    accept(ws: ServerWebSocket, message: string): Promise<void>;
+    /**
+     *
+     * @param ws {ServerWebSocket}
+     */
+    connect(ws: ServerWebSocket): Promise<void>;
+    /**
+     *
+     * @param ws {ServerWebSocket}
+     * @param code {number}
+     * @param reason {reason}
+     */
+    disconnect(ws: ServerWebSocket, code: number, reason: string): Promise<void>;
+    getInstance(): ServerWebSocket;
+    static parse(url: String): any;
+}
+//# sourceMappingURL=BaseSocketHandler.d.ts.map

package/dist/utils/DatabaseConnector.d.ts

@@ -0,0 +1,26 @@
+import { Model, ModelStatic, Sequelize } from "sequelize";
+export default class DatabaseConnector {
+    private static connections;
+    private static connection;
+    private static rootDir;
+    constructor(path: string);
+    /**
+     * Initializes the database connection
+     * @param path
+     */
+    static init(): Promise<Array<Sequelize>>;
+    static checkConnection(connection: Sequelize): Promise<void>;
+    /**
+     *
+     * @param path root dir (__dirname)
+     */
+    initializeModels(): Promise<void>;
+    getConnections(): Array<Sequelize>;
+    static getConnection(): Sequelize;
+    connect(connection: Sequelize): Promise<void>;
+    static getModel(modelName: string): ModelStatic<Model>;
+    static sync(modelName: string, force?: boolean, alter?: boolean): Promise<void>;
+    static syncAll(force?: boolean, alter?: boolean): Promise<void>;
+    static disconnect(): void;
+}
+//# sourceMappingURL=DatabaseConnector.d.ts.map

package/dist/utils/ErrorHandler.d.ts

@@ -0,0 +1,5 @@
+export default class ErrorHandler extends Error {
+    statusCode: number | undefined;
+    constructor(message?: string, statusCode?: number);
+}
+//# sourceMappingURL=ErrorHandler.d.ts.map

package/dist/utils/IBaseModel.d.ts

@@ -0,0 +1,9 @@
+export default interface IBaseModel {
+    id?: number;
+    createdById?: number;
+    updatedById?: number;
+    createdAt?: Date;
+    updatedAt?: Date;
+    _search?: string;
+}
+//# sourceMappingURL=IBaseModel.d.ts.map

package/dist/utils/Logger.d.ts

@@ -0,0 +1,8 @@
+export default class Logger {
+    static info(message: string, details?: any): void;
+    static error(error: Error): void;
+    static warn(message: string): void;
+    static debug(message: string, details?: any): void;
+    static table(data: object[]): void;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/dist/utils/Mailer.d.ts

@@ -0,0 +1,23 @@
+import { ApplicationOptionType } from '..';
+interface MailInterface {
+    from?: string;
+    to: string | string[];
+    cc?: string | string[];
+    bcc?: string | string[];
+    subject: string;
+    text?: string;
+    html: string;
+}
+export default class Mailer {
+    private static instance;
+    private transporter;
+    private sender;
+    private LOCAL_DIR;
+    static getInstance(): Mailer;
+    connect(options: ApplicationOptionType): Promise<void>;
+    hasValidConfig(options: ApplicationOptionType): boolean;
+    sendMail(options: MailInterface, template?: string, values?: any): Promise<void>;
+    findTemplate(name: string): Promise<unknown>;
+}
+export {};
+//# sourceMappingURL=Mailer.d.ts.map

package/dist/utils/Mixins.d.ts

@@ -0,0 +1,72 @@
+/// <reference types="node" />
+/**
+ * Retrieves the MIME type for a given file name based on its extension.
+ * @param fileName - The name of the file to extract the MIME type for.
+ * @returns The MIME type if found, or null if not found.
+ */
+export declare const getMimeType: (fileName: string) => string | null;
+/**
+ * Extracts numeric IDs from a string in the format [Name:ID].
+ * @param input - The input string containing IDs in the format [Name:ID].
+ * @returns An array of extracted numeric IDs.
+ */
+export declare const extractIds: (input: string) => number[];
+/**
+ * Decrypts an encoded string using a salt.
+ * @param salt - The salt used for decryption.
+ * @param encoded - The encoded string to decrypt.
+ * @returns The decrypted string.
+ */
+export declare const decrypt: (salt: string, encoded: string) => string;
+/**
+ * Encrypts a plain text string using a salt.
+ * @param salt - The salt used for encryption.
+ * @param text - The plain text string to encrypt.
+ * @returns The encrypted string in hexadecimal format.
+ */
+export declare const encrypt: (salt: string, text: string) => string;
+/**
+ * Returns the start and end dates of the current week.
+ * The week starts on Monday (00:00:00.000) and ends on Sunday (23:59:59.999).
+ *
+ * @returns An object containing:
+ *   - `startOfWeek`: Date representing the beginning of the current week (Monday at midnight).
+ *   - `endOfWeek`: Date representing the end of the current week (Sunday at 23:59:59.999).
+ */
+export declare const getCurrentWeek: () => {
+    startOfWeek: Date;
+    endOfWeek: Date;
+};
+/**
+ * Consumes a readable stream and aggregates all data chunks into a single Buffer.
+ * * @param {stream.Readable} res - The incoming data stream.
+ * @returns {Promise<Buffer>} A promise that resolves to the complete binary data.
+ */
+export declare function readAsBuffer(res: any): Promise<Buffer>;
+/**
+ * Reads an HTTP response body in its entirety and converts it to a string.
+ * Useful for parsing XML error messages or small metadata responses.
+ * * @param {http.IncomingMessage} res - The HTTP response object.
+ * @returns {Promise<string>} The body content decoded as a string.
+ */
+export declare function readAsString(res: any): Promise<string>;
+/**
+ * Parses an XML string into a JavaScript object using fast-xml-parser.
+ * * @throws {S3XmlError} If the XML contains an <Error> tag, it throws the error body.
+ */
+export declare const parseXml: (xml: string) => any;
+/**
+ * Specifically extracts the CopyPartResult from an S3 XML response.
+ * Used during multipart copy operations or part uploads that return XML.
+ */
+export declare const uploadPartParser: (xml: string) => any;
+/**
+ * Removes various encodings of double quotes from the start and end of an ETag.
+ * * @description
+ *  S3-compatible storage often returns ETags wrapped in literal quotes or
+ *  HTML entities. This regex-based sanitizer ensures only the raw hash remains.
+ * @param {string} [etag=''] - The raw ETag string from headers or XML.
+ * @returns {string} The cleaned ETag.
+ */
+export declare const sanitizeETag: (etag: string) => string;
+//# sourceMappingURL=Mixins.d.ts.map

package/dist/utils/PushNotifier.d.ts

@@ -0,0 +1,19 @@
+import type { NotificationType, NotificationOptions } from '@/types/NotificationTypes';
+import admin from 'firebase-admin';
+import { BatchResponse } from 'firebase-admin/lib/messaging/messaging-api';
+export default class PushNotifier {
+    static FirebaseAdmin: typeof admin;
+    static instance: number;
+    private static rootDir;
+    constructor(path: string);
+    /**
+     * Initiate sending push notifications
+     * @param tokens firebase user tokens
+     * @param message message to send
+     * @param metadata
+     * @param options
+     */
+    static sendNotifications(tokens: Array<string>, message: NotificationType, metadata?: any, options?: NotificationOptions): Promise<BatchResponse | undefined>;
+    static sendNotification(token: string, message: NotificationType, metadata?: any, options?: NotificationOptions): Promise<string | undefined>;
+}
+//# sourceMappingURL=PushNotifier.d.ts.map

package/dist/utils/RedisQueryHelper.d.ts

@@ -0,0 +1,38 @@
+export type QueryOptions = {
+    forceRefresh?: boolean;
+    paginate?: boolean;
+    limit?: number;
+    page?: number;
+    sort?: string;
+    search?: string;
+    fulltext?: boolean;
+    defaultSearchFields?: string[];
+};
+export type PaginatedResult<T> = {
+    rows: T[];
+    count: number;
+    meta: {
+        total: number;
+        limit: number;
+        page: number;
+        totalPages: number;
+        hasNextPage: boolean;
+        hasPrevPage: boolean;
+        sort: string;
+    };
+};
+type SearchOptions = {
+    fulltext?: boolean;
+    defaultFields?: string[];
+};
+export declare class QueryHelper {
+    private static getFieldValue;
+    private static buildHaystack;
+    private static matchesSearch;
+    static filterBySearch<T>(items: T[], search: string, options?: SearchOptions): T[];
+    static sort<T>(items: T[], sort: string): T[];
+    static paginate<T>(items: T[], limit: number, page: number, sort: string): PaginatedResult<T>;
+    static applyQuery<T>(items: T[], options?: QueryOptions): T[] | PaginatedResult<T>;
+}
+export {};
+//# sourceMappingURL=RedisQueryHelper.d.ts.map

package/dist/utils/RouterFactory.d.ts

@@ -0,0 +1,12 @@
+import { Application, Request, Response, NextFunction } from 'express';
+export default class RouterFactory {
+    /**
+     *
+     * @param app express application instance
+     * @param pathName root path of the application
+     * @param folderName path of the routers (default: routes)
+     */
+    static init(app: Application, pathName: string, folderName?: string, context?: string): Promise<void>;
+    static authenticate(req: Request, res: Response, next: NextFunction, grantPublicAccess?: boolean): Response<any, Record<string, any>> | undefined;
+}
+//# sourceMappingURL=RouterFactory.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/dist/utils/TokenGenerator.d.ts

@@ -0,0 +1,11 @@
+import { Request } from 'express';
+import { RequestUserType } from '../types/BaseModelTypes';
+/**
+ * generate jwt token from the payload
+ * @param payload
+ * @returns
+ */
+export declare function generate(payload: object): string;
+export declare function verify(token: string, secret?: string): RequestUserType;
+export declare function decode(val: string | Request): RequestUserType;
+//# sourceMappingURL=TokenGenerator.d.ts.map

package/dist/utils/Uploader.d.ts

@@ -0,0 +1,127 @@
+/// <reference types="node" />
+import { UploadedFile } from 'express-fileupload';
+import * as minio from 'minio';
+import { ApplicationOptionType } from '..';
+import { UploadedFileType, InitUpload, UploadChunk, CompleteUploadResult, UploadTypes, UploadPart } from '@/types/UploadedFileType';
+import { RemoveOptions } from 'minio';
+export default class Uploader {
+    static client: minio.Client;
+    static clientEndpoint: string;
+    constructor();
+    /**
+     * Initializes the minIO client instance
+     */
+    static init(options: ApplicationOptionType): Promise<void>;
+    /**
+     * checks .env variables if properly configured
+     */
+    static hasValidConfig(options: ApplicationOptionType): boolean;
+    /**
+     *
+     * @param bucket {string} The bucket name in minIO
+     * @param dir {string} The directory where the files are stored
+     * @param uploads {Array<UploadedFile> | UploadedFile} file(s) to be uploaded
+     * @returns
+     */
+    static upload(bucket: string, dir: string, uploads: Array<UploadedFile> | UploadedFile): Promise<Array<UploadedFileType> | UploadedFileType>;
+    /**
+     *
+     * @param bucket {string} bucket name
+     * @param file {string} file directory
+     */
+    preview(bucket: string, file: string): Promise<void>;
+    static delete(bucketName: string, objectName: string, removeOpts?: RemoveOptions): Promise<void>;
+    /**
+     * Permanently cancels all pending multipart uploads within a specified S3/MinIO bucket.
+     * @description
+     *  This is a cleanup utility. Incomplete multipart uploads occupy storage space but are not visible as objects. This method iterates through the bucket's "incomplete" stream and issues an abort command for each. Use this to recover storage or clear stuck uploads after a service interruption.
+     * @param {string} bucketName - The unique identifier of the target MinIO bucket.
+     * @returns {Promise<void>} Resolves when the stream has finished processing all abort requests.
+     * @throws {Error} If the bucket is inaccessible or the list operation fails.
+     * @example
+     *  await Uploader.clearAllMultipartUploads('temp-uploads');
+     */
+    static clearAllMultipartUploads(bucketName: string): Promise<void>;
+    /**
+     * Starts a new multipart upload session and registers it in the local session cache.
+     * @description
+     * This method performs two actions:
+     *  1. Requests a new Multipart Upload ID from the MinIO/S3 server.
+     *  2. Initializes an internal tracking session in `uploadSessions` for part management.
+     * @param {string} bucket - Target bucket name.
+     * @param {string} fileName - The final destination filename/path.
+     * @param {Record<string, string>} [metadata={}] - Key-value pairs for S3 metadata.
+     * - Standard headers: `Content-Type`, `Cache-Control`, etc.
+     * - Custom tags: Use `X-Amz-meta-` prefix for custom attributes.
+     * @returns {Promise<InitUpload>}
+     *  Returns the internal session ID and the provider's upload ID.
+     * @throws {Error} If the connection to MinIO fails or the bucket does not exist.
+     */
+    static initiateUpload(bucket: string, fileName: string, metadata?: Record<string, string>): Promise<InitUpload>;
+    /**
+     * Processes and uploads a single data part to an active multipart session.
+     * @description
+     * This method normalizes various input formats (Buffer, string, or Uint8Array) into a binary Buffer, dispatches the upload to MinIO via `uploadPart`, and updates the  internal session state with the returned ETag.
+     * @param {string} uploadSessionId - The internal UUID generated during `initiateUpload`.
+     * @param {number} chunkNumber - The 1-based index of the part.
+     * @param {Buffer | string | Uint8Array} chunkData - The raw binary data or encoded string.
+     * @returns {Promise<UploadChunk>} Returns metadata about the uploaded part, including:
+     * - `etag`: The S3 identifier for this specific part (required for completion).
+     * - `uploadedPart`: The total count of parts successfully tracked in this session so far.
+     */
+    static uploadChunk(uploadSessionId: string, chunkNumber: number, chunkData: Buffer | string | Uint8Array): Promise<UploadChunk>;
+    /**
+     * Finalizes the multipart upload by assembling all uploaded parts into a single object.
+     * @description
+     * This method performs the final handshake with MinIO/S3. It:
+     * 1. Retrieves and sorts the accumulated ETags by part number (mandatory for S3 compliance).
+     * 2. Signals the storage server to merge the data parts.
+     * 3. Extracts file metadata (size, mime-type) from the session.
+     * 4. Purges the internal `uploadSessions` cache to prevent memory leaks.
+     * @param {string} uploadSessionId - The internal tracking ID of the session to be closed.
+     * @returns {Promise<Object>} A curated result object containing:
+     * - `etag`: The final entity tag for the completed object.
+     * - `location`: The public/internal URL of the uploaded file.
+     * - `fileSize`: Parsed size from the 'X-Amz-meta-filesize' metadata.
+     * @throws {Error} If parts are missing, the session is not found, or S3 assembly fails.
+     */
+    static completeUpload(uploadSessionId: string): Promise<CompleteUploadResult>;
+    /**
+     * Streams an object from storage directly to an HTTP response.
+     * @description
+     * Fetches object metadata (stat) to populate necessary download headers before
+     * piping the data stream to the client. This avoids loading the entire file
+     * into memory, making it efficient for large file transfers.
+     * * @param {Response} res - The Express/Node.js response object.
+     * @param {UploadTypes} options - Configuration object containing:
+     * - `bucket`: Target bucket name.
+     * - `objectKey`: The internal storage path (e.g., 'stream/123').
+     * - `objectName`: The "friendly" filename for the user's browser.
+     * @returns {Promise<void>} Resolves once the stream has been successfully piped.
+     * @throws {Error} If the object does not exist or metadata cannot be retrieved.
+     */
+    static streamDownload(res: any, { bucket, objectKey, objectName }: UploadTypes): Promise<void>;
+    /**
+     * Executes a low-level Multipart Upload Part request.
+     * * @description
+     *  This is a custom wrapper around the S3/MinIO PUT Object Part API. It manually constructs the query parameters and headers required for a part upload. Crucially, it handles inconsistent server responses by attempting to extract the ETag from both the response XML body and the HTTP headers.
+     * @param {Object} partConfig - Configuration for the specific part.
+     * @param {string} partConfig.bucketName - Target bucket.
+     * @param {string} partConfig.objectName - The internal path/key of the object.
+     * @param {string} partConfig.uploadID - The ID generated by `initiateNewMultipartUpload`.
+     * @param {number} partConfig.partNumber - 1-based index of the part.
+     * @param {unknown} partConfig.headers - HTTP headers (e.g., Content-Length, Content-MD5).
+     * @param {any} [payload] - The binary data buffer for this part.
+     * @returns {Promise<UploadPart>}
+     *  Returns a sanitized ETag required for the final `completeUpload` call.
+     * @throws {Error} If no ETag is found in the response or the network request fails.
+     */
+    static uploadPart: (partConfig: {
+        bucketName: string;
+        objectName: string;
+        uploadID: string;
+        partNumber: number;
+        headers: unknown;
+    }, payload?: any) => Promise<UploadPart>;
+}
+//# sourceMappingURL=Uploader.d.ts.map

package/dist/utils/WebSocketServer.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="bun-types" />
+/// <reference types="bun-types" />
+import { ServerWebSocket } from 'bun';
+import BaseSocketHandler from './BaseSocketHandler';
+export default class WebSocketServer {
+    static socketHandlers: Array<{
+        path: string;
+        handler: BaseSocketHandler;
+    }>;
+    static init(port: number | undefined, dir: string, folder?: string): Array<{
+        path: string;
+        handler: BaseSocketHandler;
+    }>;
+    /**
+     *
+     * @returns
+     */
+    static getSocketHandlers(): Array<{
+        path: string;
+        handler: BaseSocketHandler;
+    }>;
+    /**
+     *
+     * @param path
+     * @returns
+     */
+    static getHandler(path: string): ServerWebSocket | null;
+}
+//# sourceMappingURL=WebSocketServer.d.ts.map

package/dist/utils/uploader-s3.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="node" />
+import { ApplicationOptionType } from "@/types/ApplicationOptionType";
+import { S3, DeleteObjectRequest } from "@aws-sdk/client-s3";
+import { AttachmentMetadataType } from "@/types/AttachmentMetadataTypes";
+export default class UploaderS3 {
+    static client: S3;
+    static uploadSessions: Record<string, string>;
+    /**
+     * Initializes the S3 client instance
+     */
+    static init(options: ApplicationOptionType): Promise<void>;
+    /**
+     * Validates configuration options
+     */
+    static hasValidConfig(options: ApplicationOptionType): boolean;
+    /**
+     * Lists all available S3 buckets
+     */
+    static listBuckets(): Promise<void>;
+    /**
+     * Starts a new multipart upload session
+     * @param bucketName S3 bucket name
+     * @param key Key for the object in S3
+     */
+    static startMultipartUpload(bucketName: string, key: string): Promise<string>;
+    /**
+     * Uploads a file part to S3
+     * @param bucketName S3 bucket name
+     * @param key Key for the object in S3
+     * @param uploadId Multipart upload session ID
+     * @param partNumber Part number for the upload
+     * @param chunk Chunk of the file to upload
+     */
+    static uploadPart(bucketName: string, key: string, uploadId: string, partNumber: number, chunk: Buffer): Promise<string | null>;
+    /**
+     * Completes a multipart upload
+     * @param bucketName S3 bucket name
+     * @param key Key for the object in S3
+     * @param uploadId Multipart upload session ID
+     * @param parts List of uploaded parts
+     */
+    static completeMultipartUpload(bucketName: string, key: string, uploadId: string, parts: {
+        PartNumber: number;
+        ETag: string;
+    }[]): Promise<AttachmentMetadataType>;
+    /**
+     * Aborts a multipart upload
+     * @param bucketName S3 bucket name
+     * @param key Key for the object in S3
+     * @param uploadId Multipart upload session ID
+     */
+    static abortMultipartUpload(bucketName: string, key: string, uploadId: string): Promise<void>;
+    /**
+     * Directly uploads a file to S3 without chunking
+     * @param bucketName S3 bucket name
+     * @param key Key for the object in S3
+     * @param fileContent The content of the file to upload
+     * @param contentType The MIME type of the file
+     */
+    static uploadFile(bucketName: string, key: string, fileContent: Buffer | Uint8Array | Blob | string, contentType: string): Promise<AttachmentMetadataType>;
+    /**
+     * Deletes all incomplete multipart uploads in the specified bucket
+     * @param bucketName S3 bucket name
+     */
+    static deleteIncompleteUploads(bucketName: string): Promise<void>;
+    static deleteFile(request: DeleteObjectRequest): Promise<void>;
+}
+//# sourceMappingURL=uploader-s3.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccci/micro-server",
-  "version": "1.0.243",
+  "version": "1.1.5",
   "module": "index.ts",
   "type": "module",
   "main": "dist/index.js",
@@ -23,7 +23,10 @@
     "@types/nodemailer": "^6.4.15",
     "prettier": "^3.0.3",
     "rimraf": "^5.0.5",
-    "typescript": "^5.2.2"
+    "typescript": "^5.2.2",
+    "vite": "^5.0.10",
+    "vite-tsconfig-paths": "^6.1.0",
+    "vitest": "^1.1.0"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"
@@ -45,6 +48,7 @@
     "express": "^4.19.2",
     "express-fileupload": "^1.5.0",
     "express-list-endpoints": "^7.1.1",
+    "fast-xml-parser": "^5.3.4",
     "firebase": "^10.13.1",
     "firebase-admin": "^12.4.0",
     "handlebars": "^4.7.8",
@@ -55,6 +59,7 @@
     "nodemailer": "^6.9.13",
     "pg": "^8.11.5",
     "pg-hstore": "^2.3.4",
+    "redis": "^5.11.0",
     "sequelize": "^6.37.3",
     "socket.io": "^4.7.5",
     "winston": "^3.13.0"