@kipicore/dbcore 1.1.694 → 1.1.696

package/dist/commonValidator/commandValidator.d.ts

@@ -0,0 +1,27 @@
+import Joi from 'joi';
+import { Request, Response, NextFunction } from 'express';
+import BaseValidator from './joiSchemaBuilder';
+import { CrudValidatorRules } from '../types/commonType';
+export default class BaseCrudValidator<TModel extends Record<string, any>, TKeys extends Extract<keyof TModel, string> = Extract<keyof TModel, string>> extends BaseValidator {
+    protected baseSchema: Joi.ObjectSchema<any>;
+    protected rules: CrudValidatorRules<TKeys>;
+    constructor(baseSchema: Joi.ObjectSchema<any>, rules?: CrudValidatorRules<TKeys>);
+    /** MERGE RULES */
+    private mergeRules;
+    /** APPLY DEFAULT ID RULE */
+    private applyDefaultIdRule;
+    /** Nested Required for  */
+    private applyNestedRequired;
+    /** CREATE */
+    createValidator: (req: Request, res: Response, next: NextFunction) => void;
+    /** UPDATE */
+    updateValidator: (req: Request, res: Response, next: NextFunction) => void;
+    /** DELETE */
+    deleteValidator: (req: Request, res: Response, next: NextFunction) => void;
+    /** GET BY ID */
+    getByIdValidator: (req: Request, res: Response, next: NextFunction) => void;
+    /** GET ALL */
+    getAllValidator: (req: Request, res: Response, next: NextFunction) => void;
+    /** GET ALL WITH PAGINATION */
+    getAllWithPaginationValidator: (req: Request, res: Response, next: NextFunction) => void;
+}

package/dist/commonValidator/commandValidator.js

@@ -0,0 +1,225 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const joi_1 = __importDefault(require("joi"));
+const joiSchemaBuilder_1 = __importStar(require("./joiSchemaBuilder"));
+const joiCommonValidator_1 = require("./joiCommonValidator");
+class BaseCrudValidator extends joiSchemaBuilder_1.default {
+    constructor(baseSchema, rules = {}) {
+        super();
+        /** CREATE */
+        this.createValidator = (req, res, next) => {
+            try {
+                const mergedRules = this.mergeRules({}, this.rules.create);
+                let schema = (0, joiSchemaBuilder_1.buildSchema)(this.baseSchema, mergedRules);
+                if (mergedRules.nestedRequired?.length) {
+                    schema = this.applyNestedRequired(schema, mergedRules.nestedRequired);
+                }
+                this.validate(schema, req);
+                next();
+            }
+            catch (err) {
+                next(err);
+            }
+        };
+        /** UPDATE */
+        this.updateValidator = (req, res, next) => {
+            try {
+                const idRules = this.applyDefaultIdRule(this.rules.update);
+                const mergedRules = this.mergeRules({}, idRules);
+                let schema = (0, joiSchemaBuilder_1.buildSchema)(this.baseSchema, mergedRules);
+                if (mergedRules.nestedRequired?.length) {
+                    schema = this.applyNestedRequired(schema, mergedRules.nestedRequired);
+                }
+                this.validate(schema, req);
+                next();
+            }
+            catch (err) {
+                next(err);
+            }
+        };
+        /** DELETE */
+        this.deleteValidator = (req, res, next) => {
+            try {
+                const idRules = this.applyDefaultIdRule(this.rules.delete);
+                const mergedRules = this.mergeRules({}, idRules);
+                const schema = (0, joiSchemaBuilder_1.buildSchema)(this.baseSchema, mergedRules);
+                this.validate(schema, req);
+                next();
+            }
+            catch (err) {
+                next(err);
+            }
+        };
+        /** GET BY ID */
+        this.getByIdValidator = (req, res, next) => {
+            try {
+                const idRules = this.applyDefaultIdRule(this.rules.getById);
+                const mergedRules = this.mergeRules({}, idRules);
+                const schema = (0, joiSchemaBuilder_1.buildSchema)(this.baseSchema, mergedRules);
+                this.validate(schema, req);
+                next();
+            }
+            catch (err) {
+                next(err);
+            }
+        };
+        /** GET ALL */
+        this.getAllValidator = (req, res, next) => {
+            try {
+                const mergedRules = this.mergeRules({}, this.rules.getAll);
+                const schema = (0, joiSchemaBuilder_1.buildSchema)(this.baseSchema, mergedRules);
+                this.validate(schema, req);
+                next();
+            }
+            catch (err) {
+                next(err);
+            }
+        };
+        /** GET ALL WITH PAGINATION */
+        this.getAllWithPaginationValidator = (req, res, next) => {
+            try {
+                const mergedRules = this.mergeRules({ customFields: joiCommonValidator_1.paginationValidators }, this.rules.getAllWithPagination ?? this.rules.getAll);
+                const schema = (0, joiSchemaBuilder_1.buildSchema)(this.baseSchema, mergedRules);
+                this.validate(schema, req);
+                next();
+            }
+            catch (err) {
+                next(err);
+            }
+        };
+        this.baseSchema = baseSchema;
+        this.rules = rules;
+    }
+    /** MERGE RULES */
+    mergeRules(defaultRules, overrideRules) {
+        const defaultCustomFields = {
+            search: joi_1.default.string().optional().allow(null),
+        };
+        return {
+            ...defaultRules,
+            ...overrideRules,
+            required: [...(defaultRules.required || []), ...(overrideRules?.required || [])],
+            optional: [...(defaultRules.optional || []), ...(overrideRules?.optional || [])],
+            allowNull: [...(defaultRules.allowNull || []), ...(overrideRules?.allowNull || [])],
+            forbidden: [...(defaultRules.forbidden || []), ...(overrideRules?.forbidden || [])],
+            singleOrArray: [...(defaultRules.singleOrArray || []), ...(overrideRules?.singleOrArray || [])],
+            singleOrArrayOrNull: [...(defaultRules.singleOrArrayOrNull || []), ...(overrideRules?.singleOrArrayOrNull || [])],
+            nestedRequired: [...(defaultRules.nestedRequired || []), ...(overrideRules?.nestedRequired || [])],
+            customFields: {
+                ...defaultCustomFields,
+                ...(defaultRules.customFields || {}),
+                ...(overrideRules?.customFields || {}),
+            },
+        };
+    }
+    /** APPLY DEFAULT ID RULE */
+    applyDefaultIdRule(override) {
+        const overrideHasId = override?.required?.includes('id') ||
+            override?.optional?.includes('id') ||
+            override?.forbidden?.includes('id');
+        if (override && overrideHasId)
+            return override;
+        if (override)
+            return override;
+        return { required: ['id'] };
+    }
+    /** Nested Required for  */
+    // private applyNestedRequired(schema: Joi.ObjectSchema, paths: string[]): Joi.ObjectSchema {
+    //     return schema.custom((value, helpers) => {
+    //         for (const path of paths) {
+    //             const keys = path.split('.');
+    //             let current: any = value;
+    //             let fullPath = '';
+    //             for (const key of keys) {
+    //                 if (Array.isArray(current)) {
+    //                     if (!current.length) {
+    //                         return helpers.message(`"${fullPath || path}" is required`);
+    //                     }
+    //                     current = current[0];
+    //                     fullPath += '[0]';
+    //                 }
+    //                 fullPath = fullPath ? `${fullPath}.${key}` : key;
+    //                 if (current?.[key] === undefined) {
+    //                     return helpers.message(`"${fullPath}" is required`);
+    //                 }
+    //                 current = current[key];
+    //             }
+    //         }
+    //         return value;
+    //     });
+    // }
+    applyNestedRequired(schema, paths) {
+        return schema
+            .custom((value, helpers) => {
+            const checkPath = (current, keys, basePath = '') => {
+                if (!keys.length)
+                    return null;
+                const [key, ...rest] = keys;
+                if (Array.isArray(current)) {
+                    for (let i = 0; i < current.length; i++) {
+                        const result = checkPath(current[i], keys, `${basePath}[${i}]`);
+                        if (result)
+                            return result;
+                    }
+                    return null;
+                }
+                const nextValue = current?.[key];
+                const currentPath = basePath ? `${basePath}.${key}` : key;
+                if (nextValue === undefined) {
+                    return currentPath;
+                }
+                return checkPath(nextValue, rest, currentPath);
+            };
+            for (const path of paths) {
+                const keys = path.split('.');
+                const missingPath = checkPath(value, keys);
+                if (missingPath) {
+                    return helpers.error('any.custom', {
+                        path: missingPath,
+                    });
+                }
+            }
+            return value;
+        })
+            .messages({
+            'any.custom': '"{{#path}}" is required',
+        });
+    }
+}
+exports.default = BaseCrudValidator;

package/dist/commonValidator/index.d.ts

@@ -0,0 +1,3 @@
+export * from './joiSchemaBuilder';
+export * from './joiCommonValidator';
+export { default as BaseValidator } from './joiSchemaBuilder';

package/dist/commonValidator/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseValidator = void 0;
+__exportStar(require("./joiSchemaBuilder"), exports);
+__exportStar(require("./joiCommonValidator"), exports);
+var joiSchemaBuilder_1 = require("./joiSchemaBuilder");
+Object.defineProperty(exports, "BaseValidator", { enumerable: true, get: function () { return __importDefault(joiSchemaBuilder_1).default; } });

package/dist/commonValidator/joiCommonValidator.d.ts

@@ -0,0 +1,12 @@
+import Joi from 'joi';
+export declare const paginationValidators: {
+    page: Joi.NumberSchema<number>;
+    limit: Joi.NumberSchema<number>;
+    search: Joi.StringSchema<string>;
+    isPaginate: Joi.BooleanSchema<boolean>;
+    order: Joi.ArraySchema<string[][]>;
+    sort: Joi.StringSchema<string>;
+};
+export declare const enumAlternatives: (enumObj: Record<string, string>, isRequired?: boolean, allowArray?: boolean) => Joi.StringSchema<string> | Joi.AlternativesSchema<any>;
+export declare const objectIdAlternatives: (isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any> | undefined;
+export declare const uuidIdAlternatives: (isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any> | undefined;

package/dist/commonValidator/joiCommonValidator.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uuidIdAlternatives = exports.objectIdAlternatives = exports.enumAlternatives = exports.paginationValidators = void 0;
+const joi_1 = __importDefault(require("joi"));
+exports.paginationValidators = {
+    page: joi_1.default.number().integer().min(1).default(1),
+    limit: joi_1.default.number().integer().min(1).default(10),
+    search: joi_1.default.string().trim(),
+    isPaginate: joi_1.default.boolean().default(true),
+    order: joi_1.default.array().items(joi_1.default.array().items(joi_1.default.string().trim(), joi_1.default.string().trim())),
+    sort: joi_1.default.string()
+        .pattern(/^(-?\\w+(,-?\\w+)*)?$/)
+        .optional()
+        .messages({
+        'string.pattern.base': `"sort" must be a comma-separated list of field names, optionally prefixed with '-' for descending`,
+    }),
+};
+const enumAlternatives = (enumObj, isRequired = false, allowArray = true) => {
+    const base = joi_1.default.string().valid(...Object.values(enumObj));
+    if (allowArray) {
+        const alt = joi_1.default.alternatives().try(base, joi_1.default.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+    return isRequired ? base.required() : base.optional();
+};
+exports.enumAlternatives = enumAlternatives;
+const objectIdAlternatives = (isRequired = false, allowArray = true) => {
+    const base = joi_1.default.string()
+        .pattern(/^[0-9a-fA-F]{24}$/)
+        .message('Invalid ObjectId format');
+    if (allowArray) {
+        const alt = joi_1.default.alternatives().try(base, joi_1.default.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+};
+exports.objectIdAlternatives = objectIdAlternatives;
+const uuidIdAlternatives = (isRequired = false, allowArray = true) => {
+    const base = joi_1.default.string().uuid().message('Invalid Uuid format');
+    if (allowArray) {
+        const alt = joi_1.default.alternatives().try(base, joi_1.default.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+};
+exports.uuidIdAlternatives = uuidIdAlternatives;

package/dist/commonValidator/joiSchemaBuilder.d.ts

@@ -0,0 +1,6 @@
+import Joi from 'joi';
+import { SchemaRules } from '../types/commonType';
+export declare const buildSchema: <TModel extends Record<string, any>, Keys extends keyof TModel & string = keyof TModel & string>(base: Joi.ObjectSchema<TModel>, rules?: SchemaRules<Keys>) => Joi.ObjectSchema<TModel>;
+export default class BaseValidator {
+    protected validate(schema: Joi.ObjectSchema, req: any, options?: Joi.ValidationOptions): void;
+}

package/dist/commonValidator/joiSchemaBuilder.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSchema = void 0;
+const joi_1 = __importDefault(require("joi"));
+const httpStatusCode_1 = require("../constants/httpStatusCode");
+class ApiError extends Error {
+    constructor(statusCode, message, isOperational = true, stack = '') {
+        super(message);
+        this.statusCode = statusCode;
+        this.isOperational = isOperational;
+        if (stack) {
+            this.stack = stack;
+        }
+        else {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+// GENERIC BUILDER
+const buildSchema = (base, rules = {}) => {
+    let schema = base;
+    // REQUIRED
+    if (rules.required) {
+        schema = schema.fork(rules.required, field => field.required());
+    }
+    // OPTIONAL
+    if (rules.optional) {
+        schema = schema.fork(rules.optional, field => field.optional());
+    }
+    // ALLOW NULL
+    if (rules.allowNull) {
+        schema = schema.fork(rules.allowNull, field => field.allow(null));
+    }
+    // FORBIDDEN
+    if (rules.forbidden) {
+        schema = schema.fork(rules.forbidden, field => field.forbidden());
+    }
+    // SINGLE OR ARRAY
+    if (rules.singleOrArray) {
+        schema = schema.fork(rules.singleOrArray, field => joi_1.default.alternatives().try(field, joi_1.default.array().items(field)));
+    }
+    // SINGLE OR ARRAY OR NULL
+    if (rules.singleOrArrayOrNull) {
+        schema = schema.fork(rules.singleOrArrayOrNull, field => joi_1.default.alternatives().try(field, joi_1.default.array().items(field), joi_1.default.valid(null)));
+    }
+    // CUSTOM FIELDS
+    if (rules.customFields) {
+        schema = schema.append(rules.customFields);
+    }
+    return schema;
+};
+exports.buildSchema = buildSchema;
+const defaultOptions = {
+    abortEarly: false,
+    allowUnknown: false,
+};
+class BaseValidator {
+    validate(schema, req, options) {
+        const { error, value } = schema.validate({ ...req.body, ...req.query, ...req.params }, { ...defaultOptions, ...options });
+        if (error) {
+            const errorMessage = error.details.map(d => d.message).join(', ');
+            throw new ApiError(httpStatusCode_1.HTTP_STATUS_CODE.BAD_REQUEST, errorMessage);
+        }
+        req.body = value;
+    }
+}
+exports.default = BaseValidator;

package/dist/configs/env.d.ts

@@ -59,4 +59,6 @@ export declare const ENV_VARIABLE: {
         API_KEY: any;
         ENDPOINT: any;
     };
+    REDIS_HOST: any;
+    DUMMY_EMAIL_DOMAIN: any;
 };

package/dist/configs/env.js

@@ -102,6 +102,8 @@ const envValidation = joi_1.default.object()
     PHONEPE_PASSWORD: joi_1.default.string().optional(),
     GOOGLEPAY_API_KEY: joi_1.default.string().optional(),
     GOOGLEPAY_ENDPOINT: joi_1.default.string().optional(),
+    REDIS_HOST: joi_1.default.string().optional(),
+    DUMMY_EMAIL_DOMAIN: joi_1.default.string().optional(),
 })
     .unknown();
 const { value: envVar, error } = envValidation.prefs({ errors: { label: 'key' } }).validate(process.env);
@@ -170,4 +172,6 @@ exports.ENV_VARIABLE = {
         API_KEY: envVar.GOOGLEPAY_API_KEY,
         ENDPOINT: envVar.GOOGLEPAY_ENDPOINT,
     },
+    REDIS_HOST: envVar.REDIS_HOST,
+    DUMMY_EMAIL_DOMAIN: envVar.DUMMY_EMAIL_DOMAIN,
 };

package/dist/configs/index.d.ts

@@ -1,2 +1,4 @@
 export * from './aws';
 export * from './env';
+export * from './logger';
+export * from './redisConfig';

package/dist/configs/index.js

@@ -16,3 +16,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./aws"), exports);
 __exportStar(require("./env"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./redisConfig"), exports);

package/dist/configs/logger.d.ts

@@ -0,0 +1,2 @@
+import winston from 'winston';
+export declare const logger: winston.Logger;

package/dist/configs/logger.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const winston_1 = __importDefault(require("winston"));
+const winston_daily_rotate_file_1 = __importDefault(require("winston-daily-rotate-file"));
+const env_1 = require("../configs/env");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const enumerateErrorFormat = winston_1.default.format((info) => {
+    if (info.message instanceof Error) {
+        info.message = {
+            message: info.message.message,
+            stack: info.message.stack,
+            ...info.message,
+        };
+    }
+    if (info instanceof Error) {
+        return {
+            // message: info.message,
+            stack: info.stack,
+            ...info,
+        };
+    }
+    return info;
+});
+const transport = new winston_daily_rotate_file_1.default({
+    filename: env_1.ENV_VARIABLE.LOG_FOLDER + env_1.ENV_VARIABLE.LOG_FILE,
+    datePattern: 'YYYY-MM-DD',
+    zippedArchive: true,
+    maxSize: '20m',
+    maxFiles: '3',
+    // prepend: true,
+});
+exports.logger = winston_1.default.createLogger({
+    format: winston_1.default.format.combine(enumerateErrorFormat(), winston_1.default.format.json()),
+    transports: [
+        transport,
+        new winston_1.default.transports.Console({
+            level: 'info',
+        }),
+    ],
+});

package/dist/configs/redisConfig.d.ts

@@ -0,0 +1,4 @@
+import Redis from 'ioredis';
+declare const redisClient: Redis;
+export declare const connectRedis: () => Promise<void>;
+export default redisClient;

package/dist/configs/redisConfig.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectRedis = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const logger_1 = require("./logger");
+const env_1 = require("./env");
+// const redisClient = new Redis(ENV_VARIABLE.REDIS_URL, {
+//     maxRetriesPerRequest: null,
+// });
+const redisClient = new ioredis_1.default({
+    host: env_1.ENV_VARIABLE.REDIS_HOST || 'redis',
+    port: 6379,
+    maxRetriesPerRequest: null,
+});
+redisClient.on('error', err => {
+    console.error('Redis Client Error', err);
+    logger_1.logger.error(err);
+});
+const connectRedis = async () => {
+    // ioredis connects automatically, but we can check the status
+    if (redisClient.status === 'ready')
+        return;
+    return new Promise((resolve, reject) => {
+        redisClient.once('ready', () => resolve());
+        redisClient.once('error', err => reject(err));
+    });
+};
+exports.connectRedis = connectRedis;
+exports.default = redisClient;