Today i am going to show you how to write simple fetch data from mongoDB using Apollographql
npm i apollo-server-express express graphql lodash mongoose nodemon
after install these
import { ApolloServer } from 'apollo-server-express';
import { ApolloServerPluginDrainHttpServer } from 'apollo-server-core';
import express from 'express';
import http from 'http';
import {typeDefs} from './utils/typeDefs.js'
import {resolvers} from './utils/resolvers.js'
import mongoose from 'mongoose'
async function startApolloServer(typeDefs, resolvers) {
const app = express();
const httpServer = http.createServer(app);
// Same ApolloServer initialization as before, plus the drain plugin.
const server = new ApolloServer({
typeDefs,
resolvers,
plugins: [ApolloServerPluginDrainHttpServer({ httpServer })],
});
await server.start();
server.applyMiddleware({
app,
path: '/',
});
app.use((req,res)=>{
res.send('Hello frontend')
})
//mongoDB connection
await mongoose.connect('mongodb://localhost:27017/demo')
console.log('mongoose connected')
// Modified server startup
await new Promise(resolve => httpServer.listen({ port: 4000 }, resolve));
console.log(`🚀 Server ready at http://localhost:4000${server.graphqlPath}`);
}
startApolloServer(typeDefs,resolvers); // start the server
A schema is a JSON object that defines the the structure and contents of your data
mongoDB models
// const mongoose = require('mongoose');
import mongoose from 'mongoose'
const schema = new mongoose.Schema({
message:{
type:String,
required:true
},
},{collection:'test'})
export const test = mongoose.model('test',schema) //collection name and schema name
A GraphQL schema is a description of the data clients can request from a GraphQL API. It also defines the queries and mutation functions that the client can use to read and write data from the GraphQL server
import { gql } from "apollo-server-express";
export const typeDefs = gql`
type Query {
getmessages : [Message!]!
getlimitmessage(limit : Int) : [Logs!]! // if you want limited no of messages just create a schema like this
}
type Message {
message: MessageInput!
}
input MessageInput {
message: String,
}
type Mutation {
createMessage(message: MessageInput!): Message
}
resolvers : A resolver is a function that's responsible for populating the data for a single field in your schema
import {test} from './models.js'
import _ from 'lodash'
export const resolvers = {
Query : {
getmessages: async ()=>{
return await test.find() //here i am using lodash
//function to get all the messages from the database
},
getlimitmessage: async (limit)=>{
return await _.takeRight(test,limit) //get limited number of messages from the database
}
},
Mutation : {
createMessage: (_,args,) => {
let addMessage = new test(args.message)
return addMessage.save()
}
}
}
Top comments (0)