@kipicore/dbcore 1.1.14 → 1.1.16

package/dist/cjs/helpers/utils.d.ts

@@ -153,9 +153,9 @@ export declare function extractFromObject(data: any[], config: {
     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 enumAlternatives: (enumObj: Record<string, string>, isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any> | Joi.StringSchema<string>;
+export declare const objectIdAlternatives: (isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any>;
+export declare const uuidIdAlternatives: (isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any>;
 export declare const customPagination: (data: any[], page: number, limit: number, totalRecords: number) => Promise<{
     limit: number;
     totalRecords: number;

package/dist/cjs/interfaces/approvalRequestInterface.d.ts

@@ -9,6 +9,6 @@ export interface IApproveRequestModelAttributes extends IDefaultAttributes, Docu
     approveBy?: string;
     rejectBy?: string;
     reason?: string;
-    rejectDate?: string;
-    approveDate?: string;
+    rejectDate?: Date;
+    approveDate?: Date;
 }

package/dist/cjs/interfaces/userInstituteMetaInterface.d.ts

@@ -21,7 +21,7 @@ export interface IUserInstituteMetaAttributes extends IDefaultAttributes, Docume
     subJobTitle?: string;
     jobDescription?: string;
     employmentType?: EMPLOYMENT_TYPE;
-    isPrincipal?: IS_PRINCIPAL;
+    isPrincipal?: keyof typeof IS_PRINCIPAL;
     rollNumber: string;
     details: BOOLEAN_STATUS;
     joinDate?: Date;

package/dist/cjs/models/mongodb/taskManagementModel.js

@@ -56,7 +56,7 @@ const TaskConversationsSchema = new mongoose_1.Schema({
         required: true,
     },
     parentId: {
-        type: mongoose_1.default.Types.ObjectId,
+        type: mongoose_1.default.Schema.Types.ObjectId,
         required: false,
     },
     createdAt: {

package/dist/cjs/models/psql/userModel.js

@@ -14,8 +14,6 @@ const areaModel_js_1 = __importDefault(require("./areaModel.js"));
 const utils_js_1 = require("../../helpers/utils.js");
 const uniqueNumberCounterModel_js_1 = __importDefault(require("../mongodb/uniqueNumberCounterModel.js"));
 class UserModel extends sequelize_1.Model {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static updateById;
     // declare addParent: BelongsToManyAddAssociationMixin<UserModel, string>;
     // declare getParents: BelongsToManyGetAssociationsMixin<UserModel>;
     static associate() { }

package/dist/cjs/services/Concrete/mongooseCommonService.js

@@ -3,8 +3,55 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongooseCommonService = void 0;
 const app_js_1 = require("../../constants/app.js");
 class MongooseCommonService {
-    model;
     constructor(model) {
+        this.findAllWithPagination = async (filter, options = {}, populate) => {
+            try {
+                const convertOrderToSort = (order) => {
+                    const sort = {};
+                    for (const [key, direction] of order) {
+                        sort[key] = direction.toUpperCase() === 'DESC' ? -1 : 1;
+                    }
+                    return sort;
+                };
+                const { order, projection, ...restOptions } = options;
+                let { page, limit } = options;
+                const sort = convertOrderToSort(order || app_js_1.PAGINATION_ORDER);
+                // Ensure page and limit are positive integers
+                page = Math.max(1, page || app_js_1.PAGINATION.PAGE);
+                limit = Math.max(1, limit || app_js_1.PAGINATION.LIMIT);
+                // Calculate offset
+                const skip = (page - 1) * limit;
+                // Count total records
+                const totalRecords = await this.model.countDocuments(filter).exec();
+                const totalPages = Math.ceil(totalRecords / limit);
+                // Query the records
+                const query = this.model.find(filter, projection, {
+                    ...restOptions,
+                    limit,
+                    skip,
+                    sort,
+                });
+                // Apply populate if necessary
+                if (populate) {
+                    query.populate(populate);
+                }
+                const recordList = await query.exec();
+                // Construct the pagination result
+                const paginationOptions = {
+                    limit,
+                    totalRecords,
+                    totalPages,
+                    hasPreviousPage: page > 1,
+                    currentPage: Math.min(page, totalPages),
+                    hasNextPage: page < totalPages,
+                    recordList,
+                };
+                return paginationOptions;
+            }
+            catch (err) {
+                throw err;
+            }
+        };
         this.model = model;
     }
     async findAll(filter, options = {}, populate) {
@@ -25,54 +72,6 @@ class MongooseCommonService {
             query.populate(populate);
         return query.exec();
     }
-    findAllWithPagination = async (filter, options = {}, populate) => {
-        try {
-            const convertOrderToSort = (order) => {
-                const sort = {};
-                for (const [key, direction] of order) {
-                    sort[key] = direction.toUpperCase() === 'DESC' ? -1 : 1;
-                }
-                return sort;
-            };
-            const { order, projection, ...restOptions } = options;
-            let { page, limit } = options;
-            const sort = convertOrderToSort(order || app_js_1.PAGINATION_ORDER);
-            // Ensure page and limit are positive integers
-            page = Math.max(1, page || app_js_1.PAGINATION.PAGE);
-            limit = Math.max(1, limit || app_js_1.PAGINATION.LIMIT);
-            // Calculate offset
-            const skip = (page - 1) * limit;
-            // Count total records
-            const totalRecords = await this.model.countDocuments(filter).exec();
-            const totalPages = Math.ceil(totalRecords / limit);
-            // Query the records
-            const query = this.model.find(filter, projection, {
-                ...restOptions,
-                limit,
-                skip,
-                sort,
-            });
-            // Apply populate if necessary
-            if (populate) {
-                query.populate(populate);
-            }
-            const recordList = await query.exec();
-            // Construct the pagination result
-            const paginationOptions = {
-                limit,
-                totalRecords,
-                totalPages,
-                hasPreviousPage: page > 1,
-                currentPage: Math.min(page, totalPages),
-                hasNextPage: page < totalPages,
-                recordList,
-            };
-            return paginationOptions;
-        }
-        catch (err) {
-            throw err;
-        }
-    };
     async count(filter) {
         return this.model.countDocuments(filter).exec();
     }

package/dist/cjs/services/Concrete/sequelizeCommonService.js

@@ -2,8 +2,113 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const app_js_1 = require("../../constants/app.js");
 class SequelizeCommonService {
-    model;
     constructor(model) {
+        this.findAll = (where, options) => {
+            try {
+                const finalOptions = {
+                    ...(options || {}),
+                    order: options?.order || app_js_1.PAGINATION_ORDER,
+                };
+                return this.model.findAll({ where, ...finalOptions });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.findAllWithPagination = async (where, options) => {
+            try {
+                if (!options)
+                    options = {};
+                const limit = options.limit || app_js_1.PAGINATION.LIMIT;
+                const currentPage = options.page || app_js_1.PAGINATION.PAGE;
+                // Clean options for count()
+                const countOptions = { ...options };
+                // options.subQuery = false;
+                delete countOptions.order;
+                delete countOptions.limit;
+                delete countOptions.offset;
+                const totalRecords = await this.model.count({
+                    where,
+                    include: options.include,
+                    distinct: true,
+                });
+                const totalPages = Math.ceil(totalRecords / limit);
+                // Apply pagination + order for findAll
+                options.limit = limit;
+                options.offset = (currentPage - 1) * limit;
+                options.order = options.order || app_js_1.PAGINATION_ORDER;
+                const listOfRecords = await this.findAll(where, options);
+                const paginationOptions = {
+                    limit,
+                    totalRecords,
+                    totalPages,
+                    hasPreviousPage: currentPage - 1 > 0 ? true : false,
+                    currentPage: currentPage > totalPages ? totalPages : currentPage,
+                    hasNextPage: currentPage < totalPages,
+                    recordList: listOfRecords,
+                };
+                return paginationOptions;
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.findOne = async (where, options) => {
+            try {
+                return this.model.findOne({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.update = async (where, updateData, options) => {
+            try {
+                return this.model.update(updateData, { where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.upsert = async (conflictWhere, updateData, options) => {
+            try {
+                return this.model.upsert(updateData, { conflictWhere, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.create = async (createData, options) => {
+            try {
+                return this.model.create(createData, options);
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.bulkCreate = async (createData, options) => {
+            try {
+                return this.model.bulkCreate(createData, options);
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.delete = async (where, options) => {
+            try {
+                return this.model.destroy({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.count = (where, options) => {
+            try {
+                return this.model.count({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
         this.model = model;
     }
     findByPk(identifier, options) {
@@ -14,111 +119,5 @@ class SequelizeCommonService {
             throw err;
         }
     }
-    findAll = (where, options) => {
-        try {
-            const finalOptions = {
-                ...(options || {}),
-                order: options?.order || app_js_1.PAGINATION_ORDER,
-            };
-            return this.model.findAll({ where, ...finalOptions });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    findAllWithPagination = async (where, options) => {
-        try {
-            if (!options)
-                options = {};
-            const limit = options.limit || app_js_1.PAGINATION.LIMIT;
-            const currentPage = options.page || app_js_1.PAGINATION.PAGE;
-            // Clean options for count()
-            const countOptions = { ...options };
-            // options.subQuery = false;
-            delete countOptions.order;
-            delete countOptions.limit;
-            delete countOptions.offset;
-            const totalRecords = await this.model.count({
-                where,
-                include: options.include,
-                distinct: true,
-            });
-            const totalPages = Math.ceil(totalRecords / limit);
-            // Apply pagination + order for findAll
-            options.limit = limit;
-            options.offset = (currentPage - 1) * limit;
-            options.order = options.order || app_js_1.PAGINATION_ORDER;
-            const listOfRecords = await this.findAll(where, options);
-            const paginationOptions = {
-                limit,
-                totalRecords,
-                totalPages,
-                hasPreviousPage: currentPage - 1 > 0 ? true : false,
-                currentPage: currentPage > totalPages ? totalPages : currentPage,
-                hasNextPage: currentPage < totalPages,
-                recordList: listOfRecords,
-            };
-            return paginationOptions;
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    findOne = async (where, options) => {
-        try {
-            return this.model.findOne({ where, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    update = async (where, updateData, options) => {
-        try {
-            return this.model.update(updateData, { where, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    upsert = async (conflictWhere, updateData, options) => {
-        try {
-            return this.model.upsert(updateData, { conflictWhere, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    create = async (createData, options) => {
-        try {
-            return this.model.create(createData, options);
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    bulkCreate = async (createData, options) => {
-        try {
-            return this.model.bulkCreate(createData, options);
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    delete = async (where, options) => {
-        try {
-            return this.model.destroy({ where, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    count = (where, options) => {
-        try {
-            return this.model.count({ where, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
 }
 exports.default = SequelizeCommonService;

package/dist/esm/helpers/utils.d.ts

@@ -153,9 +153,9 @@ export declare function extractFromObject(data: any[], config: {
     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 enumAlternatives: (enumObj: Record<string, string>, isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any> | Joi.StringSchema<string>;
+export declare const objectIdAlternatives: (isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any>;
+export declare const uuidIdAlternatives: (isRequired?: boolean, allowArray?: boolean) => Joi.AlternativesSchema<any>;
 export declare const customPagination: (data: any[], page: number, limit: number, totalRecords: number) => Promise<{
     limit: number;
     totalRecords: number;

package/dist/esm/interfaces/approvalRequestInterface.d.ts

@@ -9,6 +9,6 @@ export interface IApproveRequestModelAttributes extends IDefaultAttributes, Docu
     approveBy?: string;
     rejectBy?: string;
     reason?: string;
-    rejectDate?: string;
-    approveDate?: string;
+    rejectDate?: Date;
+    approveDate?: Date;
 }

package/dist/esm/interfaces/userInstituteMetaInterface.d.ts

@@ -21,7 +21,7 @@ export interface IUserInstituteMetaAttributes extends IDefaultAttributes, Docume
     subJobTitle?: string;
     jobDescription?: string;
     employmentType?: EMPLOYMENT_TYPE;
-    isPrincipal?: IS_PRINCIPAL;
+    isPrincipal?: keyof typeof IS_PRINCIPAL;
     rollNumber: string;
     details: BOOLEAN_STATUS;
     joinDate?: Date;

package/dist/esm/models/mongodb/taskManagementModel.js

@@ -18,7 +18,7 @@ const TaskConversationsSchema = new Schema({
         required: true,
     },
     parentId: {
-        type: mongoose.Types.ObjectId,
+        type: mongoose.Schema.Types.ObjectId,
         required: false,
     },
     createdAt: {

package/dist/esm/models/psql/userModel.js

@@ -9,8 +9,6 @@ import AreaModel from './areaModel.js';
 import { getCityAreas, getNextLetter } from '../../helpers/utils.js';
 import UniqueNumberCounterModel from '../mongodb/uniqueNumberCounterModel.js';
 class UserModel extends Model {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static updateById;
     // declare addParent: BelongsToManyAddAssociationMixin<UserModel, string>;
     // declare getParents: BelongsToManyGetAssociationsMixin<UserModel>;
     static associate() { }

package/dist/esm/services/Concrete/mongooseCommonService.js

@@ -1,7 +1,54 @@
 import { PAGINATION, PAGINATION_ORDER } from '../../constants/app.js';
 export class MongooseCommonService {
-    model;
     constructor(model) {
+        this.findAllWithPagination = async (filter, options = {}, populate) => {
+            try {
+                const convertOrderToSort = (order) => {
+                    const sort = {};
+                    for (const [key, direction] of order) {
+                        sort[key] = direction.toUpperCase() === 'DESC' ? -1 : 1;
+                    }
+                    return sort;
+                };
+                const { order, projection, ...restOptions } = options;
+                let { page, limit } = options;
+                const sort = convertOrderToSort(order || PAGINATION_ORDER);
+                // Ensure page and limit are positive integers
+                page = Math.max(1, page || PAGINATION.PAGE);
+                limit = Math.max(1, limit || PAGINATION.LIMIT);
+                // Calculate offset
+                const skip = (page - 1) * limit;
+                // Count total records
+                const totalRecords = await this.model.countDocuments(filter).exec();
+                const totalPages = Math.ceil(totalRecords / limit);
+                // Query the records
+                const query = this.model.find(filter, projection, {
+                    ...restOptions,
+                    limit,
+                    skip,
+                    sort,
+                });
+                // Apply populate if necessary
+                if (populate) {
+                    query.populate(populate);
+                }
+                const recordList = await query.exec();
+                // Construct the pagination result
+                const paginationOptions = {
+                    limit,
+                    totalRecords,
+                    totalPages,
+                    hasPreviousPage: page > 1,
+                    currentPage: Math.min(page, totalPages),
+                    hasNextPage: page < totalPages,
+                    recordList,
+                };
+                return paginationOptions;
+            }
+            catch (err) {
+                throw err;
+            }
+        };
         this.model = model;
     }
     async findAll(filter, options = {}, populate) {
@@ -22,54 +69,6 @@ export class MongooseCommonService {
             query.populate(populate);
         return query.exec();
     }
-    findAllWithPagination = async (filter, options = {}, populate) => {
-        try {
-            const convertOrderToSort = (order) => {
-                const sort = {};
-                for (const [key, direction] of order) {
-                    sort[key] = direction.toUpperCase() === 'DESC' ? -1 : 1;
-                }
-                return sort;
-            };
-            const { order, projection, ...restOptions } = options;
-            let { page, limit } = options;
-            const sort = convertOrderToSort(order || PAGINATION_ORDER);
-            // Ensure page and limit are positive integers
-            page = Math.max(1, page || PAGINATION.PAGE);
-            limit = Math.max(1, limit || PAGINATION.LIMIT);
-            // Calculate offset
-            const skip = (page - 1) * limit;
-            // Count total records
-            const totalRecords = await this.model.countDocuments(filter).exec();
-            const totalPages = Math.ceil(totalRecords / limit);
-            // Query the records
-            const query = this.model.find(filter, projection, {
-                ...restOptions,
-                limit,
-                skip,
-                sort,
-            });
-            // Apply populate if necessary
-            if (populate) {
-                query.populate(populate);
-            }
-            const recordList = await query.exec();
-            // Construct the pagination result
-            const paginationOptions = {
-                limit,
-                totalRecords,
-                totalPages,
-                hasPreviousPage: page > 1,
-                currentPage: Math.min(page, totalPages),
-                hasNextPage: page < totalPages,
-                recordList,
-            };
-            return paginationOptions;
-        }
-        catch (err) {
-            throw err;
-        }
-    };
     async count(filter) {
         return this.model.countDocuments(filter).exec();
     }

package/dist/esm/services/Concrete/sequelizeCommonService.js

@@ -1,7 +1,112 @@
 import { PAGINATION, PAGINATION_ORDER } from '../../constants/app.js';
 export default class SequelizeCommonService {
-    model;
     constructor(model) {
+        this.findAll = (where, options) => {
+            try {
+                const finalOptions = {
+                    ...(options || {}),
+                    order: options?.order || PAGINATION_ORDER,
+                };
+                return this.model.findAll({ where, ...finalOptions });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.findAllWithPagination = async (where, options) => {
+            try {
+                if (!options)
+                    options = {};
+                const limit = options.limit || PAGINATION.LIMIT;
+                const currentPage = options.page || PAGINATION.PAGE;
+                // Clean options for count()
+                const countOptions = { ...options };
+                // options.subQuery = false;
+                delete countOptions.order;
+                delete countOptions.limit;
+                delete countOptions.offset;
+                const totalRecords = await this.model.count({
+                    where,
+                    include: options.include,
+                    distinct: true,
+                });
+                const totalPages = Math.ceil(totalRecords / limit);
+                // Apply pagination + order for findAll
+                options.limit = limit;
+                options.offset = (currentPage - 1) * limit;
+                options.order = options.order || PAGINATION_ORDER;
+                const listOfRecords = await this.findAll(where, options);
+                const paginationOptions = {
+                    limit,
+                    totalRecords,
+                    totalPages,
+                    hasPreviousPage: currentPage - 1 > 0 ? true : false,
+                    currentPage: currentPage > totalPages ? totalPages : currentPage,
+                    hasNextPage: currentPage < totalPages,
+                    recordList: listOfRecords,
+                };
+                return paginationOptions;
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.findOne = async (where, options) => {
+            try {
+                return this.model.findOne({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.update = async (where, updateData, options) => {
+            try {
+                return this.model.update(updateData, { where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.upsert = async (conflictWhere, updateData, options) => {
+            try {
+                return this.model.upsert(updateData, { conflictWhere, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.create = async (createData, options) => {
+            try {
+                return this.model.create(createData, options);
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.bulkCreate = async (createData, options) => {
+            try {
+                return this.model.bulkCreate(createData, options);
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.delete = async (where, options) => {
+            try {
+                return this.model.destroy({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
+        this.count = (where, options) => {
+            try {
+                return this.model.count({ where, ...options });
+            }
+            catch (err) {
+                throw err;
+            }
+        };
         this.model = model;
     }
     findByPk(identifier, options) {
@@ -12,110 +117,4 @@ export default class SequelizeCommonService {
             throw err;
         }
     }
-    findAll = (where, options) => {
-        try {
-            const finalOptions = {
-                ...(options || {}),
-                order: options?.order || PAGINATION_ORDER,
-            };
-            return this.model.findAll({ where, ...finalOptions });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    findAllWithPagination = async (where, options) => {
-        try {
-            if (!options)
-                options = {};
-            const limit = options.limit || PAGINATION.LIMIT;
-            const currentPage = options.page || PAGINATION.PAGE;
-            // Clean options for count()
-            const countOptions = { ...options };
-            // options.subQuery = false;
-            delete countOptions.order;
-            delete countOptions.limit;
-            delete countOptions.offset;
-            const totalRecords = await this.model.count({
-                where,
-                include: options.include,
-                distinct: true,
-            });
-            const totalPages = Math.ceil(totalRecords / limit);
-            // Apply pagination + order for findAll
-            options.limit = limit;
-            options.offset = (currentPage - 1) * limit;
-            options.order = options.order || PAGINATION_ORDER;
-            const listOfRecords = await this.findAll(where, options);
-            const paginationOptions = {
-                limit,
-                totalRecords,
-                totalPages,
-                hasPreviousPage: currentPage - 1 > 0 ? true : false,
-                currentPage: currentPage > totalPages ? totalPages : currentPage,
-                hasNextPage: currentPage < totalPages,
-                recordList: listOfRecords,
-            };
-            return paginationOptions;
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    findOne = async (where, options) => {
-        try {
-            return this.model.findOne({ where, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    update = async (where, updateData, options) => {
-        try {
-            return this.model.update(updateData, { where, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    upsert = async (conflictWhere, updateData, options) => {
-        try {
-            return this.model.upsert(updateData, { conflictWhere, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    create = async (createData, options) => {
-        try {
-            return this.model.create(createData, options);
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    bulkCreate = async (createData, options) => {
-        try {
-            return this.model.bulkCreate(createData, options);
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    delete = async (where, options) => {
-        try {
-            return this.model.destroy({ where, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    count = (where, options) => {
-        try {
-            return this.model.count({ where, ...options });
-        }
-        catch (err) {
-            throw err;
-        }
-    };
 }

package/package.json

@@ -1,25 +1,23 @@
 {
     "name": "@kipicore/dbcore",
-    "version": "1.1.14",
+    "version": "1.1.16",
     "description": "Reusable DB core package with Postgres, MongoDB, models, services, interfaces, and types",
     "type": "module",
-    "main": "dist/cjs/index.js",
-    "module": "dist/esm/index.js",
-    "types": "dist/esm/index.d.ts",
+    "main": "./dist/cjs/index.cjs",
+    "module": "./dist/esm/index.js",
     "exports": {
         ".": {
-            "require": "./dist/cjs/index.js",
             "import": "./dist/esm/index.js",
-            "types": "./dist/esm/index.d.ts"
+            "require": "./dist/cjs/index.js"
         }
     },
+    "types": "./dist/index.d.ts",
     "scripts": {
         "clean": "rm -rf dist",
-        "format": "prettier . --write",
-        "prebuild": "node scripts/generate-index.js",
-        "build:esm": "tsc -p tsconfig.json",
+        "generate:index": "node scripts/generate-index.js",
         "build:cjs": "tsc -p tsconfig.cjs.json",
-        "build": "npm run clean && npm run build:esm && npm run build:cjs && cp .sequelizerc dist/ && npm run format"
+        "build:esm": "tsc -p tsconfig.esm.json",
+        "build": "npm run clean && npm run generate:index && npm run build:cjs && npm run build:esm"
     },
     "keywords": [
         "postgres",

package/dist/.sequelizerc

@@ -1,13 +0,0 @@
-// Import the path module to work with file paths
-const path = require("path");
-// Export an object with configuration options for Sequelize CLI
-module.exports = {
-  // Configuration file path for Sequelize
-  config: path.resolve("configs", "postgresConfig.js"),
-  // Path to the directory where models are stored
-  "models-path": path.resolve("models", "psql"),
-  // Set the path to the directory to store seeders
-  "seeders-path": path.resolve("db/psql", "seeders"),
-  // Set the path to the directory to store migrations
-  "migrations-path": path.resolve("db/psql", "migrations"),
-};