@kipicore/dbcore 1.1.0 → 1.1.2

package/dist/src/models/psql/vendorManagementModel.js

@@ -1,174 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-import { COMMAN_STATUS } from '../../constants/app.js';
-import { sequelize } from './index.js';
-import UserModel from './userModel.js';
-import InstituteModel from './instituteModel.js';
-import CityModel from './cityModel.js';
-import StateModel from './stateModel.js';
-import CountryModel from './countryModel.js';
-class VendorManagementModel extends Model {
-}
-VendorManagementModel.init({
-    id: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    status: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        defaultValue: COMMAN_STATUS.ACTIVE,
-    },
-    name: {
-        type: DataTypes.STRING,
-        allowNull: true,
-    },
-    mobile1: {
-        type: DataTypes.STRING(10),
-        allowNull: true,
-    },
-    mobile2: {
-        type: DataTypes.STRING(10),
-        allowNull: true,
-    },
-    email: {
-        type: DataTypes.STRING(50),
-        allowNull: true,
-    },
-    gstNo: {
-        type: DataTypes.STRING,
-        allowNull: true,
-    },
-    address1: {
-        type: DataTypes.STRING,
-        allowNull: true,
-    },
-    address2: {
-        type: DataTypes.STRING,
-        allowNull: true,
-    },
-    pinCode: {
-        type: DataTypes.STRING,
-        allowNull: true,
-        field: 'pin_code',
-    },
-    area: {
-        type: DataTypes.STRING,
-        allowNull: true,
-    },
-    cityId: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-        field: 'city_id',
-    },
-    stateId: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-        field: 'state_id',
-    },
-    countryId: {
-        type: DataTypes.INTEGER,
-        allowNull: true,
-        field: 'country_id',
-    },
-    instituteId: {
-        type: DataTypes.UUID,
-        allowNull: true,
-        field: 'institute_id',
-    },
-}, {
-    modelName: 'VendorManagement',
-    tableName: 'vendor_management',
-    timestamps: true,
-    sequelize,
-});
-VendorManagementModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-VendorManagementModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-VendorManagementModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-VendorManagementModel.belongsTo(InstituteModel, {
-    foreignKey: {
-        name: 'instituteId',
-        allowNull: true,
-        field: 'institute_id',
-    },
-    as: 'instituteVendor',
-});
-InstituteModel.hasMany(VendorManagementModel, {
-    foreignKey: {
-        name: 'instituteId',
-        allowNull: true,
-        field: 'institute_id',
-    },
-    as: 'vendorInstitute',
-});
-VendorManagementModel.belongsTo(CityModel, {
-    foreignKey: {
-        name: 'cityId',
-        allowNull: true,
-        field: 'city_id',
-    },
-    as: 'cityDetails',
-});
-CityModel.hasMany(VendorManagementModel, {
-    foreignKey: {
-        name: 'cityId',
-        allowNull: true,
-        field: 'city_id',
-    },
-    as: 'detailsOfCity',
-});
-VendorManagementModel.belongsTo(StateModel, {
-    foreignKey: {
-        name: 'stateId',
-        allowNull: true,
-        field: 'state_id',
-    },
-    as: 'stateDetails',
-});
-StateModel.hasMany(VendorManagementModel, {
-    foreignKey: {
-        name: 'stateId',
-        allowNull: true,
-        field: 'state_id',
-    },
-    as: 'detailsOfState',
-});
-VendorManagementModel.belongsTo(CountryModel, {
-    foreignKey: {
-        name: 'countryId',
-        allowNull: true,
-        field: 'country_id',
-    },
-    as: 'countryDetails',
-});
-CountryModel.hasMany(VendorManagementModel, {
-    foreignKey: {
-        name: 'countryId',
-        allowNull: true,
-        field: 'country_id',
-    },
-    as: 'detailsOfCountry',
-});
-export default VendorManagementModel;

package/dist/src/models/psql/walletHistoryModel.js

@@ -1,97 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-import { sequelize } from './index.js';
-import { WALLET_HISTORY_STATUS } from '../../constants/app.js';
-import UserModel from './userModel.js';
-import WalletModel from './walletModel.js';
-class WalletHistoryModel extends Model {
-}
-WalletHistoryModel.init({
-    id: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    userId: {
-        type: DataTypes.UUID,
-        allowNull: false,
-        field: 'user_id',
-    },
-    walletId: {
-        type: DataTypes.UUID,
-        allowNull: false,
-        field: 'wallet_id',
-    },
-    type: {
-        type: DataTypes.STRING,
-        allowNull: false,
-    },
-    action: {
-        type: DataTypes.STRING,
-        allowNull: false,
-    },
-    totalCoin: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-        field: 'total_coin',
-    },
-    coin: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-        field: 'coin',
-    },
-    storage: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-        field: 'storage',
-    },
-    totalStorage: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-        field: 'total_storage',
-    },
-    itemType: {
-        type: DataTypes.STRING,
-        allowNull: false,
-    },
-    status: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: WALLET_HISTORY_STATUS.PENDING,
-    },
-}, {
-    modelName: 'WalletHistoryModel',
-    tableName: 'wallet_history',
-    timestamps: true,
-    paranoid: true, // enables soft delete (deletedAt)
-    sequelize,
-});
-WalletHistoryModel.belongsTo(UserModel, {
-    foreignKey: { name: 'userId', allowNull: false, field: 'user_id' },
-    as: 'walletHistoryUser',
-});
-UserModel.hasMany(WalletHistoryModel, {
-    foreignKey: { name: 'userId', allowNull: false, field: 'user_id' },
-    as: 'userWalletHistoryList',
-});
-WalletHistoryModel.belongsTo(WalletModel, {
-    foreignKey: { name: 'walletId', allowNull: false, field: 'wallet_id' },
-    as: 'wallet',
-});
-WalletModel.hasMany(WalletHistoryModel, {
-    foreignKey: { name: 'walletId', allowNull: false, field: 'wallet_id' },
-    as: 'walletHistoryList',
-});
-WalletHistoryModel.belongsTo(UserModel, {
-    foreignKey: { name: 'createdBy', allowNull: true, field: 'created_by' },
-    as: 'createdByUser',
-});
-WalletHistoryModel.belongsTo(UserModel, {
-    foreignKey: { name: 'updatedBy', allowNull: true, field: 'updated_by' },
-    as: 'updatedByUser',
-});
-WalletHistoryModel.belongsTo(UserModel, {
-    foreignKey: { name: 'deletedBy', allowNull: true, field: 'deleted_by' },
-    as: 'deletedByUser',
-});
-export default WalletHistoryModel;

package/dist/src/models/psql/walletModel.js

@@ -1,88 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-import { sequelize } from './index.js';
-import { COMMAN_STATUS } from '../../constants/app.js';
-import UserModel from './userModel.js';
-class WalletModel extends Model {
-}
-WalletModel.init({
-    id: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    uuid: {
-        type: DataTypes.UUID,
-        allowNull: false,
-        primaryKey: true,
-    },
-    coin: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-        defaultValue: 0,
-    },
-    status: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        defaultValue: COMMAN_STATUS.ACTIVE,
-    },
-    storageInGb: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-        defaultValue: 0,
-        field: 'storage_in_gb',
-    },
-    storageInBytes: {
-        type: DataTypes.FLOAT,
-        allowNull: false,
-        defaultValue: 0,
-        field: 'storage_in_bytes',
-    },
-}, {
-    modelName: 'WalletModel',
-    tableName: 'wallets',
-    timestamps: true,
-    sequelize,
-});
-WalletModel.hasMany(UserModel, {
-    foreignKey: {
-        name: 'uuid',
-        allowNull: false,
-        field: 'uuid',
-    },
-    sourceKey: 'uuid',
-    as: 'walletUserList',
-});
-UserModel.belongsTo(WalletModel, {
-    foreignKey: {
-        name: 'uuid',
-        allowNull: false,
-        field: 'uuid',
-    },
-    as: 'userWallet',
-});
-WalletModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-WalletModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-WalletModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-export default WalletModel;

package/dist/src/models/psql/workingDayModel.js

@@ -1,74 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-import { sequelize } from './index.js';
-import { WORKIN_DAY_STATUS } from '../../constants/app.js';
-import UserModel from './userModel.js';
-class WorkingDayModel extends Model {
-}
-WorkingDayModel.init({
-    id: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    dayName: {
-        type: DataTypes.STRING(20),
-        field: 'day_name',
-        allowNull: false,
-    },
-    dayOfWeek: {
-        type: DataTypes.INTEGER,
-        field: 'day_of_week',
-        allowNull: false,
-    },
-    status: {
-        type: DataTypes.STRING(30),
-        allowNull: false,
-        defaultValue: WORKIN_DAY_STATUS.INACTIVE,
-    },
-    startTime: {
-        type: DataTypes.DATE,
-        allowNull: false,
-        field: 'start_time',
-    },
-    endTime: {
-        type: DataTypes.DATE,
-        allowNull: false,
-        field: 'end_time',
-    },
-    instituteId: {
-        type: DataTypes.UUID,
-        field: 'institute_id',
-        allowNull: true,
-    },
-}, {
-    modelName: 'WorkingDayModel',
-    tableName: 'working_days',
-    timestamps: true,
-    sequelize,
-});
-WorkingDayModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-WorkingDayModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-WorkingDayModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-export default WorkingDayModel;

package/dist/src/models/psql/workingShiftModel.js

@@ -1,87 +0,0 @@
-import { DataTypes, Model } from 'sequelize';
-import { sequelize } from './index.js';
-import { WORKIN_DAY_STATUS } from '../../constants/app.js';
-import UserModel from './userModel.js';
-import WorkingDayModel from './workingDayModel.js';
-import InstituteModel from './instituteModel.js';
-import SlotModel from './slotModel.js';
-class WorkingShiftModel extends Model {
-}
-WorkingShiftModel.init({
-    id: {
-        type: DataTypes.UUID,
-        defaultValue: DataTypes.UUIDV4,
-        allowNull: false,
-        primaryKey: true,
-    },
-    workingId: {
-        type: DataTypes.UUID,
-        field: 'working_id',
-        allowNull: false,
-    },
-    slotId: {
-        type: DataTypes.UUID,
-        field: 'slot_id',
-        allowNull: false,
-    },
-    status: {
-        type: DataTypes.STRING(30),
-        allowNull: false,
-        defaultValue: WORKIN_DAY_STATUS.ACTIVE,
-    },
-    shiftType: {
-        type: DataTypes.STRING(30),
-        allowNull: false,
-    },
-    startTime: {
-        type: DataTypes.DATE,
-        allowNull: false,
-        field: 'start_time',
-    },
-    endTime: {
-        type: DataTypes.DATE,
-        allowNull: false,
-        field: 'end_time',
-    },
-    instituteId: {
-        type: DataTypes.UUID,
-        field: 'institute_id',
-        allowNull: true,
-    },
-}, {
-    modelName: 'WorkingShiftModel',
-    tableName: 'working_shift_days',
-    timestamps: true,
-    sequelize,
-});
-WorkingShiftModel.belongsTo(WorkingDayModel, { foreignKey: 'workingId', as: 'shiftHasWorkingDay' });
-WorkingDayModel.hasMany(WorkingShiftModel, { foreignKey: 'workingId', as: 'workingDayShift' });
-WorkingShiftModel.belongsTo(InstituteModel, { foreignKey: 'instituteId', as: 'shiftHasInstituted' });
-WorkingDayModel.hasMany(WorkingShiftModel, { foreignKey: 'instituteId', as: 'institutedShift' });
-WorkingShiftModel.belongsTo(SlotModel, { foreignKey: 'slotId', as: 'shiftSlot' });
-SlotModel.hasMany(WorkingShiftModel, { foreignKey: 'slotId', as: 'slotHasShift' });
-WorkingShiftModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'createdBy',
-        allowNull: true,
-        field: 'created_by',
-    },
-    as: 'createdByUser',
-});
-WorkingShiftModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'updatedBy',
-        allowNull: true,
-        field: 'updated_by',
-    },
-    as: 'updatedByUser',
-});
-WorkingShiftModel.belongsTo(UserModel, {
-    foreignKey: {
-        name: 'deletedBy',
-        allowNull: true,
-        field: 'deleted_by',
-    },
-    as: 'deletedByUser',
-});
-export default WorkingShiftModel;

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

@@ -1,104 +0,0 @@
-import { PAGINATION, PAGINATION_ORDER } from "../../constants/app.js";
-export class MongooseCommonService {
-    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) {
-        const query = this.model.find(filter, null, options);
-        if (populate)
-            query.populate(populate);
-        return query.exec();
-    }
-    async findOne(filter, options = {}, populate) {
-        const query = this.model.findOne(filter, null, options);
-        if (populate)
-            query.populate(populate);
-        return query.exec();
-    }
-    async findById(id, options = {}, populate) {
-        const query = this.model.findById(id, null, options);
-        if (populate)
-            query.populate(populate);
-        return query.exec();
-    }
-    async count(filter) {
-        return this.model.countDocuments(filter).exec();
-    }
-    async update(filter, updateData, options = {}) {
-        return this.model.updateMany(filter, updateData, options).exec();
-    }
-    async upsert(filter, updateData, options = {
-        upsert: true,
-        new: true,
-    }) {
-        return this.model.findOneAndUpdate(filter, updateData, options).exec();
-    }
-    async create(createData, options = {}) {
-        const [createdDoc] = await this.model.create([{ ...createData, createdBy: options.userId }], options);
-        return createdDoc;
-    }
-    async bulkCreate(createData, options = {}) {
-        return this.model.create(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        createData.map((data) => {
-            data.createdBy = options.userId;
-            return data;
-        }), options);
-    }
-    async delete(filter, options = {}) {
-        return this.model
-            .updateMany(filter, { deletedBy: options.userId, deletedAt: new Date() }, options)
-            .exec();
-    }
-    async aggregate(pipeline) {
-        return this.model.aggregate(pipeline).exec();
-    }
-}