Thanks prettier

Author: JoviDeCroock

.prettierignore

@@ -7,4 +7,5 @@
 /denoDist
 /websiteDist
 /website/out
+/website/**/*.mdx
 .next

website/pages/authentication-and-express-middleware.mdx

@@ -11,37 +11,37 @@ To use middleware with a GraphQL resolver, just use the middleware like you woul
 
 For example, let's say we wanted our server to log the IP address of every request, and we also want to write an API that returns the IP address of the caller. We can do the former with middleware, and the latter by accessing the `request` object in a resolver. Here's server code that implements this:
 
-<Tabs items={['Template', 'Classes']}>
+<Tabs items={['SDL', 'Code']}>
   <Tabs.Tab>
 ```js
 const express = require('express');
 const { createHandler } = require('graphql-http/lib/use/express');
 const { buildSchema } = require('graphql');
 
-const schema = buildSchema(` type Query { ip: String }`);
+const schema = buildSchema(`type Query { ip: String }`);
 
 function loggingMiddleware(req, res, next) {
-console.log('ip:', req.ip);
-next();
+  console.log('ip:', req.ip);
+  next();
 }
 
 const root = {
-ip(args, context) {
-return context.ip;
-},
+  ip(args, context) {
+    return context.ip;
+  },
 };
 
 const app = express();
 app.use(loggingMiddleware);
 app.all(
-'/graphql',
-createHandler({
-schema: schema,
-rootValue: root,
-context: (req) => ({
-ip: req.raw.ip,
-}),
-}),
+  '/graphql',
+  createHandler({
+    schema: schema,
+    rootValue: root,
+    context: (req) => ({
+      ip: req.raw.ip,
+    }),
+  }),
 );
 app.listen(4000);
 console.log('Running a GraphQL API server at localhost:4000/graphql');

website/pages/basic-types.mdx

@@ -14,36 +14,42 @@ To use a list type, surround the type in square brackets, so `[Int]` is a list o
 
 Each of these types maps straightforwardly to JavaScript, so you can just return plain old JavaScript objects in APIs that return these types. Here's an example that shows how to use some of these basic types:
 
-<Tabs items={['Template', 'Classes']}>
+<Tabs items={['SDL', 'Code']}>
   <Tabs.Tab>
 ```js
 const express = require('express');
 const { createHandler } = require('graphql-http/lib/use/express');
 const { buildSchema } = require('graphql');
 
 // Construct a schema, using GraphQL schema language
-const schema = buildSchema(` type Query { quoteOfTheDay: String random: Float! rollThreeDice: [Int] }`);
+const schema = buildSchema(`
+  type Query {
+    quoteOfTheDay: String
+    random: Float!
+    rollThreeDice: [Int]
+  }
+`);
 
 // The root provides a resolver function for each API endpoint
 const root = {
-quoteOfTheDay() {
-return Math.random() < 0.5 ? 'Take it easy' : 'Salvation lies within';
-},
-random() {
-return Math.random();
-},
-rollThreeDice() {
-return [1, 2, 3].map((\_) => 1 + Math.floor(Math.random() \* 6));
-},
+  quoteOfTheDay() {
+    return Math.random() < 0.5 ? 'Take it easy' : 'Salvation lies within';
+  },
+  random() {
+    return Math.random();
+  },
+  rollThreeDice() {
+    return [1, 2, 3].map((\_) => 1 + Math.floor(Math.random() \* 6));
+  },
 };
 
 const app = express();
 app.all(
-'/graphql',
-createHandler({
-schema: schema,
-rootValue: root,
-}),
+  '/graphql',
+  createHandler({
+    schema: schema,
+    rootValue: root,
+  }),
 );
 app.listen(4000);
 console.log('Running a GraphQL API server at localhost:4000/graphql');

website/pages/constructing-types.mdx

@@ -10,7 +10,7 @@ When you are using the `GraphQLSchema` constructor to create a schema, instead o
 
 For example, let's say we are building a simple API that lets you fetch user data for a few hardcoded users based on an id. Using `buildSchema` we could write a server with:
 
-<Tabs items={['Template', 'Classes']}>
+<Tabs items={['SDL', 'Code']}>
   <Tabs.Tab>
 ```js
 const express = require('express');
@@ -19,40 +19,40 @@ const { buildSchema } = require('graphql');
 
 const schema = buildSchema(`
 type User {
-id: String
-name: String
+  id: String
+  name: String
 }
 
 type Query {
-user(id: String): User
+  user(id: String): User
 }
 `);
 
 // Maps id to User object
 const fakeDatabase = {
-a: {
-id: 'a',
-name: 'alice',
-},
-b: {
-id: 'b',
-name: 'bob',
-},
+  a: {
+    id: 'a',
+    name: 'alice',
+  },
+  b: {
+    id: 'b',
+    name: 'bob',
+  },
 };
 
 const root = {
-user({ id }) {
-return fakeDatabase[id];
-},
+  user({ id }) {
+    return fakeDatabase[id];
+  },
 };
 
 const app = express();
 app.all(
-'/graphql',
-createHandler({
-schema: schema,
-rootValue: root,
-}),
+  '/graphql',
+  createHandler({
+    schema: schema,
+    rootValue: root,
+  }),
 );
 app.listen(4000);
 console.log('Running a GraphQL API server at localhost:4000/graphql');

website/pages/getting-started.mdx

@@ -30,7 +30,7 @@ npm install graphql --save
 
 To handle GraphQL queries, we need a schema that defines the `Query` type, and we need an API root with a function called a “resolver” for each API endpoint. For an API that just returns “Hello world!”, we can put this code in a file named `server.js`:
 
-<Tabs items={['Template', 'Classes']}>
+<Tabs items={['SDL', 'Code']}>
   <Tabs.Tab>
 ```javascript
 const { graphql, buildSchema } = require('graphql');
@@ -40,18 +40,19 @@ const schema = buildSchema(`type Query { hello: String } `);
 
 // The rootValue provides a resolver function for each API endpoint
 const rootValue = {
-hello() {
-return 'Hello world!';
-},
+  hello() {
+    return 'Hello world!';
+  },
 };
 
 // Run the GraphQL query '{ hello }' and print out the response
 graphql({
-schema,
-source: '{ hello }',
-rootValue,
-}).then((response) => {
-console.log(response);
+  schema,
+  source: '{ hello }',
+  rootValue,
+  }).then((response) => {
+    console.log(response);
+  });
 });
 
 ````

website/pages/mutations-and-input-types.mdx

@@ -8,17 +8,16 @@ If you have an API endpoint that alters data, like inserting data into a databas
 
 Let's say we have a “message of the day” server, where anyone can update the message of the day, and anyone can read the current one. The GraphQL schema for this is simply:
 
-<Tabs items={['Template', 'Classes']}>
+<Tabs items={['SDL', 'Code']}>
   <Tabs.Tab>
 ```graphql
 type Mutation {
   setMessage(message: String): String
 }
 
 type Query {
-getMessage: String
+  getMessage: String
 }
-
 ````
   </Tabs.Tab>
   <Tabs.Tab>
@@ -69,7 +68,7 @@ You don't need anything more than this to implement mutations. But in many cases
 
 For example, instead of a single message of the day, let's say we have many messages, indexed in a database by the `id` field, and each message has both a `content` string and an `author` string. We want a mutation API both for creating a new message and for updating an old message. We could use the schema:
 
-<Tabs items={['Template', 'Classes']}>
+<Tabs items={['SDL', 'Code']}>
   <Tabs.Tab>
 ```graphql
 input MessageInput {
@@ -78,18 +77,18 @@ input MessageInput {
 }
 
 type Message {
-id: ID!
-content: String
-author: String
+  id: ID!
+  content: String
+  author: String
 }
 
 type Query {
-getMessage(id: ID!): Message
+  getMessage(id: ID!): Message
 }
 
 type Mutation {
-createMessage(input: MessageInput): Message
-updateMessage(id: ID!, input: MessageInput): Message
+  createMessage(input: MessageInput): Message
+  updateMessage(id: ID!, input: MessageInput): Message
 }
 
 ````
@@ -166,80 +165,79 @@ Naming input types with `Input` on the end is a useful convention, because you w
 
 Here's some runnable code that implements this schema, keeping the data in memory:
 
-<Tabs items={['Template', 'Classes']}>
+<Tabs items={['SDL', 'Code']}>
   <Tabs.Tab>
 ```js
 const express = require('express');
 const { createHandler } = require('graphql-http/lib/use/express');
 const { buildSchema } = require('graphql');
 
 // Construct a schema, using GraphQL schema language
-const schema = buildSchema(/_ GraphQL _/ `
+const schema = buildSchema(`
 input MessageInput {
-content: String
-author: String
+  content: String
+  author: String
 }
 
 type Message {
-id: ID!
-content: String
-author: String
+  id: ID!
+  content: String
+  author: String
 }
 
 type Query {
-getMessage(id: ID!): Message
+  getMessage(id: ID!): Message
 }
 
 type Mutation {
-createMessage(input: MessageInput): Message
-updateMessage(id: ID!, input: MessageInput): Message
+  createMessage(input: MessageInput): Message
+  updateMessage(id: ID!, input: MessageInput): Message
 }
 `);
 
 // If Message had any complex fields, we'd put them on this object.
 class Message {
-constructor(id, { content, author }) {
-this.id = id;
-this.content = content;
-this.author = author;
-}
+  constructor(id, { content, author }) {
+    this.id = id;
+    this.content = content;
+    this.author = author;
+  }
 }
 
 // Maps username to content
 const fakeDatabase = {};
 
 const root = {
-getMessage({ id }) {
-if (!fakeDatabase[id]) {
-throw new Error('no message exists with id ' + id);
-}
-return new Message(id, fakeDatabase[id]);
-},
-createMessage({ input }) {
-// Create a random id for our "database".
-const id = require('crypto').randomBytes(10).toString('hex');
+  getMessage({ id }) {
+    if (!fakeDatabase[id]) {
+      throw new Error('no message exists with id ' + id);
+    }
+    return new Message(id, fakeDatabase[id]);
+  },
+  createMessage({ input }) {
+    // Create a random id for our "database".
+    const id = require('crypto').randomBytes(10).toString('hex');
 
     fakeDatabase[id] = input;
     return new Message(id, input);
-
-},
-updateMessage({ id, input }) {
-if (!fakeDatabase[id]) {
-throw new Error('no message exists with id ' + id);
-}
-// This replaces all old data, but some apps might want partial update.
-fakeDatabase[id] = input;
-return new Message(id, input);
-},
+  },
+  updateMessage({ id, input }) {
+    if (!fakeDatabase[id]) {
+      throw new Error('no message exists with id ' + id);
+    }
+    // This replaces all old data, but some apps might want partial update.
+    fakeDatabase[id] = input;
+    return new Message(id, input);
+  },
 };
 
 const app = express();
 app.all(
-'/graphql',
-createHandler({
-schema: schema,
-rootValue: root,
-}),
+  '/graphql',
+  createHandler({
+    schema: schema,
+    rootValue: root,
+  }),
 );
 app.listen(4000, () => {
 console.log('Running a GraphQL API server at localhost:4000/graphql');