@ccci/micro-server 1.1.14 → 1.1.15

package/dist/decorators/Endpoints.d.ts

@@ -0,0 +1,16 @@
+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.d.ts

@@ -0,0 +1,34 @@
+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 { 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 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 { BaseKafka } from './utils/BaseKafka';
+export { ServeKafka } from './utils/ServeKafka';
+export type { MessageHandler, MessageType, PublishType } from './types/BrokerType';
+export { default as BaseAuthenticatorModel } from './utils/BaseAuthenticatorModel';
+export { BaseRedis, BaseRedisCore, BaseRedisCrud, BaseRedisIndexing } from './utils/BaseRedis/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/test/BaseControllerHelper.unit.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=BaseControllerHelper.unit.test.d.ts.map

package/dist/test/Uploader.integration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Uploader.integration.test.d.ts.map

package/dist/types/ApplicationOptionType.d.ts

@@ -0,0 +1,39 @@
+export type ApplicationOptionType = {
+    routeContext?: string;
+    configDir?: string;
+    modelDir?: string;
+    controllerDir?: string;
+    routeDir?: string;
+    enableDb?: boolean;
+    enableRoutes?: boolean;
+    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;
+    appVersion?: string;
+};
+//# sourceMappingURL=ApplicationOptionType.d.ts.map

package/dist/types/AttachmentMetadataTypes.d.ts

@@ -0,0 +1,23 @@
+export type AttachmentMetadataType = {
+    Bucket?: string;
+    Etag?: string;
+    Key?: string;
+    Location?: string;
+    MimeType?: string;
+    Thumbnail?: string;
+    isHls?: boolean;
+};
+export type DeleteObjectRequest = {
+    Bucket: string;
+    Key: string;
+    MFA?: string;
+    VersionId?: string;
+    RequestPayer?: 'requester';
+    BypassGovernanceRetention?: boolean;
+    ExpectedBucketOwner?: string;
+    IfMatch?: string;
+    IfMatchLastModifiedTime?: Date;
+    IfMatchSize?: number;
+};
+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,41 @@
+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;
+    clientSecret?: string;
+};
+export type ModelOptions = {
+    tableName: string;
+    schema?: string;
+    paranoid?: boolean;
+    defaultAttributes?: boolean;
+    comment?: 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/RedisTypes.d.ts

@@ -0,0 +1,48 @@
+import { RediSearchSchema } from "redis";
+export interface QueryOptions {
+    page?: number;
+    limit?: number;
+    sort?: string;
+    withCount?: boolean;
+    paginate?: boolean;
+    search?: string;
+}
+export type RediSearchFieldValue = string | number | boolean | Date | null | undefined | Array<string | number | boolean>;
+export interface RediSearchCreateOptions {
+    ON?: "HASH" | "JSON";
+    PREFIX?: string | string[];
+    FILTER?: string;
+    LANGUAGE?: string;
+    LANGUAGE_FIELD?: string;
+    SCORE?: number;
+    SCORE_FIELD?: string;
+    MAXTEXTFIELDS?: boolean;
+    TEMPORARY?: number;
+    NOOFFSETS?: boolean;
+    NOHL?: boolean;
+    NOFIELDS?: boolean;
+    NOFREQS?: boolean;
+    SKIPINITIALSCAN?: boolean;
+    STOPWORDS?: string[] | "OFF";
+}
+export interface RediSearchIndexConfig<T = unknown> {
+    indexKey: string;
+    schema: RediSearchSchema;
+    options?: RediSearchCreateOptions;
+    fields?: (item: T, score: number) => Record<string, RediSearchFieldValue>;
+}
+export interface RediSearchQueryConfig {
+    indexKey: string;
+    query?: string;
+    sortBy?: string;
+    returnFields?: string[];
+    dialect?: number;
+}
+export interface RedisResult<T> {
+    rows: T[];
+    count?: number;
+    page: number;
+    limit: number;
+    hasNextPage: boolean;
+}
+//# sourceMappingURL=RedisTypes.d.ts.map

package/dist/types/UploadedFileType.d.ts

@@ -0,0 +1,68 @@
+export type UploadedFileType = {
+    etag?: string;
+    path?: string;
+    bucket?: string;
+    directory?: string;
+    objectName?: string;
+    mimeType?: string;
+    location?: string;
+    filesize?: number;
+};
+export type InitUpload = {
+    uploadId: string;
+    minioUploadId: string;
+    pathName: string;
+    message: string;
+};
+export type UploadPartConfig = {
+    bucketName: string;
+    objectName: string;
+    uploadID: string;
+    partNumber: number;
+    headers: unknown;
+};
+export type UploadSession = {
+    bucket: string;
+    uploadId: string;
+    fileName: string;
+    objectName: string;
+    minioUploadId: string;
+    parts: Array<{
+        part: number;
+        etag: string;
+    }>;
+    metadata?: Record<string, string>;
+    createdAt: Date;
+};
+export type UploadChunk = {
+    uploadId: string;
+    chunkNumber: number;
+    etag: string;
+    key: string;
+    part: number;
+    uploadedPart: number;
+    message: string;
+};
+export type CompleteUploadResult = {
+    etag: {
+        versionId: string;
+        etag: string;
+    };
+    path: string;
+    bucket: string;
+    location: string;
+    fileSize: number;
+    mimeType: string;
+    objectName: string;
+};
+export type UploadTypes = {
+    bucket: string;
+    objectKey: string;
+    objectName: string;
+};
+export type UploadPart = {
+    etag: string;
+    key: string;
+    part: number;
+};
+//# sourceMappingURL=UploadedFileType.d.ts.map

package/dist/utils/ApplicationServer.d.ts

@@ -0,0 +1,30 @@
+import { Application } from 'express';
+import Mailer from './Mailer';
+import BaseSocketHandler from './BaseSocketHandler';
+import { ApplicationOptionType } from '../types/ApplicationOptionType';
+/**
+ * Application Sever class
+ */
+export default class ApplicationServer {
+    static app: Application;
+    static mailer: Mailer;
+    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;
+    }>;
+    static getMailer(): Mailer;
+}
+//# 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 { ConsumerRunConfig, type Consumer, 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 {
+    consumer: Consumer | null;
+    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, consumerRunConfig?: ConsumerRunConfig): Promise<void>;
+}
+//# sourceMappingURL=BaseConsumer.d.ts.map

package/dist/utils/BaseController.d.ts

@@ -0,0 +1,97 @@
+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.
+     * -- added distinct:true
+     * ```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,44 @@
+import { DataTypes, Model } from 'sequelize';
+import type { ModelAttributes } from "sequelize";
+import type IBaseModel from './IBaseModel';
+import { ModelOptions } from '../types/BaseModelTypes';
+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, comment?: string): void;
+    /**
+     *
+     * @param {ModelAttributes} fields table columns
+     * @param {string} options  Model Options
+     */
+    static initialize(fields: ModelAttributes, options: ModelOptions): 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,34 @@
+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,71 @@
+/**
+ * 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/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,126 @@
+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,27 @@
+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 @@
+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.1.14",
+  "version": "1.1.15",
   "module": "index.ts",
   "type": "module",
   "main": "dist/index.js",