feat(compatibility): New configuration option `unsafeCompatibleWhereU…

…niqueInput`

close: #177

README.md

@@ -145,6 +145,13 @@ Type: `boolean`
 Default: `false`  
 **Note**: It will break compatiblity between Prisma types and generated classes.
 
+#### `unsafeCompatibleWhereUniqueInput`
+
+This trick TypeScript and set property as non optional for all fields in `*WhereUniqueInput` classes.
+See [#177](https://github.com/unlight/prisma-nestjs-graphql/issues/177) for more details.  
+Type: `boolean`  
+Default: `false`
+
 #### `useInputType`
 
 Since GraphQL does not support input union type, this setting map

src/event-names.ts

@@ -0,0 +1 @@
+export const BeforeGenerateField = 'BeforeGenerateField';

src/handlers/combine-scalar-filters.ts

@@ -1,14 +1,15 @@
 import AwaitEventEmitter from 'await-event-emitter';
 import { cloneDeep, keyBy, remove } from 'lodash';
 
+import { BeforeGenerateField } from '../event-names';
 import { DMMF, EventArguments, InputType } from '../types';
 
 /**
  * Subscribes on 'BeforeInputType'
  */
 export function combineScalarFilters(eventEmitter: AwaitEventEmitter) {
   eventEmitter.on('BeforeInputType', beforeInputType);
-  eventEmitter.on('BeforeGenerateField', beforeGenerateField);
+  eventEmitter.on(BeforeGenerateField, beforeGenerateField);
   eventEmitter.on('PostBegin', postBegin);
 }
 

src/handlers/input-type.ts

@@ -4,6 +4,7 @@ import { castArray, last } from 'lodash';
 import pupa from 'pupa';
 import { ClassDeclarationStructure, StructureKind } from 'ts-morph';
 
+import { BeforeGenerateField } from '../event-names';
 import { getGraphqlImport } from '../helpers/get-graphql-import';
 import { getGraphqlInputType } from '../helpers/get-graphql-input-type';
 import { getPropertyType } from '../helpers/get-property-type';
@@ -72,11 +73,12 @@ export function inputType(
   const useInputType = config.useInputType.find(x =>
     inputType.name.includes(x.typeName),
   );
+  const isWhereUnique = isWhereUniqueInputType(inputType.name);
 
   for (const field of inputType.fields) {
     field.inputTypes = field.inputTypes.filter(t => !removeTypes.has(String(t.type)));
 
-    eventEmitter.emitSync('BeforeGenerateField', field, args);
+    eventEmitter.emitSync(BeforeGenerateField, field, args);
 
     const { inputTypes, isRequired, name } = field;
 
@@ -96,10 +98,14 @@ export function inputType(
     });
     const modelField = model?.fields.find(f => f.name === name);
     const isCustomsApplicable = typeName === modelField?.type;
+    const atLeastKeys = model && getWhereUniqueAtLeastKeys(model);
     const whereUniqueInputType =
       isWhereUniqueInputType(typeName) &&
-      model &&
-      `Prisma.AtLeast<${typeName}, ${getWhereUniqueAtLeastKeys(model)}>`;
+      atLeastKeys &&
+      `Prisma.AtLeast<${typeName}, ${atLeastKeys
+        .map(name => `'${name}'`)
+        .join(' | ')}>`;
+
     const propertyType = castArray(
       propertySettings?.name ||
         whereUniqueInputType ||
@@ -108,12 +114,21 @@ export function inputType(
           type: typeName,
         }),
     );
+
+    const hasExclamationToken = Boolean(
+      isWhereUnique &&
+        config.unsafeCompatibleWhereUniqueInput &&
+        atLeastKeys?.includes(name),
+    );
     const property = propertyStructure({
       name,
       isNullable: !isRequired,
+      hasExclamationToken: hasExclamationToken || undefined,
+      hasQuestionToken: hasExclamationToken ? false : undefined,
       propertyType,
       isList,
     });
+
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     classStructure.properties!.push(property);
 
@@ -136,7 +151,7 @@ export function inputType(
       config.decorate.some(
         d =>
           d.name === 'HideField' &&
-          d.from === '@nestjs/graphql' &&
+          d.from === moduleSpecifier &&
           d.isMatchField(name) &&
           d.isMatchType(inputType.name),
       );
@@ -182,7 +197,7 @@ export function inputType(
     ok(property.decorators, 'property.decorators is undefined');
 
     if (shouldHideField) {
-      importDeclarations.add('HideField', '@nestjs/graphql');
+      importDeclarations.add('HideField', moduleSpecifier);
       property.decorators.push({ name: 'HideField', arguments: [] });
     } else {
       // Generate `@Field()` decorator
@@ -197,22 +212,6 @@ export function inputType(
         ],
       });
 
-      // Debug
-      // if (classStructure.name === 'XInput') {
-      //   console.log('------------');
-      //   console.log({
-      //     field,
-      //     property,
-      //     modelField,
-      //     graphqlInputType,
-      //     'args.inputType': args.inputType,
-      //     'classStructure.name': classStructure.name,
-      //     classTransformerTypeModels,
-      //     modelName,
-      //     graphqlType,
-      //   });
-      // }
-
       if (graphqlType === 'GraphQLDecimal') {
         importDeclarations.add('transformToDecimal', 'prisma-graphql-type-decimal');
         importDeclarations.add('Transform', 'class-transformer');

src/helpers/create-config.spec.ts

@@ -138,4 +138,12 @@ describe('createConfig', () => {
     expect(result.emitBlocks.prismaEnums).toEqual(true);
     expect(result.emitBlocks.schemaEnums).toEqual(true);
   });
+
+  it('unsafeCompatibleWhereUniqueInput', () => {
+    const result = createConfig({
+      unsafeCompatibleWhereUniqueInput: 'true',
+    });
+
+    expect(result.unsafeCompatibleWhereUniqueInput).toEqual(true);
+  });
 });

src/helpers/create-config.ts

@@ -114,6 +114,9 @@ export function createConfig(data: Record<string, unknown>) {
     requireSingleFieldsInWhereUniqueInput: toBoolean(
       config.requireSingleFieldsInWhereUniqueInput,
     ),
+    unsafeCompatibleWhereUniqueInput: toBoolean(
+      config.unsafeCompatibleWhereUniqueInput,
+    ),
     graphqlScalars: (config.graphqlScalars || {}) as Record<
       string,
       ImportNameSpec | undefined

src/helpers/get-where-unique-at-least-keys.ts

@@ -13,7 +13,7 @@ export function getWhereUniqueAtLeastKeys(model: DMMF.Model) {
     names.push(createFieldName(uniqueIndex));
   }
 
-  return names.map(name => `'${name}'`).join(' | ');
+  return names;
 }
 
 function createFieldName(args: { name?: string | null; fields: string[] }) {

src/test/compatibility.ts

@@ -20,6 +20,8 @@ import { UserListRelationFilter } from '../../@generated/user/user-list-relation
 import { UserMaxOrderByAggregateInput } from '../../@generated/user/user-max-order-by-aggregate.input';
 import { UserScalarFieldEnum } from '../../@generated/user/user-scalar-field.enum';
 import { UserWhereInput } from '../../@generated/user/user-where.input';
+import { UserWhereUniqueInput } from '../../@generated/user/user-where-unique.input';
+import { Field } from '@nestjs/graphql';
 
 let $prisma = new PrismaClient();
 
@@ -199,3 +201,15 @@ let $prisma = new PrismaClient();
       console.log('result', result);
     });
 }
+
+{
+  class UserWhereUniqueInput1 extends UserWhereUniqueInput {
+    @Field(() => String, { nullable: true })
+    id!: string;
+  }
+  const userWhereUniqueInput1: UserWhereUniqueInput1 = { id: '1' };
+
+  $prisma.user.findUnique({
+    where: userWhereUniqueInput1,
+  });
+}

src/test/generate.spec.ts

@@ -163,7 +163,7 @@ describe('model with one id int', () => {
   it('aggregate user output count', () => {
     const s = testSourceFile({
       project,
-      file: 'aggregate-user.output.ts',
+      class: 'AggregateUser',
       property: '_count',
     });
     expect(s.property?.type).toEqual('UserCountAggregate');
@@ -2411,3 +2411,63 @@ describe('deprecation reason', () => {
     );
   });
 });
+
+describe('unsafeCompatibleWhereUniqueInput', () => {
+  it('user id', async () => {
+    ({ project, sourceFiles } = await testGenerate({
+      schema: `
+      model User {
+        id String @id
+      }`,
+      options: [
+        `outputFilePattern = "{name}.{type}.ts"`,
+        `unsafeCompatibleWhereUniqueInput = true`,
+      ],
+    }));
+    const s = testSourceFile({
+      project,
+      class: 'UserWhereUniqueInput',
+      property: 'id',
+    });
+    expect(s.property?.hasExclamationToken).toBe(true);
+  });
+
+  it('user id email', async () => {
+    ({ project, sourceFiles } = await testGenerate({
+      schema: `
+      model User {
+        id        String    @id @default(cuid())
+        name      String
+        email     String    @unique @db.VarChar(255)
+        password  String
+
+        @@unique([email, name])
+      }`,
+      options: [
+        `outputFilePattern = "{name}.{type}.ts"`,
+        `unsafeCompatibleWhereUniqueInput = true`,
+      ],
+    }));
+
+    const id = testSourceFile({
+      project,
+      class: 'UserWhereUniqueInput',
+      property: 'id',
+    });
+    expect(id.property?.hasExclamationToken).toBe(true);
+
+    const email = testSourceFile({
+      project,
+      class: 'UserWhereUniqueInput',
+      property: 'email',
+    });
+    expect(email.property?.hasExclamationToken).toBe(true);
+
+    const emailName = testSourceFile({
+      project,
+      class: 'UserWhereUniqueInput',
+      property: 'email_name',
+    });
+    expect(emailName.property?.hasExclamationToken).toBe(true);
+  });
+});