chore(docs): update to use new 0.19 api (#667)

Author: Jason Kuhrt

docs/content/010-getting-started/03-tutorial/03-chapter-2-writing-your-first-schema.mdx

@@ -149,17 +149,15 @@ We'll start by letting API clients read the drafts of your blog.
 <block>
 
 ```ts
-// api/graphql/Post.ts      // 1
+// api/graphql/Post.ts                   // 1
 
 import { objectType, extendType } from '@nexus/schema'
 
 export const PostQuery = extendType({
-  type: 'Query',            // 2
+  type: 'Query',                         // 2
   definition(t) {
-    t.field('drafts', {     // 3
-      nullable: false,      // 4
-      type: 'Post',         // 5
-      list: true,           // 6
+    t.nonNull.list.field('drafts', {     // 3, 4, 5
+      type: 'Post',                      // 6, 7
     })
   },
 })
@@ -181,19 +179,20 @@ type Query {
 
 1. The Query object is a central place in your schema where many other types will appear. Like before with the modular GraphQL types decision we again can decide to be modular here. We could either create a new `api/graphql/Query.ts` module (not modular), or we could _collocate_ the exposure of Post object with its definition in `api/graphql/Post.ts` (modular). Staying consistent with before, we'll take the modular way.
 1. To achieve collocation in Nexus we'll use `schema.extendType`. Its API is _very_ similar to `schema.objectType` with the difference that the defined fields are merged into the _targeted_ type.
+1. `.nullable` specifies that clients will always get a value for this field. By default, in Nexus, all "output types" (types returned by fields) are nullable. This is for [best practice reasons](https://graphql.org/learn/best-practices/#nullability). In this case though we indeed want to guarantee that a list will always be returned, never `null`.
+   If you're ever dissatisfied with Nexus' defaults, not to worry, [you can change them](https://www.nexusjs.org/#/api/modules/main/exports/settings?id=schemanullableinputs).
+1. `.list` augments the field's type spec, making it wrapped by a List type. Here, a `[Post]`.
 1. The first parameter specifies the field's name, here `drafts`
-1. `nullable: false` specifies that clients will always get a value for this field. By default, in Nexus, all "output types" (types returned by fields) are nullable. This is for [best practice reasons](https://graphql.org/learn/best-practices/#nullability). In this case though we indeed want to guarantee that a list will always be returned, never `null`.
+1. `type: 'Post'` specifies what the field's type should be. Here, a `Post`
+1. Nexus also allows you to specifiy lists and nullability on the type field. This example could be rewritten like so 👇
 
-   If you're ever dissatisfied with Nexus' defaults, not to worry, [you can change them](https://www.nexusjs.org/#/api/modules/main/exports/settings?id=schemanullableinputs).
+  ```ts
+  t.field('drafts', {
+    type: nonNull(list('Post')),
+  })
+  ```
 
-1. `type: 'Post'` specifies what the field's type should be. Here, a `Post`
-1. `list: true` augments the field's type spec, making it wrapped by a List type. Here, a `[Post]`. Nexus also provides the following shorthand for this 👇
 
-   ```ts
-   definition(t) {
-     t.list.field('drafts', { ... })
-   }
-   ```
 
 <div class="NextIs SectionDivider"></div>
 
@@ -223,9 +222,8 @@ import { extendType } from '@nexus/schema'
 export const PostQuery = extendType({
   type: 'Query',
   definition(t) {
-    t.field('drafts', {
+    t.nonNull.list.field('drafts', {
       type: 'Post',
-      list: true,
 +      resolve() {
 +        return [{ id: 1, title: 'Nexus', body: '...', published: false }]
 +      },
@@ -246,9 +244,8 @@ import { extendType } from '@nexus/schema'
 export const PostQuery = extendType({
   type: 'Query',
   definition(t) {
-    t.field('drafts', {
+    t.nonNull.list.field('drafts', {
       type: 'Post',
-      list: true,
       resolve() {
         return [{ id: 1, title: 'Nexus', body: '...', published: false }]
       },

docs/content/010-getting-started/03-tutorial/04-chapter-3-adding-mutations-to-your-api.mdx

@@ -241,9 +241,8 @@ As before we will take the collocation approach.
 export const PostMutation = extendType({
   type: 'Mutation',
   definition(t) {
-    t.field('createDraft', {
+    t.nonNull.field('createDraft', {
       type: 'Post',
-      nullable: false,
       resolve(_root, args, ctx) {
         ctx.db.posts.push(/*...*/)
         return // ...
@@ -282,12 +281,11 @@ import { extendType, stringArg } from '@nexus/schema'
 export const PostMutation = extendType({
   type: 'Mutation',
   definition(t) {
-    t.field('createDraft', {
+    t.nonNull.field('createDraft', {
       type: 'Post',
-      nullable: false,
 +      args: {                                        // 1
-+        title: stringArg({ required: true }),        // 2
-+        body: stringArg({ required: true }),         // 2
++        title: nonNull(stringArg()),                 // 2
++        body: nonNull(stringArg()),                  // 2
 +      },
       resolve(_root, args, ctx) {
 +        const draft = {
@@ -317,12 +315,11 @@ import { extendType, stringArg } from '@nexus/schema'
 export const PostMutation = extendType({
   type: 'Mutation',
   definition(t) {
-    t.field('createDraft', {
+    t.nonNull.field('createDraft', {
       type: 'Post',
-      nullable: false,
       args: {                                        // 1
-        title: stringArg({ required: true }),        // 2
-        body: stringArg({ required: true }),         // 2
+        title: nonNull(stringArg()),                 // 2
+        body: nonNull(stringArg()),                  // 2
       },
       resolve(_root, args, ctx) {
         const draft = {
@@ -351,7 +348,7 @@ Mutation {
 ```
 
 1. Add an `args` property to the field definition to define its args. Keys are arg names and values are type specifications.
-2. Use the Nexus helpers for defining an arg type. There is one such helper for every GraphQL scalar such as `intArg` and `booleanArg`. If you want to reference a type like some InputObject then use `arg({ type: "..." })`.
+2. Use the Nexus helpers for defining an arg type. There is one such helper for every GraphQL scalar such as `intArg` and `booleanArg`. If you want to reference a type like some InputObject then use `arg({ type: "..." })`. You can use the helpers `nonNull` and `nullable` to adjust the nullability type of the arg. You can use the functional helper `list` to turn the arg into a list type too.
 3. In our resolver, access the args we specified above and pass them through to our custom logic. If you hover over the `args` parameter you'll see that Nexus has properly typed them including the fact that they cannot be undefined.
 
 ## Model the domain: Part 2
@@ -374,7 +371,7 @@ export const PostMutation = extendType({
 +    t.field('publish', {
 +      type: 'Post',
 +      args: {
-+        draftId: intArg({ required: true }),
++        draftId: nonNull(intArg()),
 +      },
 +      resolve(_root, args, ctx) {
 +        let draftToPublish = ctx.db.posts.find(p => p.id === args.draftId)
@@ -408,7 +405,7 @@ export const PostMutation = extendType({
     t.field('publish', {
       type: 'Post',
       args: {
-        draftId: intArg({ required: true }),
+        draftId: nonNull(intArg()),
       },
       resolve(_root, args, ctx) {
         let draftToPublish = ctx.db.posts.find(p => p.id === args.draftId)

docs/content/010-getting-started/03-tutorial/06-chapter-5-persisting-data-via-prisma.mdx

@@ -212,7 +212,7 @@ Let's now replace all our previous in-memory db interactions with calls to the P
 
 // ...
 
-schema.extendType({
+extendType({
   type: 'Query',
   definition(t) {
     t.list.field('drafts', {
@@ -232,14 +232,14 @@ schema.extendType({
   },
 });
 
-schema.extendType({
+extendType({
   type: 'Mutation',
   definition(t) {
     t.field('createDraft', {
       type: 'Post',
       args: {
-        title: stringArg({ required: true }),
-        body: stringArg({ required: true }),
+        title: nonNull(stringArg()),
+        body: nonNull(stringArg()),
       },
       resolve(_root, args, ctx) {
         const draft = {
@@ -258,7 +258,7 @@ schema.extendType({
     t.field('publish', {
       type: 'Post',
       args: {
-        draftId: intArg({ required: true }),
+        draftId: nonNull(intArg()),
       },
       resolve(_root, args, ctx) {
 -       let postToPublish = ctx.db.posts.find((p) => p.id === args.draftId)
@@ -316,8 +316,8 @@ schema.extendType({
     t.field('createDraft', {
       type: 'Post',
       args: {
-        title: stringArg({ required: true }),
-        body: stringArg({ required: true }),
+        title: nonNull(stringArg()),
+        body: nonNull(stringArg()),
       },
       resolve(_root, args, ctx) {
         const draft = {
@@ -332,11 +332,13 @@ schema.extendType({
     t.field('publish', {
       type: 'Post',
       args: {
-        draftId: intArg({ required: true }),
+        draftId: nonNull(intArg()),
       },
       resolve(_root, args, ctx) {
         return ctx.db.post.update({
-          where: { id: args.draftId },
+          where: {
+            id: args.draftId
+          },
           data: {
             published: true,
           },

docs/content/014-guides/020-schema.mdx

@@ -128,15 +128,17 @@ type Beta {
 
 ##### Lists and nullability
 
+The following demonstration assumes the Nexus nullability defaults.
+
 ```ts
 objectType({
   name: 'Alpha',
   definition(t) {
-    t.id('a', { nullable: true })
+    t.id('a')
     t.list.id('b')
-    t.list.id('c', { nullable: true })
-    t.list.id('c', { list: [false] })
-    t.list.id('c', { list: [false], nullable: true })
+    t.nullable.list.id('c')
+    t.list.nullable.id('d')
+    t.nullable.list.nullable.id('e')
   },
 })
 ```
@@ -146,8 +148,8 @@ type Alpha {
   a: ID
   b: [ID!]!
   c: [ID!]
-  c: [ID]!
-  c: [ID]
+  d: [ID]!
+  e: [ID]
 }
 ```
 
@@ -191,13 +193,11 @@ queryType({
         return Math.random() > 0.1 : 'Zeta' : 'Yolo'
       }
     })
-    t.list.field('alphas', {
-      type: 'Alpha',
+    t.field('alphas', {
+      type: list('Alpha'),
       args: {
-        except: schema.arg({
-          list: true,
-          type: "Alpha",
-          required: true,
+        except: arg({
+          type: list(nonNull("Alpha")),
         })
       },
       resolve(_root, args) {
@@ -400,14 +400,11 @@ type Query {
 ```ts
 queryType({
   definition(t) {
-    t.string('echo', {
+    t.field('echo', {
+      type: nonNull('String'),
       args: {
-        message: schema.arg({
-          type: 'String',
-          nullable: false,
-        }),
+        message: nullable(stringArg()),
       },
-      nullable: false,
       resolve(_root, args) {
         return args.message
       },
@@ -431,7 +428,7 @@ It is possible to use type and input/field layers together. This provides flexib
 
 
 ```ts
-schema.queryType({
+queryType({
   // flip the global defaults
   nonNullDefaults: {
     input: true,
@@ -442,13 +439,9 @@ schema.queryType({
     // nullability config ... Except the following,
     // which effectively reverts back to what the global
     // defaults are:
-    t.string('echo', {
-      nullable: false,
+    t.nonNull.string('echo', {
       args: {
-        message: schema.arg({
-          type: 'String',
-          nullable: false,
-        }),
+        message: nonNull(stringArg()),
       },
       resolve(_root, args) {
         return args.message
@@ -475,14 +468,12 @@ When an arg has a default you might think that then it should be nullable to the
 ```ts
 queryType({
   definition(t) {
-    t.string('echo', {
+    t.nonNull.string('echo', {
       args: {
-        message: schema.arg({
-          type: 'String',
+        message: stringArg({
           default: 'nil via default',
         }),
       },
-      nullable: false,
       resolve(_root, args) {
         const fallback = 'nil via client null'
         return args.message ?? fallback
@@ -566,7 +557,7 @@ query({
   definition(t) {
     t.user({
       args: {
-        id: schema.arg({ type: 'ID', required: true }),
+        id: nonNull(idArg()),
       },
       resolve(_, { id }, { db }) {
         return db.fetchUser({ where: { id } })

docs/content/015-api/011-subscription-type.mdx

@@ -48,13 +48,14 @@ const schema = makeSchema({
           type: 'User',
           args: {
             data: arg({
-              required: true,
-              type: inputObjectType({
-                name: 'CreateOneUserInput',
-                definition(t) {
-                  t.string('email', { required: true })
-                },
-              }),
+              type: nonNull(
+                inputObjectType({
+                  name: 'CreateOneUserInput',
+                  definition(t) {
+                    t.nonNull.string('email')
+                  },
+                })
+              ),
             }),
           },
           async resolve(_, args) {

docs/content/015-api/050-input-object-type.mdx

@@ -13,7 +13,7 @@ Defines a complex object which can be passed as an input value.
 export const InputType = inputObjectType({
   name: 'InputType',
   definition(t) {
-    t.string('key', { required: true })
+    t.nonNull.string('key')
     t.int('answer')
   },
 })

docs/content/015-api/060-args.mdx

@@ -15,7 +15,7 @@ Defines an argument that can be used in any object or interface type. Args can b
 import { intArg, core } from '@nexus/schema'
 
 function requiredInt(opts: core.ScalarArgConfig<number>) {
-  return intArg({ ...opts, required: true })
+  return nonNull(intArg({ ...opts }))
 }
 ```