@ccci/micro-server 1.0.168 → 1.0.170

package/dist/decorators/Endpoints.d.ts

@@ -0,0 +1,12 @@
+export declare const endpoint: (target: any, methodName: string, descriptor: PropertyDescriptor) => void;
+export declare const PublicAccess: <T extends new (...args: any[]) => {}>(constructor: T) => {
+    new (...args: any[]): {
+        grantPublicAccess: boolean;
+    };
+} & T;
+export declare const PrivateAccess: <T extends new (...args: any[]) => {}>(constructor: T) => {
+    new (...args: any[]): {
+        grantPublicAccess: boolean;
+    };
+} & T;
+//# sourceMappingURL=Endpoints.d.ts.map

package/dist/index.js

@@ -297575,7 +297575,8 @@ function ConstructQuery(query) {
     let where2 = {};
     const pairs = query.search.split(",");
     pairs.forEach((field) => {
-      if (field.indexOf("|") > -1) {
+      if (field.indexOf("$") > -1) {
+      } else if (field.indexOf("|") > -1) {
         if (!where2.hasOwnProperty(Op.or))
           where2[Op.or] = [];
         let orFields = field.split("|");
@@ -297648,7 +297649,29 @@ function ConstructQuery(query) {
   }
   if (query.includes) {
     let data = query.includes.split(",");
-    let includes = data.filter((el) => el.indexOf(".") == -1);
+    let includes = [];
+    let toplevel = data.filter((el) => el.indexOf(".") == -1);
+    toplevel.forEach((top) => {
+      let association = { association: top };
+      if (query.search) {
+        const queries = query.search.split(",");
+        Logger.info(`queries: ${JSON.stringify(queries)}`);
+        let injectable = queries.find((q) => q.indexOf("$") > -1 && q.indexOf(top) > -1);
+        Logger.info(`injectable: ${JSON.stringify(injectable)}`);
+        if (injectable) {
+          injectable = injectable.replaceAll("$", "");
+          let nested2 = injectable.split(".");
+          Logger.info(`nested: ${JSON.stringify(nested2)}`);
+          let pair = nested2[1].split(":");
+          Logger.info(`pair: ${JSON.stringify(pair)}`);
+          let associationkey = pair[0];
+          Logger.info(`associationkey: ${JSON.stringify(associationkey)}`);
+          association.where = { associationkey: pair[1] };
+          Logger.info(`association.where: ${JSON.stringify(association.where)}`);
+        }
+      }
+      includes.push(association);
+    });
     let nested = data.filter((el) => el.indexOf(".") > -1);
     nested.forEach((nest) => {
       let keypair = nest.split(".");
@@ -297663,6 +297686,7 @@ function ConstructQuery(query) {
       }
       includes.push(temp);
     });
+    Logger.info(`INCLUDES: ${JSON.stringify(includes)}`);
     options.includes = includes;
   }
   if (query.paranoid) {
@@ -297772,7 +297796,7 @@ class BaseController {
     try {
       let query = req.query;
       let options = ConstructQuery(query);
-      Logger.info(`WHERE CLAUSE: ${options.where}`);
+      Logger.info(`WHERE CLAUSE: ${JSON.stringify(options.where)}`);
       let response4 = null;
       if (!response4) {
         response4 = await this._model?.findAndCountAll({

package/dist/types/ApplicationOptionType.d.ts

@@ -0,0 +1,36 @@
+export type ApplicationOptionType = {
+    routeContext?: string;
+    configDir?: string;
+    modelDir?: string;
+    controllerDir?: string;
+    routeDir?: string;
+    websocketPort?: number;
+    websocketDir?: string;
+    enableRedis?: boolean;
+    enableMinio?: boolean;
+    enableKafka?: boolean;
+    enableS3?: boolean;
+    enableWebSocket?: boolean;
+    enableFirebase?: boolean;
+    enableEmail?: boolean;
+    clientId?: string;
+    brokers?: string[];
+    consumersPath?: string;
+    producersPath?: string;
+    minioHost?: string;
+    minioPort?: number;
+    minioAccessKey?: string;
+    minioSecretKey?: string;
+    minioUseSSL?: boolean;
+    smtpService?: string;
+    smtpHost?: string;
+    smtpUser?: string;
+    smtpPassword?: string;
+    enablePushNotifications?: boolean;
+    s3ForcePathStyle?: boolean;
+    s3Endpoint?: string;
+    s3region?: string;
+    s3AccessKeyId?: string;
+    s3SecretAccessKey?: string;
+};
+//# sourceMappingURL=ApplicationOptionType.d.ts.map

package/dist/types/AttachmentMetadataTypes.d.ts

@@ -0,0 +1,9 @@
+export type AttachmentMetadataType = {
+    Bucket?: string;
+    Etag?: string;
+    Key?: string;
+    Location?: string;
+    MimeType?: string;
+};
+export declare const mimeTypes: Record<string, string>;
+//# sourceMappingURL=AttachmentMetadataTypes.d.ts.map

package/dist/types/BaseControllerTypes.d.ts

@@ -0,0 +1,42 @@
+import { Order, WhereOptions } from "sequelize";
+export type RequestQuery = {
+    search?: string;
+    limit?: number;
+    page?: number;
+    includes?: string;
+    fields?: string;
+    paranoid?: string;
+    sort?: string;
+    paginate?: string;
+    date_range?: string;
+    others?: any;
+    scan?: string;
+    groupBy?: string;
+};
+export type QueryOptions = {
+    where?: WhereOptions<any>;
+    limit?: number;
+    offset?: number;
+    attributes?: Array<string>;
+    order?: Order;
+    paranoid?: boolean;
+    includes?: Array<string | IncludeType>;
+};
+export type ResponseType = {
+    success: boolean;
+    error?: number;
+    statusCode?: number;
+    errorMessage?: string;
+    errorDescription?: string;
+    response?: object;
+    version?: string;
+    errors?: string[];
+};
+export type IncludeType = {
+    association?: string;
+    include?: Array<IncludeType>;
+};
+export type CommonType = {
+    [x: string | symbol]: any;
+};
+//# sourceMappingURL=BaseControllerTypes.d.ts.map

package/dist/types/BaseModelTypes.d.ts

@@ -0,0 +1,33 @@
+export declare enum FindTypeEnum {
+    FIND_ALL = "findAndCountAll",
+    FIND_PK = "findByPk",
+    FIND_ONE = "findOne",
+    COUNT = "count"
+}
+export type IncludesType = {
+    path?: string;
+    association?: AssociationType;
+};
+export type AssociationType = {
+    include: Array<string> | Array<object>;
+    association?: string;
+    where?: object;
+};
+export type QueryType = {
+    where?: object;
+    limit?: number;
+    offset?: number;
+    select?: object;
+    order?: object;
+    attributes?: object;
+    returning?: boolean;
+    raw?: boolean;
+    nest?: boolean;
+    distinct?: string;
+    include?: object;
+};
+export type RequestUserType = {
+    id?: number;
+    email?: string;
+};
+//# sourceMappingURL=BaseModelTypes.d.ts.map

package/dist/types/BaseRouterTypes.d.ts

@@ -0,0 +1,9 @@
+import { Request, Response, NextFunction } from 'express';
+import { ResponseType } from './BaseControllerTypes';
+export type Mappings = {
+    path: string;
+    method: string;
+    function: (req: Request, res: Response, next: NextFunction) => Promise<void | ResponseType>;
+    middleware?: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+};
+//# sourceMappingURL=BaseRouterTypes.d.ts.map

package/dist/types/BaseSocketType.d.ts

@@ -0,0 +1,6 @@
+export type WebSocketData = {
+    userId?: number;
+    channel?: string;
+    room?: string;
+};
+//# sourceMappingURL=BaseSocketType.d.ts.map

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/types/NotificationTypes.d.ts

@@ -0,0 +1,9 @@
+export type NotificationType = {
+    title: string;
+    body: string;
+    imageUrl?: string;
+};
+export type NotificationOptions = {
+    isBroadcast?: Boolean;
+};
+//# sourceMappingURL=NotificationTypes.d.ts.map

package/dist/types/UploadedFileType.d.ts

@@ -0,0 +1,9 @@
+export type UploadedFileType = {
+    etag?: string;
+    path?: string;
+    bucket?: string;
+    directory?: string;
+    objectName?: string;
+    mimeType?: string;
+};
+//# sourceMappingURL=UploadedFileType.d.ts.map

package/dist/utils/ApplicationServer.d.ts

@@ -0,0 +1,27 @@
+import { Application } from 'express';
+import BaseSocketHandler from './BaseSocketHandler';
+import { ApplicationOptionType } from '@/types/ApplicationOptionType';
+/**
+ * Application Sever class
+ */
+export default class ApplicationServer {
+    static app: Application;
+    static socketHandlers: Array<{
+        path: string;
+        handler: BaseSocketHandler;
+    }>;
+    /**
+     * Initializes the application server
+     * @param {number} port  port for the micro service
+     * @param {ApplicationOptionType} options additional server configuration
+     * @param {Array<String>} sync models to be sync to the database
+     *
+     */
+    static bootstrap(port: number, options?: ApplicationOptionType, sync?: Array<string> | Boolean): Promise<void>;
+    static getInstance(): Application;
+    static getWebsocketHandlers(): Array<{
+        path: string;
+        handler: any;
+    }>;
+}
+//# sourceMappingURL=ApplicationServer.d.ts.map

package/dist/utils/BaseAuthenticatorModel.d.ts

@@ -0,0 +1,7 @@
+import BaseModel from "./BaseModel";
+export default class BaseAuthenticatorModel extends BaseModel {
+    password?: string;
+    authenticate(password: string): boolean;
+    updatePassword(password?: string): string | undefined;
+}
+//# sourceMappingURL=BaseAuthenticatorModel.d.ts.map

package/dist/utils/BaseConsumer.d.ts

@@ -0,0 +1,44 @@
+import { type ConsumerConfig } from "kafkajs";
+import { BaseKafka } from "./BaseKafka";
+import type { MessageHandler } from "../types/BrokerType";
+/**
+ * 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 consumer;
+    private kafka;
+    /**
+     * Creates an instance of BaseConsumer using a BaseKafka instance.
+     *
+     * @param {BaseKafka} baseKafka - The instance of the BaseKafka class which provides access to the Kafka client.
+     */
+    constructor(baseKafka: BaseKafka);
+    /**
+     * 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 {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.
+     */
+    connect(groupId: string, config?: ConsumerConfig): Promise<void>;
+    /**
+     * Disconnects the consumer from the Kafka cluster.
+     * 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/BaseController.d.ts

@@ -0,0 +1,96 @@
+import { Request, Response, NextFunction } from 'express';
+import { ResponseType } from '../types/BaseControllerTypes';
+export default class BaseController {
+    protected _model: import("sequelize").ModelCtor<import("sequelize").Model<any, any>> | undefined;
+    _modelName: string | undefined;
+    protected broadcastOnCreate: boolean;
+    protected broadcastOnUpdate: boolean;
+    protected broadcastOnDelete: boolean;
+    constructor(model?: string);
+    /**
+     * Find all the rows matching your query, within a specified offset / limit,
+     * and get the total number of rows matching your query.
+     * ```js
+     * Controller.find(req, res, next)
+     * ```
+     * @param req
+     * @param res
+     * @param next
+     */
+    find(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * Search for a single instance by its primary key.
+     * This applies LIMIT 1, so the listener will always be called with a single instance.
+     * @param req
+     * @param res
+     * @param next
+     */
+    findById(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     *
+     * @param req
+     * @param res
+     * @param next
+     */
+    create(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * Update multiple instances that match the where options. The promise returns an array with one or two elements. The first element is always the number of affected rows, while the second element is the actual affected rows (only supported in postgres and mssql with options.returning true.)
+     * @param req
+     * @param res
+     * @param next
+     */
+    update(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * Delete multiple instances, or set their deletedAt timestamp to the current time if paranoid is enabled.
+     * @param req
+     * @param res
+     * @param next
+     */
+    delete(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * Find all the rows matching your query, within a specified offset / limit,
+     * and get the total number of rows matching your query.
+     * ```js
+     * Controller.find(req, res, next)
+     * ```
+     * @param req
+     * @param res
+     * @param next
+     */
+    archives(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    restore(req: Request, res: Response, next?: NextFunction): Promise<ResponseType>;
+    /**
+     * count total number of records
+     * @param req
+     * @param res
+     * @param next
+     * @returns
+     */
+    count(req: Request, res: Response, next?: NextFunction): Promise<{
+        count: number;
+    }>;
+    /**
+     * Return a basic statistics based on the query and group provided.
+     * ```js
+     * Controller.find(req, res, next)
+     * ```
+     * @param req
+     * @param res
+     * @param next
+     */
+    stats(req: Request, res: Response, next?: NextFunction): Promise<any>;
+    /**
+     * ###############################################################
+     * ###################### LIFE CYCLE HOOKS #######################
+     * ###############################################################
+     */
+    beforeCreate(req: Request): Promise<void>;
+    afterCreate(req: Request, rec: any): Promise<void>;
+    beforeUpdate(req: Request): Promise<void>;
+    afterUpdate(req: Request, rec: any, orig: any): Promise<void>;
+    beforeDelete(req: Request): Promise<void>;
+    afterDelete(req: Request, rec: any): Promise<void>;
+    beforeFind(req: Request): Promise<void>;
+    afterFind(req: Request): Promise<void>;
+}
+//# sourceMappingURL=BaseController.d.ts.map

package/dist/utils/BaseControllerHelper.d.ts

@@ -0,0 +1,27 @@
+import { BaseError, UniqueConstraintError } from "sequelize";
+import { RequestQuery, QueryOptions, ResponseType } from "../types/BaseControllerTypes";
+/**
+ * Constructs a Sequelize query object based on the provided request query.
+ * This function dynamically builds the `where` clause, allows for sorting,
+ * pagination, field selection, and includes related models.
+ *
+ * @param {RequestQuery} query - The incoming request query parameters.
+ * @returns {QueryOptions} - Returns a Sequelize query options object to be used for querying the database.
+ */
+export declare function ConstructQuery(query: RequestQuery): QueryOptions;
+/**
+ * A helper function to structure a successful response.
+ *
+ * @param {any} response - Data to include in the response.
+ * @returns {ResponseType} - An object with success status and response data.
+ */
+export declare function ResponseHelper(response?: any): ResponseType;
+/**
+ * Handles errors and constructs an error response based on the type of error (Sequelize, database, or validation).
+ *
+ * @param {UniqueConstraintError | BaseError | Error | any} error - The error encountered during execution.
+ * @returns {ResponseType} - Returns a structured error response with error codes and messages.
+ */
+export declare function ErrorResponseHandler(error: UniqueConstraintError | BaseError | Error | any): ResponseType;
+export { ResponseType };
+//# sourceMappingURL=BaseControllerHelper.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/BaseModel.d.ts

@@ -0,0 +1,37 @@
+import { DataTypes, Model } from 'sequelize';
+import type { ModelAttributes } from "sequelize";
+import type IBaseModel from './IBaseModel';
+export default class BaseModel extends Model implements IBaseModel {
+    id?: number;
+    /**
+     * Sets common model attributes
+     * @returns
+     */
+    static getCommonAttributes(defaultAttributes: boolean): {
+        createdById: {
+            type: DataTypes.IntegerDataType;
+            comment: string;
+        };
+        updatedById: {
+            type: DataTypes.IntegerDataType;
+            comment: string;
+        };
+        isActive: {
+            type: DataTypes.AbstractDataType;
+            comment: string;
+            allowNull: boolean;
+            defaultValue: boolean;
+        };
+    } | null;
+    static getCommonAssociations(): void;
+    /**
+     *
+     * @param {ModelAttributes} fields table columns
+     * @param {string} tableName name of the table
+     * @param {string} schema this will overwrite the default schema
+     * @param {boolean} paranoid paranoid option. defaults to true
+     * @param {boolean} defaultAttributes need to inherit default attributes. defaults to true
+     */
+    static initialize(fields: ModelAttributes, tableName: string, schema?: string, paranoid?: boolean, defaultAttributes?: boolean): void;
+}
+//# sourceMappingURL=BaseModel.d.ts.map

package/dist/utils/BaseProducer.d.ts

@@ -0,0 +1,42 @@
+import { type ProducerConfig } from "kafkajs";
+import { BaseKafka } from "./BaseKafka";
+import type { PublishType } from "../types/BrokerType";
+/**
+ * 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 {
+    private producer;
+    private kafka;
+    /**
+     * Creates an instance of BaseProducer using a BaseKafka instance.
+     *
+     * @param {BaseKafka} baseKafka - The instance of the BaseKafka class which provides access to the Kafka client.
+     */
+    constructor(baseKafka: BaseKafka);
+    /**
+     * 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 {ProducerConfig} [config] - Optional additional configuration for the producer.
+     * @returns {Promise<void>} - A promise that resolves once the producer is connected.
+     */
+    connect(config?: ProducerConfig): Promise<void>;
+    /**
+     * Disconnects the producer from the Kafka cluster.
+     * If the producer is already disconnected, it logs a message and does nothing.
+     *
+     * @returns {Promise<void>} - A promise that resolves once the producer is disconnected.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * 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.
+     */
+    publish(data: PublishType): Promise<boolean>;
+}
+//# sourceMappingURL=BaseProducer.d.ts.map

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): Promise<void>;
+    static syncAll(force?: 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,7 @@
+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;
+}
+//# 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,39 @@
+/**
+ * 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;
+};
+//# 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/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): RequestUserType;
+export declare function decode(val: string | Request): RequestUserType;
+//# sourceMappingURL=TokenGenerator.d.ts.map

package/dist/utils/Uploader.d.ts

@@ -0,0 +1,31 @@
+import { UploadedFile } from 'express-fileupload';
+import * as minio from 'minio';
+import { ApplicationOptionType } from '..';
+import { UploadedFileType } from '@/types/UploadedFileType';
+export default class Uploader {
+    static client: minio.Client;
+    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>>;
+    /**
+     *
+     * @param bucket {string} bucket name
+     * @param file {string} file directory
+     */
+    preview(bucket: string, file: string): Promise<void>;
+}
+//# 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,67 @@
+/// <reference types="node" />
+import { ApplicationOptionType } from "@/types/ApplicationOptionType";
+import { S3 } 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>;
+}
+//# sourceMappingURL=uploader-s3.d.ts.map

package/package.json

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