@b2y/ecommerce-common 1.4.1 → 1.4.3

package/dbconnection/Connect.js

@@ -1,498 +1,498 @@
-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,
-    TenantSettings,
-    User,
-    Customer,
-    Address,
-    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,
-    SubscriptionPlan,
-    SubscriptionFeature,
-    SubscriptionPlanFeature,
-    TenantSubscription,
-    ProductImport,
-    ProductImportFailureAudits,
-    PackagingBox,
-    ReasonContextMapping,
-    ReasonMaster,
-    OrderActionReason
-  } = models;
-  Category.hasMany(Category, {
-    foreignKey: "ParentCategoryID",
-    as: "subCategories",
-  });
-
-  Category.belongsTo(Category, {
-    foreignKey: "ParentCategoryID",
-    as: "parentCategory",
-  });
-
-  
-  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 Order
-  Order.belongsTo(Tenant, { foreignKey: 'TenantID', as: 'Tenant' });
-  Tenant.hasMany(Order, { foreignKey: 'TenantID', as: 'Order' });
-
-  // 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" });
-
-
-  /*---- 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",
-  });
-
-  ProductVariant.belongsTo(PackagingBox, {
-    foreignKey: "PackagingBoxID",
-    as: "PackagingBox"
-  });
-
-  // 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.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" });
-
-  // subscription
-  // SubscriptionPlan and SubscriptionFeature
-  SubscriptionPlan.belongsToMany(SubscriptionFeature, {
-    through: SubscriptionPlanFeature,
-    foreignKey: "SubscriptionPlanID",
-    otherKey: "SubscriptionFeatureID",
-    as: "Features",
-  });
-
-  SubscriptionFeature.belongsToMany(SubscriptionPlan, {
-    through: SubscriptionPlanFeature,
-    foreignKey: "SubscriptionFeatureID",
-    otherKey: "SubscriptionPlanID",
-    as: "SubscriptionPlans",
-  });
-
-  // SubscriptionPlan and Tenant
-  Tenant.hasOne(TenantSubscription, {
-    foreignKey: "TenantID",
-    as: "CurrentSubscription",
-  });
-
-  TenantSubscription.belongsTo(models.Tenant, {
-    foreignKey: "TenantID",
-    as: "SubscribedTenant",
-  });
-
-  TenantSubscription.belongsTo(models.SubscriptionPlan, {
-    foreignKey: "SubscriptionPlanID",
-    as: "SubscriptionPlan",
-  });
-  
-  // ProductImport and ProductImportFailureAudits
-  ProductImport.hasMany(ProductImportFailureAudits, {
-    foreignKey: 'ProductImportID',
-    as: "ProductImportFailureAudits",
-  });
-
-  ProductImportFailureAudits.belongsTo(ProductImport, {
-    foreignKey: 'ProductImportID',
-    as: 'ProductImport'
-  })
-  
-  // order reasons
-  ReasonMaster.hasMany(ReasonContextMapping, {
-    foreignKey: "ReasonID",
-    as: "ReasonContextMappings",
-  });
-
-  ReasonContextMapping.belongsTo(ReasonMaster, {
-    foreignKey: "ReasonID",
-    as: "Reason",
-  });
-
-  ReasonMaster.hasMany(OrderActionReason, {
-    foreignKey: "ReasonID",
-    as: "OrderActionReasons",
-  });
-
-  OrderActionReason.belongsTo(ReasonMaster, {
-    foreignKey: "ReasonID",
-    as: "Reason",
-  });
-
-  ReasonContextMapping.belongsTo(Category, {
-    foreignKey: "CategoryID",
-    as: "Category",
-  });
-
-  Category.hasMany(ReasonContextMapping, {
-    foreignKey: "CategoryID",
-    as: "ReasonContextMappings",
-  });
-
-  OrderActionReason.belongsTo(Order, {
-    foreignKey: "OrderID",
-    as: "Order",
-  });
-
-  Order.hasMany(OrderActionReason, {
-    foreignKey: "OrderID",
-    as: "OrderActionReasons",
-  });
-
-  OrderActionReason.belongsTo(OrderItem, {
-    foreignKey: "OrderItemID",
-    as: "OrderItem",
-  });
-
-  OrderItem.hasMany(OrderActionReason, {
-    foreignKey: "OrderItemID",
-    as: "OrderActionReasons",
-  });
-
-  //Tenant Settings
-  Tenant.hasOne(TenantSettings, {
-    foreignKey: 'TenantID',
-    as: 'TenantSettings'
-  });
-  TenantSettings.belongsTo(Tenant, {
-    foreignKey: 'TenantID',
-    as: 'Tenant'
-  });
-  return { ...models };
-};
-module.exports = initializeModels;
+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,
+    TenantSettings,
+    User,
+    Customer,
+    Address,
+    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,
+    SubscriptionPlan,
+    SubscriptionFeature,
+    SubscriptionPlanFeature,
+    TenantSubscription,
+    ProductImport,
+    ProductImportFailureAudits,
+    PackagingBox,
+    ReasonContextMapping,
+    ReasonMaster,
+    OrderActionReason
+  } = models;
+  Category.hasMany(Category, {
+    foreignKey: "ParentCategoryID",
+    as: "subCategories",
+  });
+
+  Category.belongsTo(Category, {
+    foreignKey: "ParentCategoryID",
+    as: "parentCategory",
+  });
+
+  
+  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 Order
+  Order.belongsTo(Tenant, { foreignKey: 'TenantID', as: 'Tenant' });
+  Tenant.hasMany(Order, { foreignKey: 'TenantID', as: 'Order' });
+
+  // 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" });
+
+
+  /*---- 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",
+  });
+
+  ProductVariant.belongsTo(PackagingBox, {
+    foreignKey: "PackagingBoxID",
+    as: "PackagingBox"
+  });
+
+  // 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.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" });
+
+  // subscription
+  // SubscriptionPlan and SubscriptionFeature
+  SubscriptionPlan.belongsToMany(SubscriptionFeature, {
+    through: SubscriptionPlanFeature,
+    foreignKey: "SubscriptionPlanID",
+    otherKey: "SubscriptionFeatureID",
+    as: "Features",
+  });
+
+  SubscriptionFeature.belongsToMany(SubscriptionPlan, {
+    through: SubscriptionPlanFeature,
+    foreignKey: "SubscriptionFeatureID",
+    otherKey: "SubscriptionPlanID",
+    as: "SubscriptionPlans",
+  });
+
+  // SubscriptionPlan and Tenant
+  Tenant.hasOne(TenantSubscription, {
+    foreignKey: "TenantID",
+    as: "CurrentSubscription",
+  });
+
+  TenantSubscription.belongsTo(models.Tenant, {
+    foreignKey: "TenantID",
+    as: "SubscribedTenant",
+  });
+
+  TenantSubscription.belongsTo(models.SubscriptionPlan, {
+    foreignKey: "SubscriptionPlanID",
+    as: "SubscriptionPlan",
+  });
+  
+  // ProductImport and ProductImportFailureAudits
+  ProductImport.hasMany(ProductImportFailureAudits, {
+    foreignKey: 'ProductImportID',
+    as: "ProductImportFailureAudits",
+  });
+
+  ProductImportFailureAudits.belongsTo(ProductImport, {
+    foreignKey: 'ProductImportID',
+    as: 'ProductImport'
+  })
+  
+  // order reasons
+  ReasonMaster.hasMany(ReasonContextMapping, {
+    foreignKey: "ReasonID",
+    as: "ReasonContextMappings",
+  });
+
+  ReasonContextMapping.belongsTo(ReasonMaster, {
+    foreignKey: "ReasonID",
+    as: "Reason",
+  });
+
+  ReasonMaster.hasMany(OrderActionReason, {
+    foreignKey: "ReasonID",
+    as: "OrderActionReasons",
+  });
+
+  OrderActionReason.belongsTo(ReasonMaster, {
+    foreignKey: "ReasonID",
+    as: "Reason",
+  });
+
+  ReasonContextMapping.belongsTo(Category, {
+    foreignKey: "CategoryID",
+    as: "Category",
+  });
+
+  Category.hasMany(ReasonContextMapping, {
+    foreignKey: "CategoryID",
+    as: "ReasonContextMappings",
+  });
+
+  OrderActionReason.belongsTo(Order, {
+    foreignKey: "OrderID",
+    as: "Order",
+  });
+
+  Order.hasMany(OrderActionReason, {
+    foreignKey: "OrderID",
+    as: "OrderActionReasons",
+  });
+
+  OrderActionReason.belongsTo(OrderItem, {
+    foreignKey: "OrderItemID",
+    as: "OrderItem",
+  });
+
+  OrderItem.hasMany(OrderActionReason, {
+    foreignKey: "OrderItemID",
+    as: "OrderActionReasons",
+  });
+
+  //Tenant Settings
+  Tenant.hasOne(TenantSettings, {
+    foreignKey: 'TenantID',
+    as: 'TenantSettings'
+  });
+  TenantSettings.belongsTo(Tenant, {
+    foreignKey: 'TenantID',
+    as: 'Tenant'
+  });
+  return { ...models };
+};
+module.exports = initializeModels;