sss

Mutation.js

import { ObjectId } from 'mongodb'

const Mutation = {
    createMovie: async (parent, args, { db })  => {
        const newMovie = {
            ...args.input,
            created_at: new Date()
        }
        const insertedResult  = await db.collection('movies').insertOne(newMovie)
        newMovie.id = insertedResult.insetedId
        return newMovie
    },

    updateMovie: async (parent, args, { db }) => {
        const { id, input } = args
        const updateResult = await db.collection('movies').findOneAndUpdate({ _id: ObjectId(id) }, { $set: input }, { returnOriginal: false })
        if (updateResult.value) {
            return updateResult.value
        } else{
            throw new Error('Movie not found')
        }

    },

    deleteMovie: async(parent, args, { db }) => {
        const deleteResult = await db.collection('movies').findOneAndDelete({ _id: ObjectId(args.id) })
        if (deleteResult.value) {
            return true
        } else{
            return false
        }
    }
}

export default Mutation

Query.js

import { ObjectId } from 'mongodb'

// GraphQL resolver 
const Query = {
    movie: async (parent, args, { db }) => {
        const result = await db.collection('movies').findOne({ _id: ObjectId(args.id) });
        if (result) {
            return result;
        } else {
            throw new Error('Movie not found');
        }
    },
    movies: async (parent, args, { db }) => {
        const { filter, paging, sorting } = args;
        const { sortBy, sort } = sorting;
        const { first, start } = paging;
        const { genre, createdBetween, yearBetween, ratingBetween } = filter;
        let query = {};
        if (genre) {
            query.genre = genre;
        }
        if (createdBetween) {
            query.created_at = {
                $gte: new Date(createdBetween.start),
                $lte: new Date(createdBetween.end)
            };
        }
        if (yearBetween) {
            query.year = {
                $gte: yearBetween.start,
                $lte: yearBetween.end
            };
        }
        if (ratingBetween) {
            query.rating = {
                $gte: ratingBetween.start,
                $lte: ratingBetween.end
            };
        }
        const result = await db.collection('movies').find(query).sort({ [sortBy]: sort }).skip(start).limit(first).toArray();
        return result;  
    },
    totalMovies: async (parent, args, { db }) => {
        const cnt = await db.collection('movies').estimatedDocumentCount()
        return cnt;
    }
}

export default Query

server-index.js

import { ApolloServer } from 'apollo-server-express'
import resolvers from './resolvers/index.js'
import { MongoClient } from 'mongodb'
import * as fs from 'fs';
import expressPlayground from 'graphql-playground-middleware-express'
import express from 'express';

const graphQLPlayground = expressPlayground.default

var typeDefs = fs.readFileSync('./src/schema.graphql', 'utf-8')

async function start() {
    const app = express()
    const MONGO_DB = "mongodb://127.0.0.1:27017/graphql-test"
    let db 
    try {
        const client = await MongoClient.connect(MONGO_DB, {
            useNewUrlParser: true,
            useUnifiedTopology: true
        })
        db = client.db()
        console.log('Connected to MongoDB')
    } catch (error) {
        console.log('Error connecting to MongoDB', error)
        process.exit(1)
    }

    const server = new ApolloServer({typeDefs, resolvers, context: {db}})
    await server.start()
    server.applyMiddleware({app})

    app.get('/playground', graphQLPlayground({ endpoint: '/graphql' }))
    app.listen({ port: 4000 }, () => {
        console.log('Apollo Server on http://localhost:4000/playground')
    })
}

start()

sosolver_index.js

import Query from './Query.js'
import Mutation from './Mutation.js'
import Type from './Type.js'

const resolvers = {
    Query,
    Mutation,
    ...Type
}

export default resolvers;

Type.js

import { GraphQLScalarType } from 'graphql'


const Type = {
    Movie: {
        id: (parent) => parent.id || parent._id,
        url: (parent) => `http://localhost:4000/movies/${parent.id|| parent._id}`
    }
}

export default Type