test.js

const User = require('./index')
const buildUser = require('../entities/user/index');
const buildDeck = require('../entities/deck/index');
const buildCard = require('../entities/card/index');
const db = require('../db/index');


const testuser1 = {
    username: 'test1',
    email: 'test1',
    password: 'test1'
}

const testuser2 = {
    username: 'test2',
    email: 'test2',
    password: 'test2'
}

const testuser3 = {
    username: 'test3',
    email: 'test3',
    password: 'test3'
}

const testdeck = {
    deckName: 'test',
    cards: [{
        front: 'test',
        back: 'test'
    }]
}

const testcard = {
    front: 'ok',
    back: 'kk'
}


const newDeck = buildDeck(testdeck);
const newCard = buildCard(testcard);

(async () => {
    User.dropDb()
    const newUser1 = await buildUser(testuser1);
    const newUser2 = await buildUser(testuser2);
    const newUser3 = await buildUser(testuser3);
    console.log('adding new user');
    const test1 =  {
        _id: newUser1.getId(),
        username: newUser1.getUserName(),
        email: newUser1.getEmail(),
        password: newUser1.getPassword(),
    };
    const test2 =  {
        _id: newUser2.getId(),
        username: newUser2.getUserName(),
        email: newUser2.getEmail(),
        password: newUser2.getPassword(),
    };
    const test3 =  {
        _id: newUser3.getId(),
        username: newUser3.getUserName(),
        email: newUser3.getEmail(),
        password: newUser3.getPassword(),
    };

    const testInstertUser1 = await User.insertUser(test1);
    const testInstertUser2 = await User.insertUser(test2);
    const testInstertUser3 = await User.insertUser(test3);


    console.log(testInstertUser1);
    console.log(testInstertUser2);
    console.log(testInstertUser3);


    console.log('finding user with id');
    const findUserById = await User.findUserById(test1._id)
    console.log(findUserById);

    console.log('adding deck to user');
    const addDeckToUser = await User.insertDeck(test1._id, {
        deckName: newDeck.getDeckName(),
        cards: newDeck.getCards(),
        _id: newDeck.getId()
    })
    console.log(addDeckToUser);

    console.log('adding card to user');

    const addCardToUsersDeck = await User.insertCard(test1._id, newDeck.getId(), {
        front: newCard.getFront(),
        back: newCard.getBack(),
        hash: newCard.getHash(),
        _id: newCard.getId()
    });
    console.log(addCardToUsersDeck);

    console.log('updating deck name')

    // failing
    const updateDeckName = await User.updateDeckName(test1._id, newDeck.getId(), "i changed the name!")
    console.log(updateDeckName)

    // failing
    const updateCard = await User.updateCard(newUser1.getId(), newCard.getId(), {front: '123', back: '456'})
    console.log(updateCard)

    const removeCard = await User.removeCard(newUser1.getId(), newCard.getId());
    console.log(removeCard);

    const removeDeck = await User.removeDeck(newUser1.getId(), newCard.getId())
    console.log(removeDeck)

})();

User.js

const mongoose = require('mongoose');

const userSchema = new mongoose.Schema({
    username: {type: String, required: true},
    email: {type: String, required: true},
    password: {type: String, required: true},
    decks: [{
        name: {type: String, require: true},
        cards: [{
            front: {type: String, require: true},
            back: {type: String, require: true},
            example: [{type: String}]
        }]
    }]
});

const User = mongoose.model('User', userSchema);
module.exports = User;

userDb.js

module.exports = makeUserDb = (User) => {

    const findUserByName = async (username) => {
        return await User.findOne({username: username});
    }

    const findUserById = async (id) => {
        return await User.findById(id);
    }

    const findCardById = async (userId, cardId) => {
        return await User.find({ _id: userId })
            .select({ 'decks': { $elemMatch: { 'cards': { $elemMatch: { _id: cardId } } } } })
    }

    const findDeckById = async (userId, deckId) => {
        return await User.find({ _id: userId })
            .select({ 'decks': { $elemMatch: { _id: deckId } } })
    }

    // for testing !! 

    const dropDb = async () => {
        User.collection.drop()
    }

    const findUsersDeck = async (passedUser, deckname) => {
        const deck = await User.find({ username: passedUser.getUserName() })
            .select({ 'decks': { $elemMatch: { name: deckname } } });
        return deck[0].decks
    }

    const insertUser = async (newUser) => {
        const userToDb = await User.create({
            _id: newUser._id,
            username: newUser.username,
            email: newUser.email,
            password: newUser.password
        });
        return userToDb;
    }

    const insertDeck = async (userId, passedDeck) => {
        const user = await User.findOne({ _id: userId });
        await user.decks.push({
            name: passedDeck.deckName,
            cards: passedDeck.cards
        });
        await user.save();
        return user.decks;
    }

    // need to fix to go with our entitie structue
    const insertCard = async (userId, deckId, passedCard) => {

        return await User.updateOne({ id: userId, 'decks._id': deckId },
            {
                $push: {
                    'decks.$.cards': {
                        front: passedCard.front,
                        back: passedCard.back,
                        _id: passedCard._id,
                        hash: passedCard.hash
                    }
                }
            });
    }

    const removeDeck = async (userId, deckId) => {
        return user = await User.findOneAndUpdate(
            { _id: userId },
            {
                $pull: { decks: { _id: deckId } }
            }
        )
    }

    const removeCard = async (userId, cardId) => {
        return rCard = await User.findOneAndUpdate(
            { _id: userId },
            {
                $pull: { decks: { cards:  {   _id: cardId } } }
            }
        )
    }


    const updateDeckName = async (userId, deckId, updatedName) => {
        const newDeck = await User.findOneAndUpdate(
            {
                _id: userId,
                decks: { $elemMatch: {_id: deckId}}
            },
            {
                $set: { 'decks.name': updatedName }
            }
        )
        return newDeck
    }

    const updateCard = async (userId, cardId, updatedText) => {
        return await User.findOneAndUpdate({ _id: userId, 'decks.cards._id': cardId },
            {
                $set: { 'cards.front': updatedText.front, 'cards.back': updatedText.back }
            }
        )
    }

    return Object.freeze({
        findUsersDeck,
        findUserById,
        findUserByName,
        findCardById,
        findDeckById,
        insertUser,
        insertDeck,
        insertCard,
        updateCard,
        updateDeckName,
        removeDeck,
        removeCard,
        dropDb
    })
}