feat: add support for BigInt scalar

README.md

@@ -211,13 +211,17 @@ However some of the Prisma scalars do not have a natural standard representation
 
 **Prisma Standard Scalar to GraphQL Custom Scalar Mapping**
 
-| Prisma     | GraphQL    | Nexus `t` Helper | GraphQL Scalar Implementation                                     |
-| ---------- | ---------- | ---------------- | ----------------------------------------------------------------- |
-| `Json`     | `Json`     | `json`           | [JsonObject](https://github.com/Urigo/graphql-scalars#jsonobject) |
-| `DateTime` | `DateTime` | `dateTime`       | [DateTime](https://github.com/Urigo/graphql-scalars#datetime)     |
-| `Bytes`    | `Bytes`    | `bytes`          | [Bytes](https://www.graphql-scalars.dev/docs/scalars/byte/)       |
+| Prisma     | GraphQL    | Nexus `t` Helper | GraphQL Scalar Implementation                                         | Additional Info                                                                                              |
+| ---------- | ---------- | ---------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+| `Json`     | `Json`     | `json`           | [JsonObject](https://www.graphql-scalars.dev/docs/scalars/jsonobject) |                                                                                                              |
+| `DateTime` | `DateTime` | `dateTime`       | [DateTime](https://www.graphql-scalars.dev/docs/scalars/datetime)     |                                                                                                              |
+| `BigInt`   | `BigInt`   | `bigInt`         | [BigInt](https://www.graphql-scalars.dev/docs/scalars/big-int)        | [JavaScript BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) |
+| `Bytes`    | `Bytes`    | `bytes`          | [Byte](https://www.graphql-scalars.dev/docs/scalars/byte/)            | [Node.js Buffer](https://nodejs.org/api/buffer.html#buffer_buffer)                                           |
 
-> **Note:** Not all Prisma scalar mappings are implemented yet: `BigInt`, `Decimal`, `Unsupported`
+> **Note:** Not all Prisma scalar mappings are implemented yet: `Decimal`, `Unsupported`
+
+> **Note:** `BigInt` is only supported since Node.js version 10.4.0. In order to support `BigInt` in `JSON.parse` and `JSON.stringify`, it is recommended to install this npm package together with this scalar. Otherwise, JavaScript will serialize the value as string.
+> [json-bigint-patch](https://github.com/ardatan/json-bigint-patch).
 
 While you are not required to use the implementations supplied by Nexus Prisma, you _are required to define custom scalars whose name matches the above mapping_.
 

src/entrypoints/scalars.ts

@@ -1,19 +1,22 @@
+import { BigInt } from '../scalars/BigInt'
+import { Bytes } from '../scalars/Bytes'
 import { DateTime } from '../scalars/DateTime'
 import { Json } from '../scalars/Json'
-import { Bytes } from '../scalars/Bytes'
 
 /**
  * Predefined Nexus scalar type definitions to satisfy all custom scalars needed in GraphQL to map to the
  * native scalars in Prisma. The mapping is as follows:
  *
- * | Prisma | GraphQL | Nexus `t` Helper | GraphQL Scalar Implementation |
- * | ---------- | ---------- | ---- | ----------------------------------------------------------------- |
- * | `Json` | `Json` | `json` | [JsonObject](https://github.com/Urigo/graphql-scalars#jsonobject) |
- * | `DateTime` | `DateTime` | `datetime` | [DateTime](https://github.com/Urigo/graphql-scalars#datetime) |.
+ * | Prisma     | GraphQL    | Nexus `t` Helper | GraphQL Scalar Implementation                                         | Additional Info                                                                                              |
+ * | ---------- | ---------- | ---------------- | --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
+ * | `Json`     | `Json`     | `json`           | [JsonObject](https://www.graphql-scalars.dev/docs/scalars/jsonobject) |                                                                                                              |
+ * | `DateTime` | `DateTime` | `dateTime`       | [DateTime](https://www.graphql-scalars.dev/docs/scalars/datetime)     |                                                                                                              |
+ * | `BigInt`   | `BigInt`   | `bigInt`         | [BigInt](https://www.graphql-scalars.dev/docs/scalars/big-int)        | [JavaScript BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) |
+ * | `Bytes`    | `Bytes`    | `bytes`          | [Byte](https://www.graphql-scalars.dev/docs/scalars/byte/)            | [Node.js Buffer](https://nodejs.org/api/buffer.html#buffer_buffer)                                           |
  *
  * @example
  *
- *   // Use this defualt export
+ *   // Use this default export
  *
  *   import { makeSchema, objectType } from 'nexus'
  *   import NexusPrismaScalars from 'nexus-prisma/scalars'
@@ -35,7 +38,7 @@ import { Bytes } from '../scalars/Bytes'
  *
  * @example
  *
- *   // Use only select precefined custom scalars
+ *   // Use only select predefined custom scalars
  *
  *   import { makeSchema, objectType } from 'nexus'
  *   import { Json } from 'nexus-prisma/scalars'
@@ -70,11 +73,12 @@ import { Bytes } from '../scalars/Bytes'
  *          API. For convenience you can use these ones.
  */
 const NexusPrismaScalars = {
+  BigInt,
   Bytes,
   DateTime,
   Json,
 }
 
 export default NexusPrismaScalars
 
-export { Bytes, DateTime, Json }
+export { BigInt, Bytes, DateTime, Json }

src/generator/models/declaration.ts

@@ -2,7 +2,7 @@ import { DMMF } from '@prisma/generator-helper'
 import dedent from 'dindist'
 import * as OS from 'os'
 import { LiteralUnion } from 'type-fest'
-import { StandardGraphQLScalarType, StandardgraphQLScalarTypes } from '../../helpers/graphql'
+import { StandardGraphQLScalarType, StandardGraphQLScalarTypes } from '../../helpers/graphql'
 import { PrismaScalarType } from '../../helpers/prisma'
 import { allCasesHandled } from '../../helpers/utils'
 import { Gentime } from '../gentime/settingsSingleton'
@@ -247,25 +247,25 @@ export function fieldTypeToGraphQLType(
 
       if (field.isId) {
         if (field.type === 'String' || (field.type === 'Int' && settings.projectIdIntToGraphQL === 'ID')) {
-          return StandardgraphQLScalarTypes.ID
+          return StandardGraphQLScalarTypes.ID
         }
       }
 
       switch (typeName) {
         case 'String': {
-          return StandardgraphQLScalarTypes.String
+          return StandardGraphQLScalarTypes.String
         }
         case 'Int': {
-          return StandardgraphQLScalarTypes.Int
+          return StandardGraphQLScalarTypes.Int
         }
         case 'Boolean': {
-          return StandardgraphQLScalarTypes.Boolean
+          return StandardGraphQLScalarTypes.Boolean
         }
         case 'Float': {
-          return StandardgraphQLScalarTypes.Float
+          return StandardGraphQLScalarTypes.Float
         }
         case 'BigInt': {
-          return StandardgraphQLScalarTypes.String
+          return 'BigInt'
         }
         case 'DateTime': {
           return 'DateTime'
@@ -277,7 +277,7 @@ export function fieldTypeToGraphQLType(
           return 'Bytes'
         }
         case 'Decimal': {
-          return StandardgraphQLScalarTypes.String
+          return StandardGraphQLScalarTypes.String
         }
         default: {
           return allCasesHandled(typeName)

src/helpers/graphql.ts

@@ -1,6 +1,6 @@
 export type StandardGraphQLScalarType = 'ID' | 'String' | 'Int' | 'Float' | 'Boolean'
 
-export const StandardgraphQLScalarTypes = {
+export const StandardGraphQLScalarTypes = {
   ID: 'ID',
   String: 'String',
   Float: 'Float',

src/scalars/BigInt.ts

@@ -0,0 +1,39 @@
+import { GraphQLScalarType } from 'graphql'
+import { BigIntResolver } from 'graphql-scalars'
+import { asNexusMethod } from 'nexus'
+
+/**
+ * A Nexus scalar type definition for the `BigInt` scalar type
+ *
+ * Contributes a scalar to your GraphQL schema called `BigInt`.
+ *
+ * Contributes a `t` `[1]` helper method called `bigInt`
+ *
+ * `[1]` A `t` helper method refers to a method on the argument given to a `definition` method. Helper methods
+ * here typically help you quickly create new fields.
+ *
+ * @example
+ *
+ *   import { makeSchema, objectType } from 'nexus'
+ *   import { BigInt } from 'nexus-prisma/scalars'
+ *
+ *   SomeObject = objectType({
+ *     name: 'SomeObject',
+ *     definition(t) {
+ *       t.bigInt('someBigIntField')
+ *     },
+ *   })
+ *
+ *   makeSchema({
+ *     types: [BigInt, SomeObject],
+ *   })
+ *
+ */
+export const BigInt = asNexusMethod(
+  new GraphQLScalarType({
+    ...BigIntResolver,
+    description: `The \`BigInt\` scalar type represents non-fractional signed whole numeric values.
+@see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt`,
+  }),
+  'bigInt'
+)

tests/e2e/__snapshots__/e2e.test.ts.snap

@@ -5,9 +5,11 @@ Object {
   "bars": Array [
     Object {
       "foo": Object {
+        "BigIntManually": null,
         "BytesManually": null,
         "DateTimeManually": null,
         "JsonManually": null,
+        "someBigIntField": "9007199254740991",
         "someBytesField": Object {
           "data": Array [],
           "type": "Buffer",
@@ -29,6 +31,11 @@ type Bar {
   foo: Foo
 }
 
+\\"\\"\\"
+The \`BigInt\` scalar type represents non-fractional signed whole numeric values.
+\\"\\"\\"
+scalar BigInt
+
 \\"\\"\\"The \`Byte\` scalar type represents byte value as a Buffer\\"\\"\\"
 scalar Bytes
 
@@ -38,9 +45,11 @@ A date-time string at UTC, such as 2007-12-03T10:15:30Z, compliant with the \`da
 scalar DateTime
 
 type Foo {
+  BigIntManually: BigInt
   BytesManually: Bytes
   DateTimeManually: DateTime
   JsonManually: Json
+  someBigIntField: BigInt!
   someBytesField: Bytes!
   someDateTimeField: DateTime!
   someEnumA: SomeEnumA
@@ -74,6 +83,10 @@ import * as PrismaClient from \\".prisma/client\\"
 import { core } from \\"nexus\\"
 declare global {
   interface NexusGenCustomInputMethods<TypeName extends string> {
+    /**
+     * The \`BigInt\` scalar type represents non-fractional signed whole numeric values.
+     */
+    bigInt<FieldName extends string>(fieldName: FieldName, opts?: core.CommonInputFieldConfig<TypeName, FieldName>): void // \\"BigInt\\";
     /**
      * The \`Byte\` scalar type represents byte value as a Buffer
      */
@@ -90,6 +103,10 @@ declare global {
 }
 declare global {
   interface NexusGenCustomOutputMethods<TypeName extends string> {
+    /**
+     * The \`BigInt\` scalar type represents non-fractional signed whole numeric values.
+     */
+    bigInt<FieldName extends string>(fieldName: FieldName, ...opts: core.ScalarOutSpread<TypeName, FieldName>): void // \\"BigInt\\";
     /**
      * The \`Byte\` scalar type represents byte value as a Buffer
      */
@@ -123,6 +140,7 @@ export interface NexusGenScalars {
   Float: number
   Boolean: boolean
   ID: string
+  BigInt: any
   Bytes: any
   DateTime: any
   Json: any
@@ -149,9 +167,11 @@ export interface NexusGenFieldTypes {
     foo: NexusGenRootTypes['Foo'] | null; // Foo
   }
   Foo: { // field return type
+    BigIntManually: NexusGenScalars['BigInt'] | null; // BigInt
     BytesManually: NexusGenScalars['Bytes'] | null; // Bytes
     DateTimeManually: NexusGenScalars['DateTime'] | null; // DateTime
     JsonManually: NexusGenScalars['Json'] | null; // Json
+    someBigIntField: NexusGenScalars['BigInt']; // BigInt!
     someBytesField: NexusGenScalars['Bytes']; // Bytes!
     someDateTimeField: NexusGenScalars['DateTime']; // DateTime!
     someEnumA: NexusGenEnums['SomeEnumA'] | null; // SomeEnumA
@@ -167,9 +187,11 @@ export interface NexusGenFieldTypeNames {
     foo: 'Foo'
   }
   Foo: { // field return type name
+    BigIntManually: 'BigInt'
     BytesManually: 'Bytes'
     DateTimeManually: 'DateTime'
     JsonManually: 'Json'
+    someBigIntField: 'BigInt'
     someBytesField: 'Bytes'
     someDateTimeField: 'DateTime'
     someEnumA: 'SomeEnumA'

tests/e2e/e2e.test.ts

@@ -120,6 +120,7 @@ it('When bundled custom scalars are used the project type checks and generates e
             someJsonField     Json
             someDateTimeField DateTime
             someBytesField    Bytes
+            someBigIntField   BigInt
             someEnumA         SomeEnumA
             bar               Bar?
           }
@@ -155,6 +156,7 @@ it('When bundled custom scalars are used the project type checks and generates e
               someDateTimeField: new Date("2021-05-10T20:42:46.609Z"),
               someBytesField: Buffer.from([]),
               someJsonField: JSON.stringify({}),
+              someBigIntField: BigInt(9007199254740991),
               someEnumA: 'alpha',
               bar: {
                 create: {
@@ -209,9 +211,11 @@ it('When bundled custom scalars are used the project type checks and generates e
               t.json('JsonManually')
               t.dateTime('DateTimeManually')
               t.bytes('BytesManually')
+              t.bigInt('BigIntManually')
               t.field(Foo.someJsonField.name, Foo.someJsonField)
               t.field(Foo.someDateTimeField.name, Foo.someDateTimeField)
               t.field(Foo.someBytesField.name, Foo.someBytesField)
+              t.field(Foo.someBigIntField.name, Foo.someBigIntField)
             },
           }),
         ]
@@ -319,6 +323,9 @@ it('When bundled custom scalars are used the project type checks and generates e
   expect(stripAnsi(results.runFirstBuild.stdout)).toMatch(
     /.*error TS2339: Property 'dateTime' does not exist on type 'ObjectDefinitionBlock<any>'.*/
   )
+  expect(stripAnsi(results.runFirstBuild.stdout)).toMatch(
+    /.*error TS2339: Property 'bigInt' does not exist on type 'ObjectDefinitionBlock<any>'.*/
+  )
 
   expect(results.runReflectPrisma.exitCode).toBe(0)
 
@@ -362,9 +369,11 @@ it('When bundled custom scalars are used the project type checks and generates e
           JsonManually
           DateTimeManually
           BytesManually
+          BigIntManually
           someEnumA
           someDateTimeField
           someBytesField
+          someBigIntField
         }
       }
     }

tests/integration/json.test.ts

@@ -16,6 +16,7 @@ testIntegration({
   apiSchema({ Foo }) {
     return [
       NexusPrismaScalars.Bytes,
+      NexusPrismaScalars.BigInt,
       NexusPrismaScalars.DateTime,
       NexusPrismaScalars.Json,
       objectType({

tests/unit/customScalarsModule.test.ts

@@ -5,18 +5,20 @@ assertBuildPresent()
 
 it('scalars can be accessed via namespace import', () => {
   expect(Object.keys(NexusPrismaScalarsNS)).toMatchInlineSnapshot(`
-    Array [
-      "Bytes",
-      "DateTime",
-      "Json",
-      "default",
-    ]
-  `)
+Array [
+  "BigInt",
+  "Bytes",
+  "DateTime",
+  "Json",
+  "default",
+]
+`)
 })
 
 it('scalars can be accessed via a default import', () => {
   expect(Object.keys(NexusPrismaScalars)).toMatchInlineSnapshot(`
     Array [
+      "BigInt",
       "Bytes",
       "DateTime",
       "Json",

tests/unit/graphqlSchema/__snapshots__/json.test.ts.snap

@@ -2,6 +2,11 @@
 
 exports[`When a JSON field is defined in the Prisma schema it can be projected into the GraphQL API: graphqlSchema 1`] = `
 "
+\\"\\"\\"
+The \`BigInt\` scalar type represents non-fractional signed whole numeric values.
+\\"\\"\\"
+scalar BigInt
+
 \\"\\"\\"The \`Byte\` scalar type represents byte value as a Buffer\\"\\"\\"
 scalar Bytes
 

tests/unit/graphqlSchema/json.test.ts

@@ -13,6 +13,7 @@ testGraphqlSchema({
   `,
   apiSchema({ Foo }) {
     return [
+      NexusPrismaScalars.BigInt,
       NexusPrismaScalars.Bytes,
       NexusPrismaScalars.DateTime,
       NexusPrismaScalars.Json,