chore: format & npm add over install

Author: jasonkuhrt

.prettierignore

@@ -1,2 +1,4 @@
 dist
 .now
+/website/*
+!/website/content

.prettierrc.js

@@ -2,7 +2,7 @@ module.exports = {
   ...require('@prisma-labs/prettier-config'),
   overrides: [
     {
-      files: ['prisma.md'],
+      files: ['prisma.md', 'prisma.mdx'],
       options: {
         printWidth: 35,
       },

docs/api/modules/main/exports/settings.md

@@ -160,7 +160,6 @@ false | { formatError?: (authConfig: AuthConfig) => Error }
 
 Disable or configure the `authorize` field behaviour.
 
-
 #### `schema.rootTypingsGlobPattern`
 
 <div class="OneLineSignature"></div>

docs/components/logger/about.md

@@ -3,5 +3,5 @@
 Delightful logging library that is pretty practical & performant
 
 ```cli
-npm install @nexus/logger
+npm add @nexus/logger
 ```

docs/components/schema/about.md

@@ -1,7 +1,7 @@
 # `@nexus/schema`
 
 ```cli
-npm install @nexus/schema
+npm add @nexus/schema
 ```
 
 #### Why Nexus? {docsify-ignore}

docs/components/schema/api/copy/best-practices.md

@@ -38,17 +38,17 @@ code chunks. The most common approach is to break up types into files, either on
 However you end up structuring your files, they ultimately all need to be imported and passed to the `makeSchema` function, and keeping a consistent approach to file naming makes it simpler
 
 ```ts
-import * as userTypes from "./schema/user";
-import * as postTypes from "./schema/post";
-import * as commentTypes from "./schema/comment";
+import * as userTypes from './schema/user'
+import * as postTypes from './schema/post'
+import * as commentTypes from './schema/comment'
 ```
 
 You could also consolidate this in an `index.js` or similar export file:
 
 ```ts
-export * from "./user";
-export * from "./post";
-export * from "./comment";
+export * from './user'
+export * from './post'
+export * from './comment'
 ```
 
 Using that file to build the schema:

docs/components/schema/api/copy/ecosystem-plugins.md

@@ -11,12 +11,12 @@ sidebar_label: nexus-prisma
 `nexus-prisma` is for bridging [Prisma](https://www.prisma.io) and [Nexus](https://nexus.js.org). It extends the Nexus DSL `t` with `.model` and `.crud` making it easy to project Prisma models and expose operations against them in your GraphQL API. Resolvers are dynamically created for you removing the need for traditional ORMs/query builders like TypeORM, Sequelize, or Knex. Out-of-box features include pagination, filtering, and ordering. When you do need to drop down into custom resolvers a [`Photon`](https://photonjs.prisma.io) instance on `ctx` will be ready to serve you, the same great tool `nexus-prisma` itself bulids upon.
 
 ```ts
-import { nexusPrismaPlugin } from "nexus-prisma";
+import { nexusPrismaPlugin } from 'nexus-prisma'
 
 makeSchema({
   // ...
   plugin: [nexusPrismaPlugin()],
-});
+})
 ```
 
 If you are still using `nexus-prisma@0.3` / Prisma 1 you can find the old docs [here](https://github.com/prisma-labs/nexus/blob/8cf2d6b3e22a9dec1f7c23f384bf33b7be5a25cc/docs/database-access-with-prisma-v2.md).

docs/components/schema/api/copy/getting-started.md

@@ -29,8 +29,8 @@ GraphQL Nexus can be installed with either `npm` or `yarn`.
 <!--npm-->
 
 ```sh
-npm install nexus
-npm install graphql # required as a peer dependency
+npm add nexus
+npm add graphql # required as a peer dependency
 ```
 
 <!--yarn-->
@@ -56,47 +56,47 @@ import {
   intArg,
   arg,
   makeSchema,
-} from "@nexus/schema";
+} from '@nexus/schema'
 
 const Node = interfaceType({
-  name: "Node",
+  name: 'Node',
   definition(t) {
-    t.id("id", { description: "Unique identifier for the resource" });
-    t.resolveType(() => null);
+    t.id('id', { description: 'Unique identifier for the resource' })
+    t.resolveType(() => null)
   },
-});
+})
 
 const Account = objectType({
-  name: "Account",
+  name: 'Account',
   definition(t) {
-    t.implements(Node); // or t.implements("Node")
-    t.string("username");
-    t.string("email");
+    t.implements(Node) // or t.implements("Node")
+    t.string('username')
+    t.string('email')
   },
-});
+})
 
 const StatusEnum = enumType({
-  name: "StatusEnum",
-  members: ["ACTIVE", "DISABLED"],
-});
+  name: 'StatusEnum',
+  members: ['ACTIVE', 'DISABLED'],
+})
 
 const Query = queryType({
   definition(t) {
-    t.field("account", {
+    t.field('account', {
       type: Account, // or "Account"
       args: {
         name: stringArg(),
-        status: arg({ type: "StatusEnum" }),
+        status: arg({ type: 'StatusEnum' }),
       },
-    });
-    t.list.field("accountsById", {
+    })
+    t.list.field('accountsById', {
       type: Account, // or "Account"
       args: {
         ids: intArg({ list: true }),
       },
-    });
+    })
   },
-});
+})
 
 // Recursively traverses the value passed to types looking for
 // any valid Nexus or graphql-js objects to add to the schema,
@@ -105,7 +105,7 @@ const schema = makeSchema({
   types: [Account, Node, Query, StatusEnum],
   // or types: { Account, Node, Query }
   // or types: [Account, [Node], { Query }]
-});
+})
 ```
 
 ## Nullability & Default Values
@@ -132,13 +132,13 @@ One common idiom in GraphQL is exposing fields that mask or rename the property
 
 ```ts
 const User = objectType({
-  name: "User",
+  name: 'User',
   definition(t) {
-    t.id("id", (o) => o.user_id);
-    t.string("name", (o) => o.user_name);
-    t.string("description", (o) => o.user_description);
+    t.id('id', (o) => o.user_id)
+    t.string('name', (o) => o.user_name)
+    t.string('description', (o) => o.user_description)
   },
-});
+})
 ```
 
 ## Auto-Generated Artifacts
@@ -153,10 +153,10 @@ const schema = makeSchema({
     /* All schema types provided here */
   ],
   outputs: {
-    schema: path.join(__dirname, "../../my-schema.graphql"),
-    typegen: path.join(__dirname, "../../my-generated-types.d.ts"),
+    schema: path.join(__dirname, '../../my-schema.graphql'),
+    typegen: path.join(__dirname, '../../my-generated-types.d.ts'),
   },
-});
+})
 ```
 
 Read more about how the automatic [type generation](type-generation.md) works.

docs/components/schema/api/copy/library-authors.md

@@ -11,36 +11,36 @@ If you are a library author building tools for GraphQL, it is recommended that y
 One example of this pattern would be for creating relay-style connections:
 
 ```ts
-export const UserConnectionTypes = connectionType("User");
+export const UserConnectionTypes = connectionType('User')
 ```
 
 Where `connectionType` is really just a wrapper creating two `objectTypes`:
 
 ```ts
-import { core, objectType } from "@nexus/schema";
+import { core, objectType } from '@nexus/schema'
 
 export function connectionType(name: core.AllOutputTypes) {
   const Connection = objectType({
     name: `${name}Connection`,
     definition(t) {
-      t.field("edges", { type: `${name}Edge` });
+      t.field('edges', { type: `${name}Edge` })
     },
-  });
+  })
   const Edge = objectType({
     name: `${name}Edge`,
     definition(t) {
-      t.id("cursor", (root) => `${name}:${root.id}`);
-      t.field("node", { type: name });
+      t.id('cursor', (root) => `${name}:${root.id}`)
+      t.field('node', { type: name })
     },
-  });
+  })
   const PageInfo = objectType({
     name: `${name}PageInfo`,
     definition(t) {
-      t.boolean("hasNextPage");
-      t.boolean("hasPreviousPage");
+      t.boolean('hasNextPage')
+      t.boolean('hasPreviousPage')
     },
-  });
-  return { Connection, Edge, PageInfo };
+  })
+  return { Connection, Edge, PageInfo }
 }
 ```