Error: model.belongsTo called with something that's not a subclass of Sequelize.Model

I have two models category and sub_category and i had implemented the one-to-many association b/w them but i get the error somthing like sub category Error: sub_category.belongsTo called with something that's not a subclass of Sequelize.Model. why?

category model

const { DataTypes } = require("sequelize");
const { getConnection } = require("../helper/databaseConnection");
const subcat = require("./subCategory");

const categoryModel = {
  category_id: {
    primaryKey: true,
    type: DataTypes.UUID,
    defaultValue: DataTypes.UUIDV4,
  },
  category_name: {
    type: DataTypes.STRING,
    allowNull: false,
  },
};

let category = null;
const initCategoryModel = async () => {
  try {
    if (category) return category;
    const sequelize = await getConnection();
    category = sequelize.define("category", categoryModel, {
      freezeTableName: true,
    });

    category.hasMany(subcat, {
      foreignKey: "category_id",
      onDelete: "CASCADE",
    });

    await category.sync({ alter: true });
    return category;
  } catch (err) {
    console.log("category", err);
  }
};

module.exports = { initCategoryModel };

sub category model

const { DataTypes } = require("sequelize");
const { getConnection } = require("../helper/databaseConnection");
const category = require("./category");

const subcatModel = {
  subcat_id: {
    primaryKey: true,
    type: DataTypes.UUID,
    defaultValue: DataTypes.UUIDV4,
  },
  subcat_name: {
    type: DataTypes.STRING,
    allowNull: false,
  },
};

let subcat = null;
const initSubcatModel = async () => {
  try {
    if (subcat) return subcat;
    const sequelize = await getConnection();
    subcat = sequelize.define("sub_category", subcatModel, {
      freezeTableName: true,
    });

    subcat.belongsTo(category, {
      foreignKey: "category_id",
      onDelete: "CASCADE",
    });

    await subcat.sync({ alter: true });
    return subcat;
  } catch (err) {
    console.log("sub category", err);
  }
};

module.exports = { initSubcatModel };

here category has many sub-category and sub-category belongs to a category,

From the code you pasted, you don't seems to export subcat nor category but the init functions.

const subcat = require("./subCategory"); // { initSubcatModel } and not a model

And since there is a circular dependency, you would have an issue anyway, depending in the order in which init function is called, you would have subcat or category be undefined (since corresponding init function has not been called yet).

You should rather split the model definition, the model association and the model sync in three separate steps
Ensure that are model definition is called first, then do associations and finally sync.

// category.js
const { DataTypes } = require("sequelize");
const { getConnection } = require("../helper/databaseConnection");
const { getSubcatModel } = require("./subcat");

const categoryModel = {
  category_id: {
    primaryKey: true,
    type: DataTypes.UUID,
    defaultValue: DataTypes.UUIDV4,
  },
  category_name: {
    type: DataTypes.STRING,
    allowNull: false,
  },
};

let category = null;
const getCategoryModel = () => {
  try {
    if (category) return category;
    const sequelize = await getConnection();
    category = sequelize.define("category", categoryModel, {
      freezeTableName: true,
    });

    return category;
  } catch (err) {
    console.log("category", err);
  }
};
const associateCategoryModel = () => {
  const category = getCategoryModel();
  const subcat = getSubcatModel();
  category.hasMany(subcat, {
    foreignKey: "category_id",
    onDelete: "CASCADE",
  });
}

module.exports = { getCategoryModel, associateCategoryModel };

// subcategory.js
const { DataTypes } = require("sequelize");
const { getConnection } = require("../helper/databaseConnection");
const { getCategoryModel } = require("./category");

const subcatModel = {
  subcat_id: {
    primaryKey: true,
    type: DataTypes.UUID,
    defaultValue: DataTypes.UUIDV4,
  },
  subcat_name: {
    type: DataTypes.STRING,
    allowNull: false,
  },
};

let subcat = null;
const getSubcatModel = () => {
  try {
    if (subcat) return subcat;
    const sequelize = await getConnection();
    subcat = sequelize.define("sub_category", subcatModel, {
      freezeTableName: true,
    });

    return subcat;
  } catch (err) {
    console.log("sub category", err);
  }
};

const associateSubcatModel = () => {
  const subcat = getSubcatModel();
  const category = getCategoryModel();
  subcat.belongsTo(category, {
    foreignKey: "category_id",
    onDelete: "CASCADE",
  });
}

module.exports = { getSubcatModel, associateSubcatModel };

// index.js

const initModels = async () => {
  const category = getCategoryModel();
  const subcat = getSubcatModel();

  associateCategoryModel();
  associateSubcatModel();

  await category.sync();
  await subcat.sync();
}