@b2y/ecommerce-common 1.0.0

package/README.md

@@ -0,0 +1,4 @@
+# ecommerce-common
+E-commerce common library 
+A reusable, modular **common package** containing shared models, utilities, enums, helpers, and base configurations for the E-Commerce platform.  
+This package centralizes ecommerce-Admin and ecommerce-customer cross-project logic so multiple services can stay consistent and maintainable.

package/constants/AppConstants.js

@@ -0,0 +1,4 @@
+const AppConstants = {
+    DASHBOARD_DEFAULT_DAYS : 7
+}
+module.exports = AppConstants;

package/constants/ReportConstants.js

@@ -0,0 +1,15 @@
+
+const EXCEL_METADATA = {
+  CREATOR: "Ecommerce System", // this can be customized as per requirement
+  LAST_MODIFIED_BY: "Ecommerce System"
+};
+
+const EXCEL_DEFAULT_THEME = {
+  HEADER_FILL_COLOR: "1E90FF",  // default header color
+  HEADER_FONT_COLOR: "FFFFFFFF"
+};
+
+module.exports = {
+  EXCEL_METADATA,
+  EXCEL_DEFAULT_THEME
+};

package/constants/StatusMessageConstants.js

@@ -0,0 +1,21 @@
+const StatusMessageConstants = {
+    PRODUCTVARIANT_INVALID_MRP: 'Invalid MRP: must be positive',
+    PRODUCTVARIANT_MISSING_PRICE_OR_DISCOUNT: 'Either SellingPrice or DiscountPercentage must be provided',
+    PRODUCTVARIANT_INCONSISTENT_PRICING: 'Inconsistent pricing: provided discount percentage does not match calculated value',
+    PRODUCTVARIANT_SELLING_PRICE_EXCEEDS_MRP: 'SellingPrice cannot exceed MRP',
+    PRODUCTVARIANT_INVALID_SELLING_PRICE: 'SellingPrice cannot be negative',
+    PRODUCTVARIANT_INVALID_DISCOUNT_PERCENTAGE: 'DiscountPercentage must be between 0 and 100',
+    INVALID_DATE_FORMAT: "Invalid date format",
+    INVALID_DATE_RANGE: "StartDate cannot be after EndDate",
+    DATE_RANGE_REQUIRED: "Both startDate and endDate must be provided together",
+    INVALID_END_DATE: "Invalid endDate",
+    INVALID_START_DATE: "Invalid startDate",
+    INVALID_ISACTIVE_STATUS:  "IsActive must be either true or false",
+    PAYMENT_STATUS_INVALID: "PaymentStatus is invalid",
+    PAYMENT_TYPE_INVALID: "PaymentType is invalid",
+    PAYMENT_METHOD_INVALID: "PaymentMethod is invalid",
+    ORDER_CREATION_FAILED:"Order creation failed",
+    PAYMENT_SIGNATURE_VERIFICATION_FAILED:"Payment signature verification failed",
+    PAYMENT_VERIFICATION_FAILED:"Payment verification failed"
+}
+module.exports = StatusMessageConstants;

package/dbconnection/Connect.js

@@ -0,0 +1,417 @@
+const fs = require('fs');
+const path = require('path');
+const initializeModels = (sequelize) => {
+  const models = {};
+  const modelFiles = fs.readdirSync(path.join(__dirname, "../model"));
+  modelFiles.forEach((file) => {
+    const model = require(path.join(__dirname, "../model", file))(sequelize);
+    models[model.name] = model;
+  });
+  const {
+    Tenant,
+    User,
+    Customer,
+    Address,
+    City,
+    State,
+    Country,
+    Product,
+    ProductVariant,
+    Category,
+    Brand,
+    Colour,
+    Order,
+    OrderItem,
+    Payment,
+    PaymentStatus,
+    PaymentMethod,
+    PaymentType,
+    Feedback,
+    Role,
+    Permission,
+    RolePermissionMapping,
+    DeviceToken,
+    NotificationHistory,
+    DynamicUIComponent,
+    ProductGroup,
+    OrderStatus,
+    Banner,
+    Document,
+    AttributeType,
+    AttributeValue,
+    Store,
+    StoreUserMapping,
+    OrderItemHistory,
+    Inventory,
+    SpecificationType,
+    ProductSpecification,
+    ProductVariantAttribute,
+    Cart,
+    WishList,
+  } = models;
+  Category.hasMany(Category, {
+    foreignKey: "ParentCategoryID",
+    as: "subCategories",
+  });
+
+  Category.belongsTo(Category, {
+    foreignKey: "ParentCategoryID",
+    as: "parentCategory",
+  });
+
+  User.belongsTo(City, {
+    foreignKey: "CityID",
+    as: "City", // Alias for the association
+  });
+
+  // User associations
+  User.belongsTo(State, {
+    foreignKey: "StateID",
+    as: "State", // Alias for the association
+  });
+
+  User.belongsTo(Country, {
+    foreignKey: "CountryID",
+    as: "Country", // Alias for the association
+  });
+
+  // In Store model
+  Store.belongsTo(City, { foreignKey: "CityID", as: "City" });
+
+  // In Store model
+  Store.belongsTo(State, { foreignKey: "StateID", as: "State" });
+
+  // Store.js
+  Store.belongsTo(Country, { foreignKey: "CountryID", as: "Country" });
+
+  Store.belongsToMany(User, {
+    through: StoreUserMapping,
+    foreignKey: "StoreID",
+    otherKey: "UserID",
+    as: "User",
+  });
+
+  User.belongsToMany(Store, {
+    through: StoreUserMapping,
+    foreignKey: "UserID",
+    otherKey: "StoreID",
+    as: "Store",
+  });
+
+  //permissions
+  // Role to Permission (many-to-many through RolePermissionMapping)
+  Role.belongsToMany(Permission, {
+    through: RolePermissionMapping,
+    foreignKey: "RoleID",
+    otherKey: "PermissionID",
+    as: "Permission",
+  });
+
+  Permission.belongsToMany(Role, {
+    through: RolePermissionMapping,
+    foreignKey: "PermissionID",
+    otherKey: "RoleID",
+    as: "Role",
+  });
+
+  // User to Roles association
+  User.belongsTo(Role, { foreignKey: "RoleID", as: "UserRole" });
+  Role.hasMany(User, { foreignKey: "RoleID" });
+
+  /*---- users realted associations ----*/
+  // Tenant and UserManagement (One-to-many: A Tenant has many UserManagement entries)
+  Tenant.hasMany(User, { foreignKey: "TenantID", as: "User" });
+  User.belongsTo(Tenant, { foreignKey: "TenantID", as: "Tenant" });
+
+  // Tenant and Customer (One-to-many: A Tenant has many Customers)
+  Tenant.hasMany(Customer, { foreignKey: "TenantID", as: "Customer" });
+  Customer.belongsTo(Tenant, { foreignKey: "TenantID", as: "Tenant" });
+
+  Address.belongsTo(Customer, { foreignKey: "CustomerID", as: "Customer" });
+  Customer.hasMany(Address, { foreignKey: "CustomerID", as: "Address" });
+
+  // Address belongs to City
+  Address.belongsTo(City, { foreignKey: "CityID", as: "City" });
+  City.hasMany(Address, { foreignKey: "CityID", as: "Address" });
+
+  // Address belongs to State
+  Address.belongsTo(State, { foreignKey: "StateID", as: "State" });
+  State.hasMany(Address, { foreignKey: "StateID", as: "Address" });
+
+  // Address belongs to Country
+  Address.belongsTo(Country, { foreignKey: "CountryID", as: "Country" });
+  Country.hasMany(Address, { foreignKey: "CountryID", as: "Address" });
+
+  /*---- product related associations -----*/
+  // Product and ProductVariant Associations
+  // One-to-Many
+  Product.hasMany(ProductVariant, {
+    foreignKey: "ProductID",
+    as: "ProductVariant",
+  });
+  ProductVariant.belongsTo(Product, {
+    foreignKey: "ProductID",
+    as: "Product",
+  });
+
+  // Product and Category Association
+  // Many-to-One
+  Product.belongsTo(Category, { foreignKey: "CategoryID", as: "Category" });
+  Category.hasMany(Product, { foreignKey: "CategoryID", as: "Product" });
+
+  // Product and Brand Association
+  // Many-to-One
+  Product.belongsTo(Brand, { foreignKey: "BrandID", as: "Brand" });
+
+  // Brand model definition
+  Brand.hasMany(Product, {
+    foreignKey: "BrandID", // Make sure the foreign key matches in both models
+    as: "Product",
+  });
+
+  // ProductVariant and ProductVariantAttribute
+  ProductVariant.belongsToMany(AttributeValue, {
+    through: ProductVariantAttribute,
+    foreignKey: "ProductVariantID",
+    otherKey: "AttributeValueID",
+    as: "AttributeValues",
+  });
+
+  AttributeValue.belongsToMany(ProductVariant, {
+    through: ProductVariantAttribute,
+    foreignKey: "AttributeValueID",
+    otherKey: "ProductVariantID",
+    as: "ProductVariants",
+  });
+
+  ProductVariant.hasMany(ProductVariantAttribute, {
+    foreignKey: "ProductVariantID",
+    as: "VariantAttributes",
+  });
+  ProductVariantAttribute.belongsTo(ProductVariant, {
+    foreignKey: "ProductVariantID",
+    as: "Variant",
+  });
+
+  // AttributeValue and ProductVariantAttribute
+  AttributeValue.hasMany(ProductVariantAttribute, {
+    foreignKey: "AttributeValueID",
+    as: "VariantAttributes",
+  });
+  ProductVariantAttribute.belongsTo(AttributeValue, {
+    foreignKey: "AttributeValueID",
+    as: "AttributeValue",
+  });
+
+  // Product and ProductGroup Association
+  // Many-to-One
+  Product.belongsTo(ProductGroup, {
+    foreignKey: "ProductGroupID",
+    as: "ProductGroup",
+  });
+  ProductGroup.hasMany(Product, {
+    foreignKey: "ProductGroupID",
+    as: "Product",
+  });
+
+  // Order
+  Order.belongsTo(Customer, {
+    foreignKey: "CustomerID",
+    as: "Customer",
+  });
+
+  Order.belongsTo(Address, {
+    foreignKey: "AddressID",
+    as: "Address",
+  });
+
+  Order.hasMany(OrderItem, {
+    foreignKey: "OrderID",
+    as: "OrderItem",
+  });
+  Order.hasMany(Payment, {
+    foreignKey: "OrderID",
+    as: "Payment",
+  });
+
+  // OrderItem
+  OrderItem.belongsTo(Order, {
+    foreignKey: "OrderID",
+    as: "Order",
+  });
+
+  OrderItem.belongsTo(ProductVariant, {
+    foreignKey: "ProductVariantID",
+    as: "ProductVariant",
+  });
+  
+  // OrderItem to Store association
+  OrderItem.belongsTo(Store, {
+    foreignKey: "StoreID",
+    as: "Store",
+  });
+
+  Store.hasMany(OrderItem, {
+    foreignKey: "StoreID",
+    as: "OrderItem",
+  });
+
+  OrderItem.belongsTo(OrderStatus, {
+    foreignKey: "OrderStatusID",
+    as: "OrderItemStatus",
+  });
+  OrderStatus.hasMany(OrderItem, {
+    foreignKey: "OrderStatusID",
+    as: "OrderItem",
+  });
+  // OrderItem to OrderItemHistory association
+  OrderItem.hasMany(OrderItemHistory, {
+    foreignKey: "OrderItemID",
+    as: "OrderItemHistory",
+  });
+
+  // OrderItem to Feedback
+  OrderItem.hasMany(Feedback, {
+    foreignKey: "OrderItemID",
+    as: "Feedback",
+  });
+  OrderItemHistory.belongsTo(OrderItem, {
+    foreignKey: "OrderItemID",
+    as: "OrderItem",
+  });
+
+  // OrderItemHistory to OrderStatus association
+  OrderItemHistory.belongsTo(OrderStatus, {
+    foreignKey: "OrderStatusID",
+    as: "OrderItemStatus",
+  });
+  OrderStatus.hasMany(OrderItemHistory, {
+    foreignKey: "OrderStatusID",
+    as: "OrderItemStatus",
+  });
+
+  // OrderStatus to Colour
+  OrderStatus.belongsTo(Colour, {
+    foreignKey: "ColourID",
+    as: "Colour",
+  });
+  //Payment
+  Payment.belongsTo(Order, {
+    foreignKey: "OrderID",
+    as: "Order",
+  });
+  Payment.belongsTo(PaymentStatus, {
+    foreignKey: "PaymentStatusID",
+    as: "PaymentStatus",
+  });
+  Payment.belongsTo(PaymentMethod, {
+    foreignKey: "PaymentMethodID",
+    as: "PaymentMethod",
+  });
+  Payment.belongsTo(PaymentType, {
+    foreignKey: "PaymentTypeID",
+    as: "PaymentType",
+  });
+
+  // Feedback Associations
+  Feedback.belongsTo(Product, { foreignKey: "ProductID", as: "Product" });
+  Feedback.belongsTo(Customer, { foreignKey: "CustomerID", as: "Customer" });
+  Feedback.belongsTo(OrderItem, {
+    foreignKey: "OrderItemID",
+    as: "OrderItem",
+  });
+
+  //
+  Product.hasMany(Feedback, { foreignKey: "ProductID", as: "Feedback" });
+  Customer.hasMany(Feedback, { foreignKey: "CustomerID", as: "Feedback" });
+
+  Customer.hasMany(Order, {
+    foreignKey: "CustomerID",
+    as: "Orders",
+  });
+
+  ProductVariant.hasMany(OrderItem, {
+    foreignKey: "ProductVariantID",
+    as: "OrderItems",
+  });
+
+  // One-to-Many: AttributeType has many Attributes
+  AttributeType.hasMany(AttributeValue, {
+    foreignKey: "AttributeTypeID",
+    as: "AttributeValue",
+  });
+
+  // Many-to-One: Attribute belongs to an AttributeType
+  AttributeValue.belongsTo(AttributeType, {
+    foreignKey: "AttributeTypeID",
+    as: "AttributeType",
+  });
+
+  // ProductVariant and Inventory  association
+  ProductVariant.hasMany(Inventory, {
+    foreignKey: "ProductVariantID",
+    as: "Inventory",
+  });
+
+  Inventory.belongsTo(ProductVariant, {
+    foreignKey: "ProductVariantID",
+    as: "ProductVariant",
+  });
+
+  // Inventory and Store association
+  Inventory.belongsTo(Store, {
+    foreignKey: "StoreID",
+    as: "Store",
+  });
+
+  ProductSpecification.belongsTo(SpecificationType, {
+    foreignKey: "SpecificationTypeID",
+    as: "SpecificationType",
+  });
+
+  SpecificationType.hasMany(ProductSpecification, {
+    foreignKey: "SpecificationTypeID",
+    as: "ProductSpecifications",
+  });
+
+  Product.belongsToMany(SpecificationType, {
+    through: ProductSpecification, // join model
+    foreignKey: "ProductID",
+    otherKey: "SpecificationTypeID",
+    as: "SpecificationTypes",
+  });
+
+  SpecificationType.belongsToMany(Product, {
+    through: ProductSpecification,
+    foreignKey: "SpecificationTypeID",
+    otherKey: "ProductID",
+    as: "Products",
+  });
+
+  //wishlist association
+  WishList.belongsTo(ProductVariant, {
+    foreignKey: "ProductVariantID",
+    as: "ProductVariant",
+  });
+
+  WishList.belongsTo(Customer, { foreignKey: "CustomerID", as: "Customer" });
+  ProductVariant.hasMany(WishList, {
+    foreignKey: "ProductVariantID",
+    as: "WishList",
+  });
+
+  Customer.hasMany(WishList, { foreignKey: "CustomerID", as: "WishList" });
+
+  // Cart and ProductVariant Association
+  Cart.belongsTo(ProductVariant, {
+    foreignKey: "ProductVariantID",
+    as: "ProductVariant",
+  });
+
+  Cart.belongsTo(Customer, { foreignKey: "CustomerID", as: "Customer" });
+
+  Cart.belongsTo(Inventory, { foreignKey: "InventoryID", as: "Inventory" });
+  
+  return { ...models };
+};
+module.exports = initializeModels;

package/enum/AddressTypeEnum.js

@@ -0,0 +1,7 @@
+const AddressTypeEnum = Object.freeze({
+  HOME: "Home",
+  WORK: "Work",
+  OTHER: "Other"
+});
+
+module.exports = AddressTypeEnum;

package/enum/BooleanEnum.js

@@ -0,0 +1,5 @@
+const BooleanEnum = Object.freeze({
+    TRUE: true,
+    FALSE: false
+});
+module.exports = BooleanEnum;

package/enum/EntityTypeEnum.js

@@ -0,0 +1,10 @@
+const EntityTypeEnum = Object.freeze({
+    USER: "User",
+    BRAND: "Brand",
+    CATEGORY: "Category",
+    PRODUCT_VARIANT: "ProductVariant",
+    BANNER: "Banner",
+    FEEDBACK:"Feedback"
+});
+
+module.exports = EntityTypeEnum;

package/enum/GenderEnum.js

@@ -0,0 +1,7 @@
+const GenderEnum = Object.freeze({
+    MALE: "Male",
+    FEMALE: "Female",
+    OTHER: "Other"
+});
+module.exports = GenderEnum;
+

package/enum/NotificationStatusEnum.js

@@ -0,0 +1,6 @@
+const NotificationStatusEnum = Object.freeze({
+    SENT: "Sent",
+    FAILED: "Failed",
+    PENDING: "Pending"
+});
+module.exports = NotificationStatusEnum;

package/enum/NotificationTypeEnum.js

@@ -0,0 +1,10 @@
+const NotificationTypeEnum = Object.freeze({
+
+   DYNAMIC: "Dynamic",
+   PUSH: "Push",
+   EMAIL: "Email",
+   SMS: "Sms"
+
+});
+
+module.exports = NotificationTypeEnum;

package/enum/OrderStatusEnum.js

@@ -0,0 +1,8 @@
+const OrderStatusEnum = Object.freeze({
+    PENDING: "Pending",
+    PROCESSING: "Processing",
+    SHIPPED: "Shipped",
+    DELIVERED: "Delivered",
+    CANCELLED: "Cancelled"
+});
+module.exports = OrderStatusEnum;

package/enum/PaymentMethodEnum.js

@@ -0,0 +1,7 @@
+const PaymentMethodEnum = Object.freeze({
+    NET_BANKING: "NetBanking",
+    UPI: "UPI",
+    WALLET: "Wallet",
+    CARD: "Card",
+});
+module.exports = PaymentMethodEnum;

package/enum/PaymentStatusEnum.js

@@ -0,0 +1,7 @@
+const PaymentStatusEnum = Object.freeze({
+    PENDING: "Pending",
+    PAID: "Paid",
+    FAILED: "Failed",
+    REFUNDED: "Refunded"
+});
+module.exports = PaymentStatusEnum;

package/enum/PaymentTypeEnum.js

@@ -0,0 +1,7 @@
+const PaymentTypeEnum = Object.freeze({
+    CASH_ON_DELIVERY: "Cash On Delivery",
+    RAZORPAY: "Razorpay",
+    JUSPAY: "Juspay",
+    PAY_U: "PayU"
+});
+module.exports = PaymentTypeEnum;

package/enum/PlatformEnum.js

@@ -0,0 +1,5 @@
+const PlatformEnum = Object.freeze({
+    ANDROID: "Android",
+    IOS: "Ios"
+});
+module.exports = PlatformEnum;

package/enum/RegistrationStatusEnum.js

@@ -0,0 +1,6 @@
+const RegistrationStatusEnum = Object.freeze({
+    INITIATED: "Initiated",
+    VERIFIED: "Verified",
+    COMPLETED: "Completed"
+});
+module.exports = RegistrationStatusEnum;

package/enum/SortByEnum.js

@@ -0,0 +1,8 @@
+const SortByEnum = Object.freeze({
+    LOW_TO_HIGH: "lowToHigh",
+    HIGH_TO_LOW: "highToLow",
+    DISCOUNT: "discount",
+    NEW_ARRIVAL: "newArrival",
+    CUSTOMER_RATING: "customerRating"
+});
+module.exports = SortByEnum;

package/index.js

@@ -0,0 +1,22 @@
+const fs = require('fs');
+const path = require('path');
+const initializeModels = require('./dbconnection/Connect');
+
+const enums = {};
+const enumDir = path.join(__dirname, 'enum');
+fs.readdirSync(enumDir).forEach((file) => {
+  if (file.endsWith('.js')) {
+    const enumName = path.basename(file, '.js');
+    enums[enumName] = require(path.join(enumDir, file));
+  }
+});
+const utils = {};
+const utilDir = path.join(__dirname, 'utility');
+fs.readdirSync(utilDir).forEach((file) => {
+  if(file.endsWith('.js')){
+    const utilName = path.basename(file, '.js');
+    utils[utilName] = require(path.join(utilDir, file));
+  }
+})
+
+module.exports = {initializeModels, enums, utils}