教MERN堆栈说GraphQL

1
npm install graphql graphql-tag @apollo/subgraph @apollo/server

1
type Query {
2
  record(id:ID!): Record
3
  records: [Record]
4
}
5

6
type Mutation {
7
  createRecord(name: String!, position: String, level: String): Record
8
  deleteRecord(id: ID!): Boolean
9
  updateRecord(id: ID! name: String, position: String, level: String): Record
10
}
11

12
type Record {
13
  id: ID
14
  name: String
15
  position: String
16
  level: String
17
}

1
import db from "./db/connection.js";
2

3
const resolvers = {
4
  Record: {
5
    id: (parent) => parent.id ?? parent._id,
6
  },
7
  Query: {
8
    async record(_, { id }) {
9
      let collection = await db.collection("records");
10
      let query = { _id: new ObjectId(id) };
11

12
      return await collection.findOne(query);
13
    },
14
    async records(_, __, context) {
15
      let collection = await db.collection("records");
16
      const records = await collection.find({}).toArray();
17
      return records;
18
    },
19
  },
20
  Mutation: {
21
    async createRecord(_, { name, position, level }, context) {
22
      let collection = await db.collection("records");
23
      const insert = await collection.insertOne({ name, position, level });
24
      if (insert.acknowledged)
25
        return { name, position, level, id: insert.insertedId };
26
      return null;
27
    },
28
    async updateRecord(_, args, context) {
29
      const id = new ObjectId(args.id);
30
      let query = { _id: new ObjectId(id) };
31
      let collection = await db.collection("records");
32
      const update = await collection.updateOne(
33
        query,
34
        { $set: { ...args } }
35
      );
36

37
      if (update.acknowledged)
38
        return await collection.findOne(query);
39

40
      return null;
41
    },
42
    async deleteRecord(_, { id }, context) {
43
      let collection = await db.collection("records");
44
      const dbDelete = await collection.deleteOne({ _id: new ObjectId(id) });
45
      return dbDelete.acknowledged && dbDelete.deletedCount == 1 ? true : false;
46
    },
47
  },
48
};
49

50
export default resolvers;

1
import express from 'express';
2
import cors from 'cors';
3
import records from "./routes/record.js";
4

5
import gql from "graphql-tag";
6
import { ApolloServer } from '@apollo/server';
7
import { buildSubgraphSchema } from '@apollo/subgraph';
8
import { expressMiddleware } from '@apollo/server/express4';
9
import resolvers from "./resolvers.js";
10
import { readFileSync } from "fs";
11

12
const PORT = process.env.PORT || 5050;
13
const app = express();
14

15
app.use(cors());
16
app.use(express.json());
17

18
const typeDefs = gql(
19
    readFileSync("schema.graphql", {
20
      encoding: "utf-8",
21
    })
22
  );
23

24
const server = new ApolloServer({
25
    schema: buildSubgraphSchema({ typeDefs, resolvers }),
26
});
27
// Note you must call `start()` on the `ApolloServer`
28
// instance before passing the instance to `expressMiddleware`
29
await server.start();
30

31
app.use("/record", records);
32

33
// start the Express server
34
app.listen(PORT, () => {
35
  console.log(`Server is running on port: ${PORT}`);
36
});

1
app.use("/record", records);
2
// Specify the path to mount the server
3
app.use(
4
  '/graphql',
5
  cors(),
6
  express.json(),
7
  expressMiddleware(server),
8
);
9

10
app.listen(PORT, () => {
11
  console.log(`Server is running on port: ${PORT}`);
12
});

1
npm start

1
query GetRecords {
2
  records {
3
    name
4
    position
5
    level
6
  }
7
}