Splitting resolvers into separate files, causes a circular dependency.

[KennethJoris]

Thanks a lot for the free course.

Splitting up the resolvers index.js from branch/video #6, into folders like user.js and event.js causes a circular dependency, since users requires logic from events, and visa versa.

How do you solve these kind of circular dependency issues when different models and their "Polulators" require one another?
(getUserById => getEventsById => getUserById => getEventsById => ...)

file: user.js
Warning: Accessing non-existent property 'getEventsById' of module exports inside circular dependency
createdEvents: getEventsById(createdEvents) => TypeError: getEventsById is not a function

// @ts-check
const { User } = require('../models');
const { hash } = require('bcryptjs');
const { getEventsById } = require('./event');

module.exports = {
	// Poplulators
	getUserById: async (userID) => {
		try {
			const {
				_doc: { createdEvents, ...rest }
			} = await User.findById(userID);
			return {
				createdEvents: getEventsById(createdEvents),
				...rest
			};
		} catch (error) {
			throw error;
		}
	},

	// Resolvers
	users: async () => {
		try {
			const users = await User.find();
			return users.map(({ _doc: { password, createdEvents, ...rest } }) => {
				return {
					password: null, // Security: Hide user password in result
					createdEvents: getEventsById(createdEvents), // populate the user.createdEvents field with Event data
					...rest
				};
			});
		} catch (error) {
			throw error;
		}
	},
	user: async ({ email }) => {
		try {
			const {
				_doc: { password, createdEvents, ...rest }
			} = await User.findOne({ email: email });
			return {
				password: null,
				createdEvents: getEventsById(createdEvents),
				...rest
			};
		} catch (error) {
			throw error;
		}
	},
	createUser: async ({ userInput: { email, password } }) => {
		try {
			// Check if user already exists
			const foundUser = await User.findOne({ email: email });

			// User with email found
			if (foundUser) {
				throw new Error('User already exists');
			}

			// New user
			// Security: Hash user password
			const hashedPassword = await hash(password, 12);

			// Create a new MongoDB user model with data
			const user = new User({
				email: email,
				password: hashedPassword
			});

			// Save user to MongoDB and return result
			const { email: userEmail, password: userPassword } = await user.save();

			// Security: Hide user password in result
			return { email: userEmail, password: null };
		} catch (error) {
			throw error;
		}
	}
};

file: event.js
Warning: Accessing non-existent property 'getUserById' of module exports inside circular dependency
creator: getUserById(creator) => TypeError: getUserById is not a function

// @ts-check
const { User, Event } = require('../models');
const { getUserById } = require('./user');

module.exports = {
	// Poplulators
	getEventsById: async (eventIDs) => {
		try {
			const events = await Event.find({ _id: { $in: eventIDs } });
			return events.map(({ _doc: { creator, date, ...rest } }) => {
				return {
					date: new Date(date).toISOString(),
					creator: getUserById(creator),
					...rest
				};
			});
		} catch (error) {
			throw error;
		}
	},

	// Resolvers
	events: async () => {
		try {
			const events = await Event.find();
			return events.map(({ _doc: { creator, date, ...rest } }) => {
				return {
					date: new Date(date).toISOString(),
					creator: getUserById(creator),
					...rest
				};
			});
		} catch (error) {
			throw error;
		}
	},
	createEvent: async ({ eventInput: { title, description, price, date } }) => {
		// Create a new MongoDB event model with data
		const event = new Event({
			title: title,
			description: description,
			price: +price,
			date: new Date(date),
			creator: '60ecc8c9b01258b09dc23aa8'
		});

		// eventDate temp store
		let storedEvent;

		// Save event to MongoDB and return result
		// Add event to user.createdEvents
		try {
			const { _doc: eventData } = await event.save();

			// Store even data
			// Reference Event creator to User
			storedEvent = {
				...eventData,
				date: new Date(eventData.date).toISOString(),
				creator: getUserById(eventData.creator)
			};

			// Find creator
			// To add event to user.createdEvents
			const foundUser = await User.findById(eventData.creator);

			// no User found
			if (!foundUser) {
				throw new Error('No user found');
			}

			// Add event _id to user.createdEVents
			foundUser.createdEvents.push(eventData._id);
			// Save (same as update) user
			await foundUser.save();

			// return the stored event
			return storedEvent;
		} catch (error) {
			throw error;
		}
	}
};