29916/backend/src/db/seeders/20231127130745-sample-data.js

const db = require('../models');
const Users = db.users;

const Admins = db.admins;

const Avatars = db.avatars;

const Learners = db.learners;

const Parents = db.parents;

const Words = db.words;

const AdminsData = [
  {
    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field
  },

  {
    // type code here for "relation_one" field
  },
];

const AvatarsData = [
  {
    name: 'Star Explorer',

    required_stars: 10,
  },

  {
    name: 'Word Wizard',

    required_stars: 50,
  },

  {
    name: 'Sentence Sage',

    required_stars: 100,
  },
];

const LearnersData = [
  {
    // type code here for "relation_one" field

    stars: 50,

    // type code here for "relation_many" field
  },

  {
    // type code here for "relation_one" field

    stars: 30,

    // type code here for "relation_many" field
  },

  {
    // type code here for "relation_one" field

    stars: 70,

    // type code here for "relation_many" field
  },
];

const ParentsData = [
  {
    // type code here for "relation_one" field
    // type code here for "relation_many" field
  },

  {
    // type code here for "relation_one" field
    // type code here for "relation_many" field
  },

  {
    // type code here for "relation_one" field
    // type code here for "relation_many" field
  },
];

const WordsData = [
  {
    word: 'apple',

    difficulty: 'intermediate',
  },

  {
    word: 'banana',

    difficulty: 'basic',
  },

  {
    word: 'cherry',

    difficulty: 'intermediate',
  },
];

// Similar logic for "relation_many"

async function associateAdminWithUser() {
  const relatedUser0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Admin0 = await Admins.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Admin0?.setUser) {
    await Admin0.setUser(relatedUser0);
  }

  const relatedUser1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Admin1 = await Admins.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Admin1?.setUser) {
    await Admin1.setUser(relatedUser1);
  }

  const relatedUser2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Admin2 = await Admins.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Admin2?.setUser) {
    await Admin2.setUser(relatedUser2);
  }
}

async function associateLearnerWithUser() {
  const relatedUser0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Learner0 = await Learners.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Learner0?.setUser) {
    await Learner0.setUser(relatedUser0);
  }

  const relatedUser1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Learner1 = await Learners.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Learner1?.setUser) {
    await Learner1.setUser(relatedUser1);
  }

  const relatedUser2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Learner2 = await Learners.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Learner2?.setUser) {
    await Learner2.setUser(relatedUser2);
  }
}

// Similar logic for "relation_many"

async function associateParentWithUser() {
  const relatedUser0 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Parent0 = await Parents.findOne({
    order: [['id', 'ASC']],
    offset: 0,
  });
  if (Parent0?.setUser) {
    await Parent0.setUser(relatedUser0);
  }

  const relatedUser1 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Parent1 = await Parents.findOne({
    order: [['id', 'ASC']],
    offset: 1,
  });
  if (Parent1?.setUser) {
    await Parent1.setUser(relatedUser1);
  }

  const relatedUser2 = await Users.findOne({
    offset: Math.floor(Math.random() * (await Users.count())),
  });
  const Parent2 = await Parents.findOne({
    order: [['id', 'ASC']],
    offset: 2,
  });
  if (Parent2?.setUser) {
    await Parent2.setUser(relatedUser2);
  }
}

// Similar logic for "relation_many"

module.exports = {
  up: async (queryInterface, Sequelize) => {
    await Admins.bulkCreate(AdminsData);

    await Avatars.bulkCreate(AvatarsData);

    await Learners.bulkCreate(LearnersData);

    await Parents.bulkCreate(ParentsData);

    await Words.bulkCreate(WordsData);

    await Promise.all([
      // Similar logic for "relation_many"

      await associateAdminWithUser(),

      await associateLearnerWithUser(),

      // Similar logic for "relation_many"

      await associateParentWithUser(),

      // Similar logic for "relation_many"
    ]);
  },

  down: async (queryInterface, Sequelize) => {
    await queryInterface.bulkDelete('admins', null, {});

    await queryInterface.bulkDelete('avatars', null, {});

    await queryInterface.bulkDelete('learners', null, {});

    await queryInterface.bulkDelete('parents', null, {});

    await queryInterface.bulkDelete('words', null, {});
  },
};