@kipicore/dbcore 1.1.5 → 1.1.8

package/dist/models/psql/feeHistoryModel.js

@@ -28,49 +28,49 @@ FeeHistoryModel.init({
     },
     instituteId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "institute_id",
+        field: 'institute_id',
         allowNull: false,
     },
     pdfId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "pdf_id",
+        field: 'pdf_id',
         allowNull: true,
     },
     invoiceId: {
         type: sequelize_1.DataTypes.INTEGER,
-        field: "invoice_id",
+        field: 'invoice_id',
         defaultValue: null,
         allowNull: true,
     },
     userId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "user_id",
+        field: 'user_id',
         allowNull: false,
     },
     feeCollectionId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "fee_collection_id",
+        field: 'fee_collection_id',
         allowNull: true,
     },
     parentHistoryId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "parent_history_id",
+        field: 'parent_history_id',
         allowNull: true,
     },
     bankAccountId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "bank_account_id",
+        field: 'bank_account_id',
         allowNull: true,
     },
     feeTypeId: {
         type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.STRING),
         defaultValue: [],
-        field: "fee_type_id",
+        field: 'fee_type_id',
         allowNull: true,
     },
     schoolFeeCollectionId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "school_fee_collection_id",
+        field: 'school_fee_collection_id',
         allowNull: true,
     },
     // academicCalendarId: {
@@ -112,136 +112,136 @@ FeeHistoryModel.init({
         allowNull: true,
     },
 }, {
-    modelName: "FeeHistoryModel",
-    tableName: "fee_history",
+    modelName: 'FeeHistoryModel',
+    tableName: 'fee_history',
     timestamps: true,
     sequelize: index_js_1.sequelize,
 });
 FeeHistoryModel.belongsTo(feesCollectionModel_js_1.default, {
     foreignKey: {
-        name: "feeCollectionId",
-        field: "fee_collection_id",
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
         allowNull: true,
     },
-    as: "feeHistoryFeeCollection",
+    as: 'feeHistoryFeeCollection',
 });
 feesCollectionModel_js_1.default.hasMany(FeeHistoryModel, {
     foreignKey: {
-        name: "feeCollectionId",
-        field: "fee_collection_id",
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
         allowNull: true,
     },
-    as: "feeCollectionHasFeeHistory",
+    as: 'feeCollectionHasFeeHistory',
 });
 FeeHistoryModel.belongsTo(fileStorageModel_js_1.default, {
     foreignKey: {
-        name: "pdfId",
-        field: "pdf_id",
+        name: 'pdfId',
+        field: 'pdf_id',
         allowNull: true,
     },
-    as: "feeHistoryFile",
+    as: 'feeHistoryFile',
 });
 fileStorageModel_js_1.default.hasMany(FeeHistoryModel, {
     foreignKey: {
-        name: "pdfId",
-        field: "pdf_id",
+        name: 'pdfId',
+        field: 'pdf_id',
         allowNull: true,
     },
-    as: "filesHasFeeHistory",
+    as: 'filesHasFeeHistory',
 });
 FeeHistoryModel.belongsTo(bankAccountDetailsModel_js_1.default, {
     foreignKey: {
-        name: "bankAccountId",
-        field: "bank_account_id",
+        name: 'bankAccountId',
+        field: 'bank_account_id',
         allowNull: true,
     },
-    as: "feeHistoryAccount",
+    as: 'feeHistoryAccount',
 });
 bankAccountDetailsModel_js_1.default.hasMany(FeeHistoryModel, {
     foreignKey: {
-        name: "bankAccountId",
-        field: "bank_account_id",
+        name: 'bankAccountId',
+        field: 'bank_account_id',
         allowNull: true,
     },
-    as: "feeHistoryHasAccount",
+    as: 'feeHistoryHasAccount',
 });
 FeeHistoryModel.belongsTo(FeeHistoryModel, {
     foreignKey: {
-        name: "parentHistoryId",
-        field: "parent_history_id",
+        name: 'parentHistoryId',
+        field: 'parent_history_id',
         allowNull: true,
     },
-    as: "feeHistory",
+    as: 'feeHistory',
 });
 FeeHistoryModel.hasMany(FeeHistoryModel, {
     foreignKey: {
-        name: "parentHistoryId",
-        field: "parent_history_id",
+        name: 'parentHistoryId',
+        field: 'parent_history_id',
         allowNull: true,
     },
-    as: "feeHistoryHas",
+    as: 'feeHistoryHas',
 });
 FeeHistoryModel.belongsTo(schoolFeeCollectionModel_js_1.default, {
     foreignKey: {
-        name: "schoolFeeCollectionId",
-        field: "school_fee_collection_id",
+        name: 'schoolFeeCollectionId',
+        field: 'school_fee_collection_id',
         allowNull: true,
     },
-    as: "feeHistorySchool",
+    as: 'feeHistorySchool',
 });
 schoolFeeCollectionModel_js_1.default.hasMany(FeeHistoryModel, {
     foreignKey: {
-        name: "schoolFeeCollectionId",
-        field: "school_fee_collection_id",
+        name: 'schoolFeeCollectionId',
+        field: 'school_fee_collection_id',
         allowNull: true,
     },
-    as: "feeHistoryHasSchool",
+    as: 'feeHistoryHasSchool',
 });
 FeeHistoryModel.belongsTo(instituteModel_js_1.default, {
     foreignKey: {
-        name: "instituteId",
-        field: "institute_id",
+        name: 'instituteId',
+        field: 'institute_id',
     },
-    as: "feeHistoryInstitute",
+    as: 'feeHistoryInstitute',
 });
 instituteModel_js_1.default.hasMany(FeeHistoryModel, {
-    foreignKey: "instituteId",
-    as: "instituteHasFeeHistory",
+    foreignKey: 'instituteId',
+    as: 'instituteHasFeeHistory',
 });
 FeeHistoryModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "userId",
-        field: "user_id",
+        name: 'userId',
+        field: 'user_id',
     },
-    as: "feeHistoryUser",
+    as: 'feeHistoryUser',
 });
 userModel_js_1.default.hasMany(FeeHistoryModel, {
-    foreignKey: "userId",
-    as: "userHasFeeHistory",
+    foreignKey: 'userId',
+    as: 'userHasFeeHistory',
 });
 FeeHistoryModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "createdBy",
+        name: 'createdBy',
         allowNull: true,
-        field: "created_by",
+        field: 'created_by',
     },
-    as: "createdByUser",
+    as: 'createdByUser',
 });
 FeeHistoryModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "updatedBy",
+        name: 'updatedBy',
         allowNull: true,
-        field: "updated_by",
+        field: 'updated_by',
     },
-    as: "updatedByUser",
+    as: 'updatedByUser',
 });
 FeeHistoryModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "deletedBy",
+        name: 'deletedBy',
         allowNull: true,
-        field: "deleted_by",
+        field: 'deleted_by',
     },
-    as: "deletedByUser",
+    as: 'deletedByUser',
 });
 const subjectWiserFeePay = async (instituteId, feeCollectionId, paidFee, userId) => {
     try {
@@ -259,12 +259,12 @@ const subjectWiserFeePay = async (instituteId, feeCollectionId, paidFee, userId)
             },
             include: [
                 {
-                    association: "entityType",
+                    association: 'entityType',
                     where: { sequence: app_js_1.INSTITUTE_ENTITY_TYPE_SEQUENCE.LAST },
                 },
             ],
         });
-        const subjectIds = subjects.map((subject) => subject.id);
+        const subjectIds = subjects.map(subject => subject.id);
         const fees = await userHasSubjectFeeModel_js_1.default.findAll({
             where: {
                 subjectId: { [sequelize_1.Op.in]: subjectIds },
@@ -276,7 +276,7 @@ const subjectWiserFeePay = async (instituteId, feeCollectionId, paidFee, userId)
             throw new Error(errorMessages_js_1.FEESCOLLECTION_ERROR_MESSAGES.NOT_FOUND);
         }
         // const totalFeeAmount = Number(fees.reduce((total, fee) => total + fee.fee, 0));
-        const feeDistribution = fees.map((fee) => {
+        const feeDistribution = fees.map(fee => {
             const subjectPaidFee = (fee.fee / (feeCollection.feeAmount || 0)) * paidFee;
             return {
                 subjectId: fee.subjectId,
@@ -326,8 +326,7 @@ const beforeCreateOrUpdateHook = async (feeCollection) => {
                 throw new Error(errorMessages_js_1.FILE_STORAGE_ERROR_MESSAGES.NOT_FOUND);
         }
     }
-    if ((!feeCollection.feeTypeId || feeCollection.feeTypeId.length === 0) &&
-        !feeCollection.bankAccountId)
+    if ((!feeCollection.feeTypeId || feeCollection.feeTypeId.length === 0) && !feeCollection.bankAccountId)
         await subjectWiserFeePay(feeCollection.instituteId, feeCollection.feeCollectionId, feeCollection.paidFee, feeCollection.userId);
 };
 FeeHistoryModel.beforeCreate(beforeCreateOrUpdateHook);

package/dist/models/psql/feeReminderModel.d.ts

@@ -1,6 +1,6 @@
-import { Model } from "sequelize";
-import { IFeeReminderModelAttributes } from "../../interfaces/feeReminderInterface.js";
-import { TFeeReminderModelCreationAttributes } from "../../types/feeReminderType.js";
+import { Model } from 'sequelize';
+import { IFeeReminderModelAttributes } from '../../interfaces/feeReminderInterface.js';
+import { TFeeReminderModelCreationAttributes } from '../../types/feeReminderType.js';
 declare class FeeReminderModel extends Model<IFeeReminderModelAttributes, TFeeReminderModelCreationAttributes> {
     id: string;
     userId: string;

package/dist/models/psql/feeReminderModel.js

@@ -33,7 +33,7 @@ FeeReminderModel.init({
     sendDate: {
         type: sequelize_1.DataTypes.DATE,
         allowNull: false,
-        defaultValue: sequelize_1.Sequelize.literal("CURRENT_TIMESTAMP"),
+        defaultValue: sequelize_1.Sequelize.literal('CURRENT_TIMESTAMP'),
     },
     dueDate: {
         type: sequelize_1.DataTypes.DATE,
@@ -61,78 +61,78 @@ FeeReminderModel.init({
         allowNull: false,
     },
 }, {
-    modelName: "FeeReminderModel",
-    tableName: "fee_reminders",
+    modelName: 'FeeReminderModel',
+    tableName: 'fee_reminders',
     timestamps: true,
     sequelize: index_js_1.sequelize,
 });
 FeeReminderModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "userId",
-        field: "user_id",
+        name: 'userId',
+        field: 'user_id',
     },
-    as: "reminderUser",
+    as: 'reminderUser',
 });
 userModel_js_1.default.hasMany(FeeReminderModel, {
-    foreignKey: "userId",
-    as: "userReminders",
+    foreignKey: 'userId',
+    as: 'userReminders',
 });
 FeeReminderModel.belongsTo(feeReminderSettingModel_js_1.default, {
     foreignKey: {
-        name: "templateId",
-        field: "template_id",
+        name: 'templateId',
+        field: 'template_id',
     },
-    as: "reminderTemplate",
+    as: 'reminderTemplate',
 });
 feeReminderSettingModel_js_1.default.hasMany(FeeReminderModel, {
-    foreignKey: "templateId",
-    as: "TemplateReminders",
+    foreignKey: 'templateId',
+    as: 'TemplateReminders',
 });
 FeeReminderModel.belongsTo(instituteModel_js_1.default, {
     foreignKey: {
-        name: "instituteId",
-        field: "institute_id",
+        name: 'instituteId',
+        field: 'institute_id',
     },
-    as: "reminderInstitute",
+    as: 'reminderInstitute',
 });
 instituteModel_js_1.default.hasMany(FeeReminderModel, {
-    foreignKey: "instituteId",
-    as: "instituteReminders",
+    foreignKey: 'instituteId',
+    as: 'instituteReminders',
 });
 FeeReminderModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "createdBy",
+        name: 'createdBy',
         allowNull: true,
-        field: "created_by",
+        field: 'created_by',
     },
-    as: "createdByUser",
+    as: 'createdByUser',
 });
 FeeReminderModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "updatedBy",
+        name: 'updatedBy',
         allowNull: true,
-        field: "updated_by",
+        field: 'updated_by',
     },
-    as: "updatedByUser",
+    as: 'updatedByUser',
 });
 FeeReminderModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "deletedBy",
+        name: 'deletedBy',
         allowNull: true,
-        field: "deleted_by",
+        field: 'deleted_by',
     },
-    as: "deletedByUser",
+    as: 'deletedByUser',
 });
 FeeReminderModel.belongsTo(feesCollectionModel_js_1.default, {
     foreignKey: {
-        name: "feeCollectionId",
-        field: "fee_collection_id",
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
     },
-    as: "feeCollection",
+    as: 'feeCollection',
 });
 feesCollectionModel_js_1.default.hasMany(FeeReminderModel, {
-    foreignKey: "feeCollectionId",
-    as: "feeReminders",
+    foreignKey: 'feeCollectionId',
+    as: 'feeReminders',
 });
 const beforeCreateHook = async (feeReminder) => {
     if (feeReminder.userId && feeReminder.batchId && feeReminder.instituteId) {

package/dist/models/psql/feesCollectionModel.d.ts

@@ -1,7 +1,7 @@
-import { Model } from "sequelize";
-import { IFeesCollectionModelAttributes } from "../../interfaces/feesCollectionInterface.js";
-import { TFeesCollectionModelCreationAttributes } from "../../types/feesCollectionType.js";
-import { FEE_PAYMENT_STATUS, PAYMENT_TYPE } from "../../constants/app.js";
+import { Model } from 'sequelize';
+import { IFeesCollectionModelAttributes } from '../../interfaces/feesCollectionInterface.js';
+import { TFeesCollectionModelCreationAttributes } from '../../types/feesCollectionType.js';
+import { FEE_PAYMENT_STATUS, PAYMENT_TYPE } from '../../constants/app.js';
 declare class FeesCollectionModel extends Model<IFeesCollectionModelAttributes, TFeesCollectionModelCreationAttributes> {
     id: string;
     date: Date;

package/dist/models/psql/feesCollectionModel.js

@@ -22,7 +22,7 @@ FeesCollectionModel.init({
     },
     date: {
         type: sequelize_1.DataTypes.DATE,
-        defaultValue: sequelize_1.Sequelize.literal("CURRENT_TIMESTAMP"),
+        defaultValue: sequelize_1.Sequelize.literal('CURRENT_TIMESTAMP'),
         allowNull: true,
     },
     dueDate: {
@@ -69,7 +69,7 @@ FeesCollectionModel.init({
     },
     academicCalendarId: {
         type: sequelize_1.DataTypes.UUID,
-        field: "academic_calendar_id",
+        field: 'academic_calendar_id',
         allowNull: false,
     },
     userId: {
@@ -82,13 +82,13 @@ FeesCollectionModel.init({
     },
     isLeft: {
         type: sequelize_1.DataTypes.BOOLEAN,
-        field: "is_left",
+        field: 'is_left',
         defaultValue: false,
         allowNull: true,
     },
 }, {
-    modelName: "FeesCollectionModel",
-    tableName: "fees_collections",
+    modelName: 'FeesCollectionModel',
+    tableName: 'fees_collections',
     timestamps: true,
     sequelize: index_js_1.sequelize,
 });
@@ -106,8 +106,7 @@ const beforeCreateOrUpdateHook = async (feeCollection) => {
         else {
             existingRecord = await FeesCollectionModel.findByPk(feeCollection.id);
         }
-        if (existingRecord?.status === app_js_1.FEE_PAYMENT_STATUS.COMPLETED &&
-            feeCollection.paidFee) {
+        if (existingRecord?.status === app_js_1.FEE_PAYMENT_STATUS.COMPLETED && feeCollection.paidFee) {
             throw new Error(errorMessages_js_1.FEESCOLLECTION_ERROR_MESSAGES.FEE_PAID);
         }
     }
@@ -158,75 +157,75 @@ FeesCollectionModel.beforeBulkUpdate(async (options) => {
 });
 FeesCollectionModel.belongsTo(instituteModel_js_1.default, {
     foreignKey: {
-        name: "instituteId",
-        field: "institute_id",
+        name: 'instituteId',
+        field: 'institute_id',
     },
-    as: "feeCollectionInstitute",
+    as: 'feeCollectionInstitute',
 });
 instituteModel_js_1.default.hasMany(FeesCollectionModel, {
-    foreignKey: "instituteId",
-    as: "instituteHasFeeCollection",
+    foreignKey: 'instituteId',
+    as: 'instituteHasFeeCollection',
 });
 FeesCollectionModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "userId",
-        field: "user_id",
+        name: 'userId',
+        field: 'user_id',
     },
-    as: "feeCollectionUser",
+    as: 'feeCollectionUser',
 });
 userModel_js_1.default.hasMany(FeesCollectionModel, {
-    foreignKey: "userId",
-    as: "userHasFeeCollection",
+    foreignKey: 'userId',
+    as: 'userHasFeeCollection',
 });
 FeesCollectionModel.belongsTo(academicCalendarModel_js_1.default, {
     foreignKey: {
-        name: "academicCalendarId",
-        field: "academic_calendar_id",
+        name: 'academicCalendarId',
+        field: 'academic_calendar_id',
         allowNull: true,
     },
-    as: "CollectionCalendar",
+    as: 'CollectionCalendar',
 });
 academicCalendarModel_js_1.default.hasMany(FeesCollectionModel, {
     foreignKey: {
-        name: "academicCalendarId",
-        field: "academic_calendar_id",
+        name: 'academicCalendarId',
+        field: 'academic_calendar_id',
         allowNull: true,
     },
-    as: "CollectionHasCalendar",
+    as: 'CollectionHasCalendar',
 });
 FeesCollectionModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "createdBy",
+        name: 'createdBy',
         allowNull: true,
-        field: "created_by",
+        field: 'created_by',
     },
-    as: "createdByUser",
+    as: 'createdByUser',
 });
 FeesCollectionModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "updatedBy",
+        name: 'updatedBy',
         allowNull: true,
-        field: "updated_by",
+        field: 'updated_by',
     },
-    as: "updatedByUser",
+    as: 'updatedByUser',
 });
 FeesCollectionModel.belongsTo(userModel_js_1.default, {
     foreignKey: {
-        name: "deletedBy",
+        name: 'deletedBy',
         allowNull: true,
-        field: "deleted_by",
+        field: 'deleted_by',
     },
-    as: "deletedByUser",
+    as: 'deletedByUser',
 });
 paymentTermsModel_js_1.default.belongsTo(FeesCollectionModel, {
     foreignKey: {
-        name: "feeCollectionId",
-        field: "fee_collection_id",
+        name: 'feeCollectionId',
+        field: 'fee_collection_id',
     },
-    as: "feeCollection",
+    as: 'feeCollection',
 });
 FeesCollectionModel.hasMany(paymentTermsModel_js_1.default, {
-    foreignKey: "feeCollectionId",
-    as: "feeCollectionHasPaymentTerms",
+    foreignKey: 'feeCollectionId',
+    as: 'feeCollectionHasPaymentTerms',
 });
 exports.default = FeesCollectionModel;

package/dist/models/psql/index.d.ts

@@ -1,4 +1,4 @@
-import { Sequelize } from "sequelize";
+import { Sequelize } from 'sequelize';
 declare const db: any;
 declare const sequelize: Sequelize;
 export { sequelize, db, Sequelize };

package/dist/models/psql/index.js

@@ -40,7 +40,7 @@ exports.Sequelize = exports.db = exports.sequelize = void 0;
 /* eslint-disable @typescript-eslint/no-explicit-any */
 const sequelize_1 = require("sequelize");
 Object.defineProperty(exports, "Sequelize", { enumerable: true, get: function () { return sequelize_1.Sequelize; } });
-const postgresConfig = require("../../configs/postgresConfig.js");
+const postgresConfig = require('../../configs/postgresConfig.js');
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const { database, username, password, host, port, dbLogging, dialectOptions } = postgresConfig;
@@ -51,7 +51,7 @@ const sequelize = new sequelize_1.Sequelize(database, username, password, {
     host,
     port,
     logging: dbLogging,
-    dialect: "postgres",
+    dialect: 'postgres',
     define: {
         timestamps: true,
         underscored: true,
@@ -62,7 +62,7 @@ const sequelize = new sequelize_1.Sequelize(database, username, password, {
 exports.sequelize = sequelize;
 // add all models
 fs_1.default.readdirSync(__dirname)
-    .filter((file) => file.indexOf(".") !== 0 && file !== "index.js" && file.slice(-3) === ".ts")
+    .filter(file => file.indexOf('.') !== 0 && file !== 'index.js' && file.slice(-3) === '.ts')
     .forEach(async (file) => {
     const model = await Promise.resolve(`${path_1.default.join(__dirname, file)}`).then(s => __importStar(require(s)));
     db[model?.default?.name] = model;
@@ -73,7 +73,7 @@ fs_1.default.readdirSync(__dirname)
 //         db[modelName].associate(db);
 //     }
 // });
-sequelize.addHook("beforeBulkDestroy", async (options) => {
+sequelize.addHook('beforeBulkDestroy', async (options) => {
     const userId = options.userId; // Pass the user ID through options
     if (userId) {
         // Fetch all instances matching the delete condition
@@ -83,7 +83,7 @@ sequelize.addHook("beforeBulkDestroy", async (options) => {
             raw: false,
         });
         for (const instance of instances) {
-            if ("deletedBy" in instance || "deleted_by" in instance) {
+            if ('deletedBy' in instance || 'deleted_by' in instance) {
                 instance.deletedBy = userId;
                 // Save the updated instance without triggering additional hooks
                 await instance.save({ hooks: false });
@@ -91,30 +91,30 @@ sequelize.addHook("beforeBulkDestroy", async (options) => {
         }
     }
 });
-sequelize.addHook("beforeCreate", async (instance, options) => {
+sequelize.addHook('beforeCreate', async (instance, options) => {
     const userId = options.userId; // Extract user ID
-    if (userId && ("createdBy" in instance || "created_by" in instance)) {
+    if (userId && ('createdBy' in instance || 'created_by' in instance)) {
         instance.createdBy = userId;
     }
 });
-sequelize.addHook("beforeBulkCreate", async (instances, options) => {
+sequelize.addHook('beforeBulkCreate', async (instances, options) => {
     const userId = options.userId; // Extract user ID
     if (userId) {
         for (const instance of instances) {
-            if ("createdBy" in instance || "created_by" in instance) {
+            if ('createdBy' in instance || 'created_by' in instance) {
                 instance.createdBy = userId;
             }
         }
     }
 });
-sequelize.addHook("beforeBulkUpdate", async (options) => {
+sequelize.addHook('beforeBulkUpdate', async (options) => {
     const userId = options.userId; // Extract user ID from options
     if (userId && options.attributes) {
         // Update the 'updatedBy' or 'updated_by' attribute
-        options.attributes["updatedBy"] = userId; // Adjust as per your column name
+        options.attributes['updatedBy'] = userId; // Adjust as per your column name
     }
 });
-sequelize.addHook("beforeFind", async (options) => {
+sequelize.addHook('beforeFind', async (options) => {
     if (options.include) {
         options.raw = false;
     }