@kipicore/dbcore 1.0.3

package/dist/models/mongodb/plannerModel.js

@@ -0,0 +1,174 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const app_1 = require("../../constants/app");
+const plannerLectureContentSchema = new mongoose_1.Schema({
+    chapterIndexId: {
+        type: String,
+        required: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values(app_1.USER_CHAPTER_INDEX_STATUS),
+        default: app_1.USER_CHAPTER_INDEX_STATUS.NOT_COMPLETED,
+        required: false,
+    },
+}, { _id: false });
+const plannerLectureSchema = new mongoose_1.Schema({
+    lectureId: {
+        type: String,
+        required: true,
+    },
+    teacherId: {
+        type: String,
+        required: false,
+    },
+    lectureContent: {
+        type: [plannerLectureContentSchema],
+        default: [],
+        required: false,
+    },
+    subjectIndexId: {
+        type: String,
+        required: false,
+    },
+}, { _id: false });
+const plannerTimeSlotSchema = new mongoose_1.Schema({
+    id: {
+        type: String,
+        required: false,
+    },
+    startTime: {
+        type: Date,
+        required: true,
+    },
+    endTime: {
+        type: Date,
+        required: true,
+    },
+}, { _id: false });
+const plannerModelSchema = new mongoose_1.Schema({
+    instituteId: {
+        type: String,
+        required: true,
+    },
+    academicCalenderId: {
+        type: String,
+        required: true,
+    },
+    workingDayId: {
+        type: String,
+        required: true,
+    },
+    date: {
+        type: Date,
+        required: true,
+    },
+    batchId: {
+        type: String,
+        required: true,
+    },
+    lectures: {
+        type: [plannerLectureSchema],
+        default: [],
+        required: true,
+    },
+    freeSlots: {
+        type: [plannerTimeSlotSchema],
+        default: [],
+        required: true,
+    },
+    events: {
+        type: [plannerTimeSlotSchema],
+        default: [],
+        required: true,
+    },
+    holidays: {
+        type: [plannerTimeSlotSchema],
+        default: [],
+        required: true,
+    },
+    exams: {
+        type: [plannerTimeSlotSchema],
+        default: [],
+        required: true,
+    },
+    lastSyncTime: {
+        type: Date,
+        default: () => new Date(),
+        required: true,
+    },
+}, {
+    timestamps: true,
+    versionKey: false,
+});
+// plannerModelSchema.index({
+//     instituteId: 1,
+//     workingDayId: 1,
+//     batchId: 1,
+//     date: 1,
+//     academicCalenderId: 1,
+// });
+// plannerModelSchema.index({
+//     instituteId: 1,
+//     date: 1,
+//     academicCalenderId: 1,
+// });
+// plannerModelSchema.index({
+//     instituteId: 1,
+//     academicCalenderId: 1,
+//     'lectures.teacherId': 1,
+//     date: 1,
+// });
+// plannerModelSchema.index({
+//     instituteId: 1,
+//     academicCalenderId: 1, // optional in some queries, still included for index reuse
+//     batchId: 1,
+//     date: 1,
+// });
+plannerModelSchema.index({
+    instituteId: 1,
+    academicCalenderId: 1,
+    batchId: 1,
+    'lectures.teacherId': 1,
+    workingDayId: 1,
+    date: 1,
+});
+const PlannerModel = mongoose_1.default.model('Planner', plannerModelSchema);
+// (async () => {
+//     await PlannerModel.syncIndexes();
+// })(); // Rebuilds indexes in DB based on schema
+exports.default = PlannerModel;

package/dist/models/mongodb/plugin/addDefaultAttributesPlugin.d.ts

@@ -0,0 +1,2 @@
+import { Schema } from 'mongoose';
+export declare function addDefaultAttributesPlugin(schema: Schema): void;

package/dist/models/mongodb/plugin/addDefaultAttributesPlugin.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDefaultAttributesPlugin = addDefaultAttributesPlugin;
+// Define the audit plugin
+function addDefaultAttributesPlugin(schema) {
+    // Add audit fields to the schema
+    schema.add({
+        createdBy: { type: String, required: false },
+        updatedBy: { type: String, required: false },
+        deletedBy: { type: String, required: false },
+        deletedAt: { type: Date, required: false },
+    });
+    // Before creating a single document
+    // schema.pre('save', async function (next: (err?: Error) => void) {
+    //     const instance = this as any; // Use `as any` to bypass TypeScript strictness
+    //     const options = instance.$locals.options; // Access options passed during save
+    //     if (options?.userId && this.isNew) {
+    //         if ('createdBy' in instance || 'created_by' in instance) {
+    //             instance.createdBy = options.userId;
+    //         }
+    //     }
+    //     if (options?.userId && this.isModified()) {
+    //         if ('updatedBy' in instance || 'updated_by' in instance) {
+    //             instance.updatedBy = options.userId;
+    //         }
+    //     }
+    //     next();
+    // });
+    // Before updating multiple documents
+    schema.pre('updateMany', async function (next) {
+        const options = this.getOptions();
+        const userId = options?.userId;
+        const updateData = this.getUpdate();
+        if (!updateData.deletedBy && userId) {
+            this.setUpdate({
+                ...updateData,
+                updatedBy: userId,
+            });
+        }
+        else if (updateData.deletedBy) {
+            this.setUpdate({
+                ...updateData,
+                deletedBy: userId,
+            });
+        }
+        next();
+    });
+    // Before deleting multiple documents
+    // schema.pre('deleteMany', async function (next: (err?: Error) => void) {
+    //     const options: any = this.getOptions();
+    //     const userId = options?.userId;
+    //     if (userId) {
+    //         const conditions = this.getFilter();
+    //         // Update `deletedBy` for all matched documents
+    //         await mongoose.model(this.model.modelName).updateMany(
+    //             conditions,
+    //             { deletedBy: userId },
+    //             { hooks: false }, // Prevent triggering additional hooks
+    //         );
+    //     }
+    //     next();
+    // });
+}

package/dist/models/mongodb/plugin/transformIdInQueryPlugin.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from 'mongoose';
+declare const transformIdIdQueryPlugin: (schema: Schema) => void;
+export default transformIdIdQueryPlugin;

package/dist/models/mongodb/plugin/transformIdInQueryPlugin.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Helper function to transform queries in aggregation stages
+const transformQuery = (query) => {
+    if (query.id) {
+        query._id = query.id;
+        delete query.id;
+    }
+    if (query.deletedAt === undefined && query.deletedBy === undefined) {
+        query.deletedAt = { $exists: false };
+    }
+};
+// Plugin to transform `id` to `_id` in all queries
+const transformIdIdQueryPlugin = (schema) => {
+    // List of query hooks where the transformation is applied
+    const queryHooks = [
+        'find',
+        'findOne',
+        'findOneAndUpdate',
+        'findOneAndDelete',
+        'findOneAndRemove',
+        'updateOne',
+        'updateMany',
+        'deleteOne',
+        'deleteMany',
+        'count',
+        'countDocuments',
+    ];
+    // Attach the transformation to each query type
+    queryHooks.forEach(hook => {
+        schema.pre(hook, function (next) {
+            const query = this.getQuery();
+            transformQuery(query);
+            next();
+        });
+    });
+    // Special handling for `findById` since it directly deals with `_id`
+    schema.pre('findById', function (next) {
+        const query = this.getQuery();
+        transformQuery(query);
+        next();
+    });
+    // Special handling for aggregations
+    schema.pre('aggregate', function (next) {
+        const pipeline = this.pipeline();
+        pipeline.forEach((stage) => {
+            if (stage.$match) {
+                transformQuery(stage.$match);
+            }
+            else if (stage.$lookup && stage.$lookup.pipeline) {
+                stage.$lookup.pipeline.forEach((subStage) => {
+                    if (subStage.$match) {
+                        transformQuery(subStage.$match);
+                    }
+                });
+            }
+        });
+        next();
+    });
+};
+exports.default = transformIdIdQueryPlugin;

package/dist/models/mongodb/plugin/transformIdInResponsePlugin.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "mongoose";
+declare const transformIdInResponsePlugin: (schema: Schema) => void;
+export default transformIdInResponsePlugin;

package/dist/models/mongodb/plugin/transformIdInResponsePlugin.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const mongoose_1 = __importDefault(require("mongoose"));
+const transformNestedDocs = (doc) => {
+    if (!doc || typeof doc !== "object") {
+        return doc; // Skip non-object or null values
+    }
+    if (Array.isArray(doc)) {
+        return doc.map(transformNestedDocs); // Recursively process arrays
+    }
+    if (doc._id !== undefined) {
+        doc.id = doc._id; // Map _id to id
+        delete doc._id; // Remove _id
+        delete doc.__v; // Optionally remove __v
+    }
+    // Recursively process nested objects
+    for (const key of Object.keys(doc)) {
+        if (!mongoose_1.default.Types.ObjectId.isValid(doc[key]) &&
+            doc[key] &&
+            typeof doc[key] === "object") {
+            doc[key] = transformNestedDocs(doc[key]);
+        }
+    }
+    return doc;
+};
+const transformIdInResponsePlugin = (schema) => {
+    // Apply `toJSON` and `toObject` transformations
+    schema.set("toJSON", {
+        virtuals: true,
+        transform: (_, ret) => {
+            if (ret._id !== undefined) {
+                ret.id = ret._id; // Map _id to id
+                delete ret._id; // Remove _id
+                delete ret.__v; // Optionally remove __v
+            }
+        },
+    });
+    schema.set("toObject", {
+        virtuals: true,
+        transform: (_, ret) => {
+            if (ret._id !== undefined) {
+                ret.id = ret._id; // Map _id to id
+                delete ret._id; // Remove _id
+                delete ret.__v; // Optionally remove __v
+            }
+        },
+    });
+    // Enable lean globally
+    schema.pre(/^find/, function () {
+        const options = this.getOptions();
+        if (options.lean === undefined) {
+            this.setOptions({ lean: true, ...options });
+        }
+    });
+    // Middleware for lean query results
+    schema.post(/^find/, function (docs, next) {
+        transformNestedDocs(docs);
+        next();
+    });
+};
+exports.default = transformIdInResponsePlugin;

package/dist/models/mongodb/replaceTeacherModel.d.ts

@@ -0,0 +1,4 @@
+import { Model } from 'mongoose';
+import { IReplaceTeacherModelAttributes } from '../../interfaces/replaceTeacherInterface';
+declare const ReplaceTeacherModel: Model<IReplaceTeacherModelAttributes>;
+export default ReplaceTeacherModel;

package/dist/models/mongodb/replaceTeacherModel.js

@@ -0,0 +1,110 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const mongoose_1 = __importStar(require("mongoose"));
+const app_1 = require("../../constants/app");
+const batchesItemSchema = new mongoose_1.Schema({
+    userBatchId: { type: String, required: true },
+    replaceTeacherBatchId: { type: String, required: true },
+    subjectId: { type: String, required: false },
+    lectureId: { type: String, required: false },
+}, { _id: false });
+const ReplaceTeacherSchema = new mongoose_1.Schema({
+    batches: {
+        type: [batchesItemSchema],
+        required: true,
+        trim: true,
+    },
+    standardId: {
+        type: String,
+        required: false,
+        trim: true,
+    },
+    teacherType: {
+        type: String,
+        enum: Object.values(app_1.TEACHER_TYPE),
+        required: true,
+    },
+    replaceTeacherStatus: {
+        type: String,
+        enum: Object.values(app_1.REPLACE_TEACHER_STATUS),
+        default: app_1.REPLACE_TEACHER_STATUS.PENDING,
+        required: true,
+    },
+    startDate: {
+        type: Date,
+        required: true,
+        trim: true,
+    },
+    endDate: {
+        type: Date,
+        trim: true,
+    },
+    userId: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    replaceTeacherId: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    instituteId: {
+        type: String,
+        required: true,
+        trim: true,
+    },
+    status: {
+        type: String,
+        enum: Object.values(app_1.COMMAN_STATUS),
+        default: app_1.COMMAN_STATUS.ACTIVE,
+        required: true,
+    },
+    createdBy: {
+        type: String,
+    },
+    updatedBy: {
+        type: String,
+    },
+    deletedBy: {
+        type: String,
+    },
+}, {
+    timestamps: true,
+    versionKey: false,
+});
+const ReplaceTeacherModel = mongoose_1.default.model('replaceTeachers', ReplaceTeacherSchema);
+exports.default = ReplaceTeacherModel;

package/dist/models/mongodb/schoolFeeModel.d.ts

@@ -0,0 +1,4 @@
+import { Model } from "mongoose";
+import { ISchoolFeeModelAttributes } from "../../interfaces/schoolFeeInterface";
+declare const SchoolFeeModel: Model<ISchoolFeeModelAttributes>;
+export default SchoolFeeModel;

package/dist/models/mongodb/schoolFeeModel.js

@@ -0,0 +1,178 @@
+"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 mongoose_1 = __importStar(require("mongoose"));
+const app_1 = require("../../constants/app");
+const errorMessages_1 = require("../../constants/errorMessages");
+const instituteModel_1 = __importDefault(require("../psql/instituteModel"));
+const userInstituteMetaModel_1 = __importDefault(require("./userInstituteMetaModel"));
+const feeTypeModel_1 = __importDefault(require("../psql/feeTypeModel"));
+const termsSchemaSchema = new mongoose_1.Schema({
+    date: {
+        type: Date,
+        required: true,
+    },
+    amount: {
+        type: Number,
+        default: 0,
+        required: true,
+    },
+    // paidAmount: {
+    //     type: Number,
+    //     default: 0,
+    //     required: false,
+    // },
+}, { _id: false });
+const feeSchema = new mongoose_1.Schema({
+    feeTypeId: {
+        type: String,
+        required: true,
+    },
+    frequency: {
+        type: String,
+        enum: Object.values(app_1.PAYMENT_TERMS_TYPE),
+        required: true,
+    },
+    terms: {
+        type: [termsSchemaSchema],
+        default: [],
+        required: true,
+    },
+    isNotApplicableForGirls: {
+        type: Boolean,
+        default: false,
+        required: false,
+    },
+    totalAmount: {
+        type: Number,
+        default: 0,
+        required: true,
+    },
+}, { _id: false });
+const schoolFeeSchema = new mongoose_1.Schema({
+    instituteId: {
+        type: String,
+        required: true,
+    },
+    stdId: {
+        type: [String],
+        required: true,
+    },
+    commonDueDate: {
+        type: Number,
+        required: true,
+    },
+    fees: {
+        type: [feeSchema],
+        default: [],
+        required: true,
+    },
+    createdBy: {
+        type: String,
+        required: false,
+    },
+    updatedBy: {
+        type: String,
+        required: false,
+    },
+    deletedBy: {
+        type: String,
+        required: false,
+    },
+}, {
+    timestamps: true,
+    versionKey: false,
+});
+schoolFeeSchema.pre("save", async function (next) {
+    const schoolFee = this;
+    try {
+        if (!schoolFee.fees || schoolFee.fees.length === 0) {
+            return next(new Error("Fees array cannot be empty."));
+        }
+        if (schoolFee.instituteId) {
+            const institute = await instituteModel_1.default.findByPk(schoolFee.instituteId);
+            if (!institute) {
+                return next(new Error(errorMessages_1.INSTITUTE_ERROR_MESSAGES.NOT_FOUND));
+            }
+        }
+        if (schoolFee.stdId) {
+            const stdExits = await userInstituteMetaModel_1.default.findOne({
+                userId: schoolFee.instituteId,
+                instituteId: schoolFee.instituteId,
+                entities: { $all: schoolFee.stdId },
+            });
+            if (!stdExits) {
+                return next(new Error(errorMessages_1.USER_INSTITUTE_META_ERROR_MESSAGES.STD_NOT_FOUND));
+            }
+        }
+        // const expectedLengths: Record<PAYMENT_TERMS_TYPE, number> = {
+        //     YEARLY: 1,
+        //     MONTHLY: 12,
+        //     HALF_YEARLY: 2,
+        //     QUARTERLY: 4,
+        //     FULL_PAYMENT: 1,
+        // };
+        for (const fee of schoolFee.fees) {
+            // if (fee.frequency && expectedLengths[fee.frequency] !== fee.terms.length) {
+            //     return next(
+            //         new Error(`Invalid terms length for ${fee.frequency}. Expected ${expectedLengths[fee.frequency]}, but got ${fee.terms.length}.`),
+            //     );
+            // }
+            if (fee.feeTypeId) {
+                const feeType = await feeTypeModel_1.default.findByPk(fee.feeTypeId);
+                if (!feeType)
+                    return next(new Error(errorMessages_1.FEE_TYPE_ERROR_MESSAGES.NOT_FOUND));
+            }
+            const totalTermsAmount = fee.terms.reduce((sum, term) => sum + term.amount, 0);
+            if (totalTermsAmount !== fee.totalAmount) {
+                return next(new Error(`Total amount mismatch for feeTypeId ${fee.feeTypeId}: Expected ${fee.totalAmount}, but sum of terms is ${totalTermsAmount}.`));
+            }
+            for (const term of fee.terms) {
+                if (!(term.date instanceof Date) || isNaN(term.date.getTime())) {
+                    return next(new Error(`Invalid date format in terms for feeTypeId ${fee.feeTypeId}.`));
+                }
+            }
+        }
+        next();
+    }
+    catch (error) {
+        return next(error);
+    }
+});
+const SchoolFeeModel = mongoose_1.default.model("schoolFee", schoolFeeSchema);
+exports.default = SchoolFeeModel;

package/dist/models/mongodb/subjectIndexModel.d.ts

@@ -0,0 +1,4 @@
+import { Model } from "mongoose";
+import { ISubjectIndexModelAttributes } from "../../interfaces/subjectIndexInterface";
+declare const SubjectIndexModel: Model<ISubjectIndexModelAttributes>;
+export default SubjectIndexModel;