fix: undefined vs null (wip)

src/packages/client/fixtures/blog/main.ts

@@ -1,22 +1,35 @@
-import { PrismaClient } from '@prisma/client'
+import { PrismaClient } from './@prisma/client'
 
-const prisma = new PrismaClient()
+const prisma = new PrismaClient({
+  errorFormat: 'pretty',
+})
 
 async function main() {
-  const users = await prisma.user.findMany({
-    include: {
-      posts: {
-        include: {
-          author: true,
-        },
-        orderBy: {
-          title: 'aasc',
-        },
-      },
+  // const users = await prisma.user.findMany({
+  //   where: {
+  //     id: null,
+  //   },
+  //   include: {
+  //     posts: {
+  //       include: {
+  //         author: true,
+  //       },
+  //       orderBy: {
+  //         title: 'asc',
+  //       },
+  //     },
+  //   },
+  // })
+
+  // console.log(users)
+
+  const result = await prisma.user.updateMany({
+    data: {
+      id: null,
     },
-  } as any)
+  })
 
-  console.log(users)
+  console.log(result)
 
   // // prisma.disconnect()
 

src/packages/client/src/__tests__/__snapshots__/undefined-vs-null.test.ts.snap

@@ -0,0 +1,39 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`select validation null when undefined is allowed 1`] = `
+"mutation {
+  updateOnePost(
+    data: {
+      id: null
+    }
+    where: {
+      id: \\"abc\\"
+    }
+  ) {
+    id
+    createdAt
+    updatedAt
+    published
+    title
+    content
+    authorId
+  }
+}"
+`;
+
+exports[`select validation null when undefined is not allowed 1`] = `
+"mutation {
+  createOnePost(data: {
+    published: true
+    title: null
+  }) {
+    id
+    createdAt
+    updatedAt
+    published
+    title
+    content
+    authorId
+  }
+}"
+`;

src/packages/client/src/__tests__/dmmf.test.ts

@@ -26,6 +26,7 @@ describe('dmmf', () => {
             "inputType": Array [
               Object {
                 "isList": false,
+                "isNullable": false,
                 "isRequired": false,
                 "kind": "enum",
                 "type": "PostKind",
@@ -38,12 +39,14 @@ describe('dmmf', () => {
             "inputType": Array [
               Object {
                 "isList": false,
+                "isNullable": false,
                 "isRequired": false,
                 "kind": "enum",
                 "type": "PostKind",
               },
               Object {
                 "isList": false,
+                "isNullable": false,
                 "isRequired": false,
                 "kind": "enum",
                 "type": "PostKindFilter",
@@ -56,6 +59,7 @@ describe('dmmf', () => {
             "inputType": Array [
               Object {
                 "isList": true,
+                "isNullable": false,
                 "isRequired": false,
                 "kind": "enum",
                 "type": "PostKind",
@@ -68,6 +72,7 @@ describe('dmmf', () => {
             "inputType": Array [
               Object {
                 "isList": true,
+                "isNullable": false,
                 "isRequired": false,
                 "kind": "enum",
                 "type": "PostKind",

src/packages/client/src/__tests__/document.test.ts

@@ -28,13 +28,15 @@ test('document stringify', () => {
                 {
                   isList: false,
                   isRequired: false,
+                  isNullable: true,
                   kind: 'scalar',
                   type: 'number',
                 },
               ],
               bestFittingType: {
                 isList: false,
                 isRequired: false,
+                isNullable: true,
                 kind: 'scalar',
                 type: 'number',
               },

src/packages/client/src/__tests__/undefined-vs-null.test.ts

@@ -0,0 +1,92 @@
+import stripAnsi from 'strip-ansi'
+import { blog } from '../fixtures/blog'
+import { DMMFClass } from '../runtime/dmmf'
+import { makeDocument } from '../runtime/query'
+import { getDMMF } from '../generation/getDMMF'
+
+let dmmf
+beforeAll(async () => {
+  const dmmfDocument = await getDMMF({ datamodel: blog })
+  dmmf = new DMMFClass(dmmfDocument)
+})
+
+describe('select validation', () => {
+  test('null when undefined is allowed', () => {
+    const select = {
+      data: {
+        id: null,
+      },
+      where: {
+        id: 'abc',
+      },
+    }
+
+    const document = makeDocument({
+      dmmf,
+      select,
+      rootTypeName: 'mutation',
+      rootField: 'updateOnePost',
+    })
+
+    expect(String(document)).toMatchSnapshot()
+    try {
+      document.validate(select)
+    } catch (e) {
+      expect(stripAnsi(e.message)).toMatchInlineSnapshot(`
+        "
+        Invalid \`prisma.updateOnePost()\` invocation:
+
+        {
+          data: {
+            id: null
+                ~~~~
+          },
+          where: {
+            id: 'abc'
+          }
+        }
+
+        Argument id for data.id must not be null. Please use undefined instead.
+
+        "
+      `)
+    }
+  })
+  test('null when undefined is not allowed', () => {
+    const select = {
+      data: {
+        published: true,
+        title: null,
+      },
+    }
+
+    const document = makeDocument({
+      dmmf,
+      select,
+      rootTypeName: 'mutation',
+      rootField: 'createOnePost',
+    })
+
+    expect(String(document)).toMatchSnapshot()
+    try {
+      document.validate(select)
+    } catch (e) {
+      expect(stripAnsi(e.message)).toMatchInlineSnapshot(`
+        "
+        Invalid \`prisma.createOnePost()\` invocation:
+
+        {
+          data: {
+            published: true,
+            title: null
+                   ~~~~
+          }
+        }
+
+        Argument title: Got invalid value null on prisma.createOnePost. Provided null, expected String.
+
+        "
+      `)
+    }
+  })
+})

src/packages/client/src/generation/TSClient.ts

@@ -1148,6 +1148,7 @@ export class ArgsType implements Generatable {
             kind: 'object',
             isList: false,
             isRequired: false,
+            isNullable: true,
           },
         ],
         comment: `Select specific fields to fetch from the ${name}`,
@@ -1165,6 +1166,7 @@ export class ArgsType implements Generatable {
             kind: 'object',
             isList: false,
             isRequired: false,
+            isNullable: true,
           },
         ],
         comment: `Choose, which related nodes to fetch as well.`,

src/packages/client/src/generation/generateClient.ts

@@ -125,13 +125,18 @@ export async function generateClient({
   clientVersion,
   engineVersion,
 }: GenerateClientOptions): Promise<BuildClientResult | undefined> {
-  const useDotPrisma = !generator?.isCustomOutput || testMode
+  const useDotPrisma = testMode ? !runtimePath : !generator?.isCustomOutput
 
   runtimePath =
     runtimePath || (useDotPrisma ? '@prisma/client/runtime' : './runtime')
 
   const finalOutputDir = useDotPrisma ? getDotPrismaDir(outputDir) : outputDir
 
+  if (testMode) {
+    Debug.enable('generateClient')
+    debug({ finalOutputDir })
+  }
+
   const { prismaClientDmmf, fileMap } = await buildClient({
     datamodel,
     datamodelPath,

src/packages/client/src/runtime/dmmf-types.ts

@@ -77,6 +77,7 @@ export namespace DMMF {
 
   export interface SchemaArgInputType {
     isRequired: boolean
+    isNullable: boolean
     isList: boolean
     type: ArgType
     kind: FieldKind

src/packages/client/src/runtime/error-types.ts

@@ -63,6 +63,7 @@ export type InvalidArgError =
   | InvalidArgTypeError
   | AtLeastOneError
   | AtMostOneError
+  | InvalidNullArgError
 
 /**
  * This error occurs if the user provides an arg name that doens't exist
@@ -90,6 +91,17 @@ export interface MissingArgError {
   atMostOne: boolean
 }
 
+/**
+ * If a user incorrectly provided null where she shouldn't have
+ */
+export interface InvalidNullArgError {
+  type: 'invalidNullArg'
+  name: string
+  invalidType: DMMF.SchemaArgInputType[] // note that this could be an object or scalar type. in the object case, we print the whole object type
+  atLeastOne: boolean
+  atMostOne: boolean
+}
+
 export interface AtMostOneError {
   type: 'atMostOne'
   key: string

src/packages/client/src/runtime/externalToInternalDmmf.ts

@@ -7,7 +7,7 @@ import { uniqueBy } from './utils/uniqueBy'
 function transformFieldKind(model: ExternalDMMF.Model): DMMF.Model {
   return {
     ...model,
-    fields: model.fields.map(field => ({
+    fields: model.fields.map((field) => ({
       ...field,
       kind: field.kind === 'relation' ? ('object' as any) : field.kind,
     })),
@@ -16,9 +16,9 @@ function transformFieldKind(model: ExternalDMMF.Model): DMMF.Model {
 
 function transformDatamodel(datamodel: ExternalDMMF.Datamodel): DMMF.Datamodel {
   return {
-    enums: datamodel.enums.map(enumValue => ({
+    enums: datamodel.enums.map((enumValue) => ({
       ...enumValue,
-      values: enumValue.values.map(v => v.name),
+      values: enumValue.values.map((v) => v.name),
     })),
     models: datamodel.models.map(transformFieldKind),
   }
@@ -42,13 +42,13 @@ export function externalToInternalDmmf(
 function transformSchema(schema: ExternalDMMF.Schema): DMMF.Schema {
   return {
     enums: schema.enums,
-    inputTypes: schema.inputTypes.map(t => ({
+    inputTypes: schema.inputTypes.map((t) => ({
       ...t,
-      fields: uniqueBy(transformArgs(t.fields), f => f.name),
+      fields: uniqueBy(transformArgs(t.fields), (f) => f.name),
     })),
-    outputTypes: schema.outputTypes.map(o => ({
+    outputTypes: schema.outputTypes.map((o) => ({
       ...o,
-      fields: o.fields.map(f => ({ ...f, args: transformArgs(f.args) })),
+      fields: o.fields.map((f) => ({ ...f, args: transformArgs(f.args) })),
     })),
   }
 }
@@ -64,6 +64,7 @@ function fixOrderByEnum(arg: ExternalDMMF.SchemaArg): ExternalDMMF.SchemaArg {
       inputType: {
         isList: arg.inputType.isList,
         isRequired: arg.inputType.isRequired,
+        isNullable: arg.inputType.isNullable,
         type: arg.inputType.type,
         kind: 'object',
       },
@@ -85,12 +86,12 @@ function getMappings(
   datamodel: DMMF.Datamodel,
 ): DMMF.Mapping[] {
   return mappings
-    .filter(mapping => {
-      const model = datamodel.models.find(m => m.name === mapping.model)
+    .filter((mapping) => {
+      const model = datamodel.models.find((m) => m.name === mapping.model)
       if (!model) {
         throw new Error(`Mapping without model ${mapping.model}`)
       }
-      return model.fields.some(f => f.kind !== 'object')
+      return model.fields.some((f) => f.kind !== 'object')
     })
     .map((mapping: any) => ({
       model: mapping.model,