@kipicore/dbcore 1.1.16 → 1.1.19

package/dist/helpers/utils.d.ts

@@ -0,0 +1,173 @@
+import Joi from 'joi';
+import { OrderItem } from 'sequelize';
+export declare const pick: <T extends object, K extends keyof T>(objOrArray: T | T[], keys: K[]) => Pick<T, K> | Pick<T, K>[];
+export declare const isValidMongoDbId: Joi.StringSchema<string>;
+export declare const omit: <T extends object, K extends keyof T>(objOrArray: T | T[], keys: K[]) => Omit<T, K> | Omit<T, K>[];
+export declare const ensureDirectoryExists: (directory: string) => void;
+export declare const generateOtp: (length?: number) => string;
+export declare const generateAlphaNumericCode: (length?: number) => string;
+export declare const generateTempPassword: (length?: number) => string;
+type UniqueByFields<T> = (array: T[], fields: (keyof T)[]) => T[];
+export declare const getUniqueArrayByFields: UniqueByFields<any>;
+export declare const keyByFieldOrFields: <T>(array: T[], fields: keyof T | (keyof T)[]) => Record<string, T>;
+/**
+ * Groups an array of objects by a specified field or multiple fields.
+ *
+ * @param array - The array of objects to group.
+ * @param fields - A single field or an array of fields to group by.
+ * @returns An object where keys are the grouped field values and values are arrays of grouped objects.
+ */
+export declare function groupByFieldOrFields<T>(array: T[], fields: keyof T | (keyof T)[]): Record<string, T[]>;
+export declare const isTimeWithinRange: (time: Date, rangeStart: Date, rangeEnd: Date) => boolean;
+export declare const isDateWithinRange: (date: Date | string, rangeStart: Date | string, rangeEnd: Date | string) => boolean;
+export declare const startOfDay: (date: string | Date) => Date;
+export declare const generateUuidToNumber: (uuid1?: string) => string;
+export declare const endOfDay: (date: string | Date) => Date;
+type GroupByFields<T> = (array: T[], fields: keyof T | (keyof T)[]) => Record<string, T[]>;
+export declare const groupByFields: GroupByFields<any>;
+type SortOrder = 'asc' | 'desc';
+interface SortField<T> {
+    key: keyof T;
+    order?: SortOrder;
+}
+/**
+ * Sorts an array of objects based on specified fields and order.
+ *
+ * @param array - The array to be sorted.
+ * @param fields - A single sort field or an array of sort fields.
+ * @returns A new sorted array.
+ */
+export declare const sortArray: <T>(array: T[], fields: SortField<T> | SortField<T>[]) => T[];
+/**
+ * Gets all nested children for a given parent ID.
+ *
+ * @param array - Array of nodes representing the flat hierarchy.
+ * @param parentIds - The ID of the parent node.
+ * @param parentIdKey - The key used to reference the parent ID.
+ * @returns A flattened list of all children.
+ */
+export declare const getChildrenByParentId: <T extends Record<string, any>>(array: T[], parentIds: string | string[], parentIdKey: keyof T) => T[];
+/**
+ * Gets all nested children for a given parent ID.
+ *
+ * @param array - Array of nodes representing the flat hierarchy.
+ * @param childIds - The ID of the parent node.
+ * @param parentIdKey - The key used to reference the parent ID..
+ * @returns A flattened list of all parents.
+ */
+export declare const getParentsByChildrenId: <T extends Record<string, any>>(array: T[], childIds: string | string[], parentIdKey: keyof T) => T[];
+/**
+ * Builds a nested structure from a flat array of items based on a parent-child relationship.
+ *
+ * @param items - The array of items that need to be organized.
+ * @param parentIdKey - The key that refers to the parent ID in each item.
+ * @param nestedListKey - The key that will store the nested child items for each parent.
+ *
+ * @returns An array of root-level items, each containing its nested children in the `nestedListKey`.
+ */
+export declare const buildNestedStructure: <T extends Record<string, any>>(items: T[], parentIdKey: keyof T, nestedListKey: string) => T[];
+/**
+ * Flattens a nested structure into a flat array while preserving the parent-child relationship.
+ *
+ * @param items - The nested array of items to be flattened.
+ * @param parentIdKey - The key that will store the parent ID in each flattened item.
+ * @param nestedListKey - The key that contains the nested child items.
+ *
+ * @returns A flat array of items, each containing a reference to its parent ID.
+ */
+export declare const flattenNestedStructure: <T extends Record<string, any>>(items: T[], parentIdKey: keyof T, nestedListKey: string) => Omit<T, typeof nestedListKey>[];
+/**
+ * Removes all falsy values from an object.
+ *
+ * A falsy value in JavaScript/TypeScript includes:
+ * - false
+ * - 0 (zero)
+ * - "" (empty string)
+ * - null
+ * - undefined
+ * - NaN (Not-a-Number)
+ *
+ * This function iterates through the object's properties and removes any key-value pairs
+ * where the value is falsy. Only truthy values remain in the final object.
+ *
+ * @param obj - The input object containing key-value pairs.
+ * @returns A new object with all falsy values removed.
+ *
+ * @example
+ * const data = {
+ *   name: "Alice",
+ *   age: 25,
+ *   isAdmin: false,
+ *   score: 0,
+ *   city: "",
+ *   country: "USA",
+ *   email: null,
+ *   phone: undefined,
+ *   balance: NaN,
+ * };
+ *
+ * const cleanedData = removeFalsyValues(data);
+ * console.log(cleanedData);
+ * // Output: { name: 'Alice', age: 25, country: 'USA' }
+ */
+export declare const removeFalsyValues: <T extends Record<string, any>>(obj: T) => Partial<T>;
+export declare const isValidUUID: (id: string, expectedVersion?: 1 | 4) => boolean;
+/**
+ * Parses ordering input and returns Sequelize-compatible order array.
+ *
+ * @param inputOrder - Array like [["columnName", "ASC"], ...]
+ * @param defaultOrder - Fallback or additional default order (e.g. [['createdAt', 'DESC']])
+ */
+export declare const parseOrderOptions: (inputOrder: unknown, defaultOrder?: OrderItem[]) => OrderItem[];
+import { IInstituteAttributes } from '../interfaces/instituteInterface.js';
+import { IUserAttributes } from '../interfaces/userInterface.js';
+import { TAeraModelCreationAttributes } from '../types/areaType.js';
+export declare const capitalizeFirst: (str: string) => string;
+export declare const normalizeToArray: (value: string | string[] | undefined) => string[] | undefined;
+/**
+ * Converts a snake_case string to Normal Text
+ * @param {string} input - The snake_case string
+ * @returns {string} - The converted Normal Text
+ */
+export declare const fromSnakeCaseToNormalText: (input: string) => string;
+export declare function slugify(text: string): string;
+export declare function assignNonNull<T extends Record<string, any>>(target: T, source: Record<string, any>): void;
+export declare function isUserSchoolInfoUpdate(institute: IInstituteAttributes, reqUser: IUserAttributes & {
+    isAddDetails?: boolean;
+}): boolean;
+export declare function chunkArray<T>(array: T[], size: number): T[][];
+/**
+ * Prepares userdata for EJS template based on dynamic columns config.
+ * @param data Array of objects
+ * @param columnsConfig Array of columns with { title, field }
+ * @returns { userdata: any[], columns: string[] }
+ */
+export declare function extractFromObject(data: any[], config: {
+    tableTitle: string;
+    columns: {
+        title: string;
+        field: string;
+    }[];
+}): {
+    tableTitle: string;
+    userdata: any[];
+    columns: 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;
+export declare const customPagination: (data: any[], page: number, limit: number, totalRecords: number) => Promise<{
+    limit: number;
+    totalRecords: number;
+    totalPages: number;
+    hasPreviousPage: boolean;
+    currentPage: number;
+    hasNextPage: boolean;
+    recordList: any[];
+}>;
+export declare const generateHmacSHA256: (data: string, secret: string) => string;
+export declare const verifyHmacSHA256: (data: string, secret: string, signature: string) => boolean;
+export declare const generateVoucherCode: (format?: string) => string;
+export declare const getCityAreas: (cityName?: string) => Promise<Partial<TAeraModelCreationAttributes>[]>;
+export declare const getNextLetter: (current: string) => string;
+export {};

package/dist/models/psql/userPayoutModel.js

@@ -0,0 +1,301 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+const index_js_1 = require("./index.js");
+const app_js_1 = require("../../constants/app.js");
+const userModel_js_1 = __importDefault(require("./userModel.js"));
+const instituteModel_js_1 = __importDefault(require("./instituteModel.js"));
+const date_fns_1 = require("date-fns");
+const utils_js_1 = require("../../helpers/utils.js");
+const subjectHasPayFeeHistoryModel_js_1 = __importDefault(require("./subjectHasPayFeeHistoryModel.js"));
+const lectureModel_js_1 = __importDefault(require("./lectureModel.js"));
+const attendanceModel_js_1 = __importDefault(require("../mongodb/attendanceModel.js"));
+const userPayoutDetailsModel_js_1 = __importDefault(require("./userPayoutDetailsModel.js"));
+class UserPayoutModel extends sequelize_1.Model {
+}
+UserPayoutModel.init({
+    id: {
+        type: sequelize_1.DataTypes.UUID,
+        defaultValue: sequelize_1.DataTypes.UUIDV4,
+        allowNull: false,
+        primaryKey: true,
+    },
+    userId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+        field: 'user_id',
+    },
+    userType: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: Object.values(app_js_1.USER_TYPES),
+        allowNull: false,
+        field: 'user_type',
+    },
+    instituteId: {
+        type: sequelize_1.DataTypes.UUID,
+        allowNull: false,
+        field: 'institute_id',
+    },
+    totalPayableAmount: {
+        type: sequelize_1.DataTypes.FLOAT,
+        allowNull: true,
+        defaultValue: 0,
+        field: 'total_payable_amount',
+    },
+    totalPaidAmount: {
+        type: sequelize_1.DataTypes.FLOAT,
+        allowNull: true,
+        defaultValue: 0,
+        field: 'total_paid_amount',
+    },
+    type: {
+        type: sequelize_1.DataTypes.ENUM,
+        values: Object.values(app_js_1.USER_PAYOUT_TYPE),
+        allowNull: false,
+    },
+    lastCalculatedAt: {
+        type: sequelize_1.DataTypes.DATE,
+        defaultValue: (0, date_fns_1.startOfToday)(),
+        field: 'last_calculated_at',
+    },
+}, {
+    modelName: 'UserPayoutModel',
+    tableName: 'user_payouts',
+    timestamps: true,
+    sequelize: index_js_1.sequelize,
+});
+UserPayoutModel.belongsTo(userModel_js_1.default, {
+    foreignKey: {
+        name: 'createdBy',
+        allowNull: true,
+        field: 'created_by',
+    },
+    as: 'createdByUser',
+});
+UserPayoutModel.belongsTo(userModel_js_1.default, {
+    foreignKey: {
+        name: 'updatedBy',
+        allowNull: true,
+        field: 'updated_by',
+    },
+    as: 'updatedByUser',
+});
+UserPayoutModel.belongsTo(userModel_js_1.default, {
+    foreignKey: {
+        name: 'deletedBy',
+        allowNull: true,
+        field: 'deleted_by',
+    },
+    as: 'deletedByUser',
+});
+UserPayoutModel.belongsTo(instituteModel_js_1.default, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'institute',
+});
+instituteModel_js_1.default.hasMany(UserPayoutModel, {
+    foreignKey: {
+        name: 'instituteId',
+    },
+    as: 'instituteHasPayoutList',
+});
+UserPayoutModel.belongsTo(userModel_js_1.default, {
+    foreignKey: {
+        name: 'userId',
+    },
+    as: 'user',
+});
+userModel_js_1.default.hasMany(UserPayoutModel, {
+    foreignKey: {
+        name: 'userId',
+    },
+    as: 'userHasPayoutList',
+});
+const afterCreateOrUpdateHook = async (userPayout, user = null, transaction, filterOptions = {}) => {
+    try {
+        if (!userPayout.userPayoutDetailsList || !userPayout.userPayoutDetailsList.length)
+            return userPayout;
+        userPayout.userPayoutDetailsList = (0, utils_js_1.getUniqueArrayByFields)(userPayout.userPayoutDetailsList, ['subjectId']);
+        const options = {
+            transaction,
+        };
+        if (user)
+            options.userId = user.id;
+        const now = new Date();
+        const previousMonthDate = (0, date_fns_1.subMonths)(now, 1);
+        let startOfPreviousMonth = (0, date_fns_1.startOfMonth)(previousMonthDate).toISOString();
+        let endOfPreviousMonth = (0, date_fns_1.endOfMonth)(previousMonthDate).toISOString();
+        if (filterOptions.include) {
+            filterOptions.include = !Array.isArray(filterOptions.include) ? [filterOptions.include] : filterOptions.include;
+            const historyListInclude = filterOptions.include.find((include) => include.as === 'userPayoutHistoryList');
+            let where = {};
+            if (historyListInclude && historyListInclude.where && historyListInclude.where[sequelize_1.Op.and]) {
+                where = historyListInclude.where[sequelize_1.Op.and].pop();
+            }
+            if (where.payout_start_time && where.payout_end_time) {
+                startOfPreviousMonth = where.payout_start_time[sequelize_1.Op.gte];
+                endOfPreviousMonth = where.payout_end_time[sequelize_1.Op.lte];
+            }
+        }
+        const attendanceWhereAnd = [{ date: { $gte: startOfPreviousMonth } }, { date: { $lte: endOfPreviousMonth } }];
+        const exsitUserPayout = (await UserPayoutModel.findOne({
+            where: { id: userPayout.id },
+            include: [{ association: 'userPayoutDetailsList' }],
+            transaction,
+        }));
+        if (!exsitUserPayout)
+            return userPayout;
+        if (userPayout.type === app_js_1.USER_PAYOUT_TYPE.PERCENTAGE) {
+            let feeTotalBySubjectList = await subjectHasPayFeeHistoryModel_js_1.default.findAll({
+                where: {
+                    instituteId: exsitUserPayout.instituteId,
+                    subjectId: {
+                        [sequelize_1.Op.in]: userPayout.userPayoutDetailsList.map(userPayoutDetails => userPayoutDetails.subjectId),
+                    },
+                },
+                attributes: [
+                    ['subject_id', 'subjectId'],
+                    [sequelize_1.Sequelize.fn('sum', sequelize_1.Sequelize.col('amount')), 'amount'],
+                ],
+                group: ['subject_id', 'created_at'],
+                raw: true,
+            });
+            feeTotalBySubjectList = JSON.parse(JSON.stringify(feeTotalBySubjectList));
+            userPayout.userPayoutDetailsList = userPayout.userPayoutDetailsList.map(oneUserPayoutDetails => {
+                oneUserPayoutDetails.payableAmount = feeTotalBySubjectList
+                    .filter(feeTotalBySubject => feeTotalBySubject.subjectId === oneUserPayoutDetails.subjectId)
+                    .reduce((sum, record) => {
+                    if (oneUserPayoutDetails.percentage) {
+                        const amount = ((record.amount || 0) * oneUserPayoutDetails.percentage) / 100;
+                        return sum + parseFloat(amount.toFixed(2)); // Add fixed precision and convert back to number
+                    }
+                    return sum;
+                }, 0);
+                return oneUserPayoutDetails;
+            });
+        }
+        if (userPayout.type === app_js_1.USER_PAYOUT_TYPE.HOURLY) {
+            let lectureList = (await lectureModel_js_1.default.findAll({
+                where: {
+                    instituteId: exsitUserPayout.instituteId,
+                    subject: {
+                        [sequelize_1.Op.in]: userPayout.userPayoutDetailsList.map(userPayoutDetails => userPayoutDetails.subjectId),
+                    },
+                    [sequelize_1.Op.or]: [{ primaryUserId: exsitUserPayout.userId }, { secondaryUserId: exsitUserPayout.userId }],
+                },
+                include: [{ association: 'workingDay' }],
+            }));
+            lectureList = JSON.parse(JSON.stringify(lectureList));
+            const currentMonthAttendenceList = await attendanceModel_js_1.default.find({
+                $and: attendanceWhereAnd,
+                userType: userPayout.userType,
+                'users.userId': userPayout.userId,
+                'users.status': { $ne: app_js_1.ATTENDANCE_STATUS.ABSENT },
+            });
+            userPayout.userPayoutDetailsList = userPayout.userPayoutDetailsList.map(oneUserPayoutDetails => {
+                let totalMinutes = 0;
+                currentMonthAttendenceList.forEach(attendance => {
+                    const dayName = (0, date_fns_1.format)(attendance.date, 'EEEE');
+                    const attendanceDayLectureBySubjectList = lectureList.filter(lecture => {
+                        return lecture.workingDay.dayName === dayName && lecture.subject === oneUserPayoutDetails.subjectId;
+                    });
+                    if (attendanceDayLectureBySubjectList.length) {
+                        totalMinutes += attendanceDayLectureBySubjectList.reduce((sum, record) => {
+                            return sum + record.slotDuration;
+                        }, 0);
+                    }
+                });
+                oneUserPayoutDetails.payableAmount = ((oneUserPayoutDetails.amountPerHour || 0) / app_js_1.SIXTY) * totalMinutes;
+                return oneUserPayoutDetails;
+            });
+        }
+        const userPayoutDetailsList = [];
+        for (let userPayoutDetails of userPayout.userPayoutDetailsList) {
+            userPayoutDetails.userPayoutId = exsitUserPayout.id;
+            userPayoutDetails.userId = exsitUserPayout.userId;
+            userPayoutDetails.instituteId = exsitUserPayout.instituteId;
+            userPayoutDetails.type = exsitUserPayout.type;
+            const found = exsitUserPayout?.userPayoutDetailsList?.find(exsitUserPayoutDetails => userPayoutDetails.userPayoutId === exsitUserPayout.id &&
+                userPayoutDetails.instituteId === exsitUserPayoutDetails.instituteId &&
+                userPayoutDetails.userId === exsitUserPayoutDetails.userId &&
+                userPayoutDetails.type === exsitUserPayoutDetails.type &&
+                userPayoutDetails.subjectId === exsitUserPayoutDetails.subjectId &&
+                userPayoutDetails.batchId === exsitUserPayoutDetails.batchId);
+            if (found) {
+                await userPayoutDetailsModel_js_1.default.update(userPayoutDetails, {
+                    where: { id: found.id },
+                    ...options,
+                });
+            }
+            else {
+                userPayoutDetails = (await userPayoutDetailsModel_js_1.default.create(userPayoutDetails, options));
+            }
+            userPayoutDetailsList.push(userPayoutDetails);
+        }
+        if (userPayoutDetailsList.length) {
+            await userPayoutDetailsModel_js_1.default.destroy({
+                where: {
+                    id: {
+                        [sequelize_1.Op.notIn]: userPayoutDetailsList.map(userPayoutDetails => userPayoutDetails.id),
+                    },
+                    userPayoutId: exsitUserPayout.id,
+                },
+                ...options,
+            });
+        }
+        const totalPayableAmount = userPayoutDetailsList.reduce((sum, record) => {
+            return sum + record.payableAmount || 0;
+        }, 0);
+        //this is updatating payble amount so comment it .
+        // await this.update({ id: exsitUserPayout.id }, { totalPayableAmount, lastCalculatedAt: startOfToday() }, options);
+        userPayout.userPayoutDetailsList = userPayoutDetailsList;
+        userPayout.totalPayableAmount = totalPayableAmount;
+        return userPayout;
+    }
+    catch (err) {
+        throw err;
+    }
+};
+const afterFindHook = async (userPayoutList, options = {}) => {
+    const afterFindHookTransaction = await index_js_1.sequelize.transaction();
+    try {
+        const syncUserPayoutList = JSON.parse(JSON.stringify(userPayoutList));
+        if (!syncUserPayoutList.length) {
+            await afterFindHookTransaction.commit();
+            return userPayoutList;
+        }
+        const updatedData = [];
+        for (let syncUserPayout of syncUserPayoutList) {
+            syncUserPayout = await afterCreateOrUpdateHook(JSON.parse(JSON.stringify(syncUserPayout)), undefined, afterFindHookTransaction, options);
+            updatedData.push(syncUserPayout);
+        }
+        userPayoutList = userPayoutList.map((userPayout) => {
+            const found = updatedData.find(one => one.id === userPayout.id);
+            if (found) {
+                userPayout.totalPayableAmount = found.totalPayableAmount;
+                userPayout.userPayoutDetailsList = found.userPayoutDetailsList;
+            }
+            return userPayout;
+        });
+        await afterFindHookTransaction.commit();
+        return userPayoutList;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (err) {
+        await afterFindHookTransaction.rollback();
+        return userPayoutList;
+    }
+};
+UserPayoutModel.addHook('afterFind', async (result, options) => {
+    if (options.syncUserPayoutLastCalculatedAt && Array.isArray(result)) {
+        result = (await afterFindHook(result, options));
+    }
+    else if (options.syncUserPayoutLastCalculatedAt && result) {
+        result = (await afterFindHook([result], options)).pop();
+    }
+});
+exports.default = UserPayoutModel;

package/package.json

@@ -1,23 +1,24 @@
 {
     "name": "@kipicore/dbcore",
-    "version": "1.1.16",
+    "version": "1.1.19",
     "description": "Reusable DB core package with Postgres, MongoDB, models, services, interfaces, and types",
-    "type": "module",
-    "main": "./dist/cjs/index.cjs",
-    "module": "./dist/esm/index.js",
+    "types": "dist/index.d.ts",
+    "main": "dist/index.js",
+    "type": "commonjs",
     "exports": {
         ".": {
-            "import": "./dist/esm/index.js",
-            "require": "./dist/cjs/index.js"
+            "types": "./dist/index.d.ts",
+            "require": "./dist/index.js",
+            "import": "./dist/index.js"
         }
     },
-    "types": "./dist/index.d.ts",
     "scripts": {
         "clean": "rm -rf dist",
         "generate:index": "node scripts/generate-index.js",
-        "build:cjs": "tsc -p tsconfig.cjs.json",
-        "build:esm": "tsc -p tsconfig.esm.json",
-        "build": "npm run clean && npm run generate:index && npm run build:cjs && npm run build:esm"
+        "build": "tsc -p tsconfig.json",
+        "prebuild": "npm run clean && npm run generate:index",
+        "lint": "eslint \"src/**/*.ts\"",
+        "test": "npm run build && tsd"
     },
     "keywords": [
         "postgres",
@@ -51,9 +52,8 @@
         "prettier": "^3.3.3"
     },
     "files": [
-        "dist"
-    ],
-    "engines": {
-        "node": ">=20.16.0"
-    }
+        "dist",
+        "README.md",
+        "LICENSE"
+    ]
 }