@b2y/ecommerce-common 1.0.0

package/model/User.js

@@ -0,0 +1,150 @@
+const { DataTypes } = require('sequelize');
+const GenderEnum = require('../enum/GenderEnum')
+module.exports = (sequelize) => {
+  return sequelize.define('User', {
+    UserID: {
+      type: DataTypes.UUID,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4
+    },
+    TenantID: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Tenant',
+        key: 'TenantID'
+      },
+      onDelete: 'CASCADE',
+      onUpdate: 'CASCADE'
+    },
+    FirstName: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    },
+    LastName: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    },
+    EmployeeID: {
+      type: DataTypes.STRING(50),
+      allowNull: false,
+      unique: true
+    },
+    Email: {
+      type: DataTypes.STRING(100),
+      allowNull: false,
+    },
+    Password: {
+      type: DataTypes.STRING(255),
+      allowNull: false
+    },
+    CountryCode: {
+      type: DataTypes.STRING(5),
+      allowNull: false
+    },
+    PhoneNumber: {
+      type: DataTypes.STRING(20),
+      allowNull: false,
+    },
+    Gender: {
+      type: DataTypes.ENUM(...Object.values(GenderEnum)),
+      allowNull: true
+    },
+    RoleID: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Role',
+        key: 'RoleID'
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE'
+    },
+    AddressLine: {
+      type: DataTypes.STRING(500),
+      allowNull: false
+    },
+    CityID: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'City',
+        key: 'CityID'
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE'
+    },
+    StateID: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'State',
+        key: 'StateID'
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE'
+    },
+    CountryID: {
+      type: DataTypes.INTEGER,
+      allowNull: false,
+      references: {
+        model: 'Country',
+        key: 'CountryID'
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE'
+    },
+    Zipcode: {
+      type: DataTypes.STRING(10),
+      allowNull: false
+    },
+    OTP: {
+      type: DataTypes.STRING(10),
+      allowNull: true
+    },
+    OtpExpiry: {
+      type: DataTypes.DATE,
+      allowNull: true
+    },
+    IsActive: {
+      type: DataTypes.BOOLEAN,
+      defaultValue: true
+    },
+    CreatedBy: {
+      type: DataTypes.UUID,
+      allowNull: false
+    },
+    CreatedAt: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false
+    },
+    UpdatedBy: {
+      type: DataTypes.UUID,
+      allowNull: false
+    },
+    UpdatedAt: {
+      type: DataTypes.DATE,
+      defaultValue: DataTypes.NOW,
+      allowNull: false
+    }
+  }, {
+    tableName: 'User',
+    timestamps: false,
+    indexes: [
+      {
+        name: "UQ_User_Tenant_Email",
+        unique: true,
+        fields: ["TenantID", "Email"],
+      },
+      {
+        name: "UQ_User_Tenant_Phone",
+        unique: true,
+        fields: ["TenantID", "CountryCode", "PhoneNumber"],
+      },
+    ],
+  });
+};
+
+

package/model/WishList.js

@@ -0,0 +1,63 @@
+const { DataTypes } = require('sequelize');
+
+module.exports = (sequelize) => {
+  return sequelize.define('WishList', {
+    WishListID: {
+      type: DataTypes.UUID,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: DataTypes.UUIDV4
+    },
+    TenantID: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Tenant',
+        key: 'TenantID'
+      },
+      onDelete: 'CASCADE',
+      onUpdate: 'CASCADE'
+    },
+    ProductVariantID: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'ProductVariant',
+        key: 'ProductVariantID'
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE'
+    },
+    CustomerID: {
+      type: DataTypes.UUID,
+      allowNull: false,
+      references: {
+        model: 'Customer',
+        key: 'CustomerID'
+      },
+      onDelete: 'RESTRICT',
+      onUpdate: 'CASCADE'
+    },
+    CreatedBy: {
+      type: DataTypes.UUID,
+      allowNull: false
+    },
+    CreatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: DataTypes.NOW
+    },
+    UpdatedBy: {
+      type: DataTypes.UUID,
+      allowNull: false
+    },
+    UpdatedAt: {
+      type: DataTypes.DATE,
+      allowNull: false,
+      defaultValue: DataTypes.NOW
+    }
+  }, {
+    tableName: 'WishList',
+    timestamps: false
+  });
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@b2y/ecommerce-common",
+  "version": "1.0.0",
+  "description": "E-commerce common library",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yuvakrishna29/ecommerce-common.git"
+  },
+  "publishConfig": { 
+  "access": "public" 
+  },
+  "author": "Shikha",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/yuvakrishna29/ecommerce-common/issues"
+  },
+  "homepage": "https://github.com/yuvakrishna29/ecommerce-common#readme",
+  "dependencies": {
+    "exceljs": "^4.4.0",
+    "luxon": "^3.7.2",
+    "razorpay": "^2.9.6"
+  }
+}

package/utility/AppUtil.js

@@ -0,0 +1,58 @@
+const BooleanEnum = require('../enum/BooleanEnum');
+const AppUtil = {
+  generateResponse: function (statusCode, status, message, payload, res, customCode = null) {
+    let response = {
+      status,
+    };
+    if (
+      payload &&
+      (Array.isArray(payload) || Object.keys(payload).length > 0)
+    ) {
+      if (payload.rows && typeof payload.count !== "undefined") {
+        const { rows, count, pageNumber, limit } = payload;
+        const currentPage = Number(pageNumber) || 1;
+        const pageSize = Number(limit) || count;
+        const totalPages = Math.ceil(count / pageSize);
+        response.data = rows;
+        response.pagination = {
+          totalRecords: count,
+          totalPages,
+          currentPage,
+          pageSize,
+          hasNext: currentPage < totalPages,
+          hasPrev: currentPage > 1,
+        };
+      } else {
+        // Non-paginated response
+        response.data = payload;
+      }
+    }
+    if (message) {
+      // No data => return message (POST/PUT/DELETE-like APIs)
+      response.message = message || "";
+    }
+    // if custome code also need to send in reponse body
+    if (customCode) {
+      response.customCode = customCode;
+    }
+    res.status(statusCode).send(response);
+  },
+  parseIsActive: function (isActive) {
+    if (isActive === true || isActive === "true") return BooleanEnum.TRUE;
+    if (isActive === false || isActive === "false") return BooleanEnum.FALSE;
+    return undefined;
+  },
+  getPagination: function (page, size) {
+    if (!size || !page) return {};
+    const limit = +size;
+    const offset = (page - 1) * limit;
+    return { limit, offset };
+  },
+  trimDecimal: function (decimal) {
+    const value = parseFloat(decimal);
+      return Math.round(value)
+  },
+};
+
+
+module.exports = AppUtil;

package/utility/DateUtil.js

@@ -0,0 +1,55 @@
+const AppConstants = require('../constants/AppConstants');
+const {DateTime} = require('luxon');
+const StatusMessage = require('../constants/StatusMessageConstants');
+const DateUtil = {
+  isValidDate: function (dateStr) {
+    const dt = DateTime.fromISO(dateStr);
+    return dt.isValid;
+  },
+  getDateRange: function (startDate, endDate, logger) {
+    let currentStartDate, currentEndDate, previousStartDate, previousEndDate;
+    if (startDate && endDate) {
+      if (!this.isValidDate(startDate) || !this.isValidDate(endDate)) {
+        logger.warn("invalid date format");
+        throw new Error(StatusMessage.INVALID_DATE_FORMAT);
+      }
+      currentStartDate = DateTime.fromISO(startDate, { zone: "utc" });
+      currentEndDate = DateTime.fromISO(endDate, { zone: "utc" });
+      if (currentStartDate > currentEndDate) {
+        logger.warn("invalid date range");
+        throw new Error(StatusMessage.INVALID_DATE_RANGE);
+      }
+      const duration = currentEndDate.diff(currentStartDate);
+      previousEndDate = currentStartDate;
+      previousStartDate = previousEndDate.minus(duration);
+    } else if (startDate || endDate) {
+      // Only one provided
+      logger.warn("start date and date date both required");
+      throw new Error(StatusMessage.DATE_RANGE_REQUIRED);
+    } else {
+      // Default 7 days including today
+      currentEndDate = DateTime.utc();
+      currentStartDate = currentEndDate.minus({
+        days: AppConstants.DASHBOARD_DEFAULT_DAYS - 1,
+      });
+
+      const duration = currentEndDate.diff(currentStartDate);
+      previousEndDate = currentStartDate;
+      previousStartDate = previousEndDate.minus(duration);
+    }
+
+    return {
+      currentStartDate: currentStartDate.toISO(),
+      currentEndDate: currentEndDate.toISO(),
+      previousStartDate: previousStartDate.toISO(),
+      previousEndDate: previousEndDate.toISO(),
+    };
+  },
+  formatDate: function (date) {
+    if (!(date instanceof Date)) return null;
+    // conver JS date object to luxon date time
+    const dt = DateTime.fromJSDate(date);
+   return dt.toFormat('dd/MM/yyyy HH:mm:ss');
+  }
+};
+module.exports = DateUtil;

package/utility/ExcelUtil.js

@@ -0,0 +1,125 @@
+const ExcelJS = require('exceljs');
+const { EXCEL_METADATA, EXCEL_DEFAULT_THEME } = require("../constants/ReportConstants");
+
+class ExcelUtil {
+
+  // Create workbook with metadata
+  static createWorkbook() {
+    const workbook = new ExcelJS.Workbook();
+    workbook.creator = EXCEL_METADATA.CREATOR;
+    workbook.lastModifiedBy = EXCEL_METADATA.LAST_MODIFIED_BY;
+    workbook.created = new Date();
+    workbook.modified = new Date();
+    return workbook;
+  }
+
+  // Safe worksheet name
+  static createWorksheet(workbook, sheetName) {
+    const cleanSheetName = sheetName
+      .replace(/[\\/*[\]:?]/g, "")
+      .substring(0, 31);
+
+    return workbook.addWorksheet(cleanSheetName);
+  }
+
+  // Setup headers using theme from constants
+  static setupHeaders(worksheet, headers) {
+    worksheet.columns = headers;
+
+    const headerRow = worksheet.getRow(1);
+    headerRow.eachCell(cell => {
+      cell.font = {
+        bold: true,
+        color: { argb: EXCEL_DEFAULT_THEME.HEADER_FONT_COLOR },
+        size: 11
+      };
+      cell.fill = {
+        type: "pattern",
+        pattern: "solid",
+        fgColor: { argb: EXCEL_DEFAULT_THEME.HEADER_FILL_COLOR }
+      };
+      cell.alignment = { horizontal: "center", vertical: "middle", wrapText: true };
+      cell.border = {
+        top: { style: "thin" },
+        left: { style: "thin" },
+        bottom: { style: "thin" },
+        right: { style: "thin" }
+      };
+    });
+
+    worksheet.views = [{ state: "frozen", ySplit: 1 }];
+  }
+
+  static cleanValue(val) {
+    if (val == null) return "";
+
+    if (typeof val === "string") {
+      // eslint-disable-next-line no-control-regex
+      return val.replace(/[\x00-\x1F\x7F]/g, "");
+    }
+
+    if (typeof val === "object") {
+      return JSON.stringify(val).substring(0, 32767);
+    }
+
+    return val;
+  }
+
+  static cleanRow(row) {
+    const clean = {};
+    for (let key in row) clean[key] = ExcelUtil.cleanValue(row[key]);
+    return clean;
+  }
+
+  static styleDataRows(worksheet) {
+    worksheet.eachRow((row, idx) => {
+      if (idx !== 1) {
+        row.eachCell(cell => {
+          const isNumber = typeof cell.value === 'number';
+          cell.alignment = { horizontal: isNumber ? 'right' : 'left', vertical: "middle", wrapText: true };
+          cell.border = {
+            top: { style: "thin" },
+            left: { style: "thin" },
+            bottom: { style: "thin" },
+            right: { style: "thin" }
+          };
+        });
+      }
+    });
+  }
+
+  static autoAdjustColumns(worksheet) {
+    worksheet.columns.forEach(col => {
+      let maxLength = 10;
+      col.eachCell({ includeEmpty: true }, cell => {
+        const val = cell.value ? cell.value.toString() : "";
+        maxLength = Math.max(maxLength, val.length + 2);
+      });
+      col.width = Math.min(maxLength, 50);
+    });
+  }
+
+  static async writeToResponse(workbook, res, filename, logger) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const finalName = `${filename}_${timestamp}.xlsx`;
+
+    res.setHeader("Content-Disposition", `attachment; filename="${finalName}"`);
+    res.setHeader("Content-Type", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+    res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+    res.setHeader("Pragma", "no-cache");
+    res.setHeader("Expires", "0");
+    res.setHeader("Content-Transfer-Encoding", "binary");
+
+    try {
+      await workbook.xlsx.write(res);
+      res.end();
+    } catch (err) {
+      logger.error("Excel generation error:", err);
+      if (!res.headersSent) {
+        res.status(500).json({ error: "Excel generation failed" });
+      }
+    }
+  }
+}
+
+module.exports = ExcelUtil;

package/utility/OrderTimeFilterUtil.js

@@ -0,0 +1,86 @@
+class OrderTimeFilterUtil {
+    static getDateRange(filter) {
+        if (!filter) return null;
+
+        const today = new Date();
+        let startDate, endDate;
+
+        switch (filter.toLowerCase()) {
+            case AppConstants.LAST_30DAYS.toLowerCase():
+                startDate = new Date(today);
+                startDate.setDate(today.getDate() - 30);
+                startDate.setHours(0, 0, 0, 0);
+                endDate = new Date(today);
+                endDate.setHours(23, 59, 59, 999);
+                break;
+
+            case AppConstants.LAST_6MONTHS.toLowerCase():
+                startDate = new Date(today);
+                startDate.setMonth(today.getMonth() - 6);
+                startDate.setHours(0, 0, 0, 0);
+                endDate = new Date(today);
+                endDate.setHours(23, 59, 59, 999);
+                break;
+
+            case AppConstants.OLDER.toLowerCase():
+                startDate = new Date(1970, 0, 1);
+                endDate = new Date(today);
+                break;
+            
+            default:
+                const year = parseInt(filter);
+                if (!isNaN(year)) {
+                    return this.getYearRange(year);
+                }
+                return null;
+        }
+
+        return { startDate, endDate };
+    }
+
+    static getYearRange(year) {
+        const today = new Date();
+        const startDate = new Date(year, 0, 1);
+        
+        if (year === today.getFullYear()) {
+            const endDate = new Date(today);
+            endDate.setHours(23, 59, 59, 999);
+            return { startDate, endDate };
+        }
+        
+        return {
+            startDate,
+            endDate: new Date(year, 11, 31, 23, 59, 59, 999)
+        };
+    }
+
+    static isValidFilter(filter) {
+        if (!filter) return false;
+
+        const validFilters = [
+            AppConstants.LAST_30DAYS.toLowerCase(),
+            AppConstants.LAST_6MONTHS.toLowerCase(),
+            AppConstants.OLDER.toLowerCase()
+        ];
+        
+        if (validFilters.includes(filter.toLowerCase())) {
+            return true;
+        }
+        
+        const year = parseInt(filter);
+        const currentYear = new Date().getFullYear();
+        return !isNaN(year) && year <= currentYear && year;
+    }
+
+    static buildWhereCondition(filter, Sequelize) {
+        const dateRange = this.getDateRange(filter);
+        if (!dateRange) return null;
+
+        return {
+            [Sequelize.Op.gte]: dateRange.startDate,
+            [Sequelize.Op.lte]: dateRange.endDate
+        };
+    }
+   
+}
+