fix: Change generated enum type to ticked style

Author: unlight

README.md

@@ -763,3 +763,4 @@ import { generate } from 'prisma-nestjs-graphql/generate';
 - keyof typeof SortOrder -> `SortOrder`
 - dummy-createfriends.input.ts -> `create-friends`
 - check 'TODO FIXME'
+- 22.12 node require esm (update all deps to latest)

src/generate.ts

@@ -42,7 +42,7 @@ export async function generate(
     ) => void | Promise<void>;
   },
 ) {
-  const { connectCallback, generator, skipAddOutputSourceFiles, dmmf } = args;
+  const { connectCallback, dmmf, generator, skipAddOutputSourceFiles } = args;
 
   const generatorOutputValue = generator.output?.value;
   ok(generatorOutputValue, 'Missing generator configuration: output');
@@ -72,12 +72,12 @@ export async function generate(
   }
 
   const project = new Project({
-    tsConfigFilePath: config.tsConfigFilePath,
-    skipAddingFilesFromTsConfig: true,
-    skipLoadingLibFiles: !config.emitCompiled,
     manipulationSettings: {
       quoteKind: QuoteKind.Single,
     },
+    skipAddingFilesFromTsConfig: true,
+    skipLoadingLibFiles: !config.emitCompiled,
+    tsConfigFilePath: config.tsConfigFilePath,
   });
 
   if (!skipAddOutputSourceFiles) {
@@ -101,30 +101,30 @@ export async function generate(
   const fieldSettings = new Map<string, Map<string, ObjectSettings>>();
   const getModelName = createGetModelName(modelNames);
   const getSourceFile = factoryGetSourceFile({
-    output: generatorOutputValue,
-    project,
+    eventEmitter,
     getModelName,
+    output: generatorOutputValue,
     outputFilePattern: config.outputFilePattern,
-    eventEmitter,
+    project,
   });
   const { datamodel, schema } = JSON.parse(JSON.stringify(dmmf)) as Document;
   const removeTypes = new Set<string>();
   const eventArguments: EventArguments = {
-    schema,
-    models,
+    classTransformerTypeModels: new Set(),
     config,
-    modelNames,
-    modelFields,
-    fieldSettings,
-    project,
-    output: generatorOutputValue,
-    getSourceFile,
-    eventEmitter,
-    typeNames: new Set<string>(),
     enums: mapKeys(datamodel.enums, x => x.name),
+    eventEmitter,
+    fieldSettings,
     getModelName,
+    getSourceFile,
+    modelFields,
+    modelNames,
+    models,
+    output: generatorOutputValue,
+    project,
     removeTypes,
-    classTransformerTypeModels: new Set(),
+    schema,
+    typeNames: new Set<string>(),
   };
 
   if (connectCallback) {
@@ -143,7 +143,7 @@ export async function generate(
     await eventEmitter.emit('Model', model, eventArguments);
   }
 
-  const { inputObjectTypes, outputObjectTypes, enumTypes } = schema;
+  const { enumTypes, inputObjectTypes, outputObjectTypes } = schema;
 
   await eventEmitter.emit('PostBegin', eventArguments);
 
@@ -170,9 +170,9 @@ export async function generate(
   for (const inputType of inputTypes) {
     const event = {
       ...eventArguments,
-      inputType,
-      fileType: 'input',
       classDecoratorName: 'InputType',
+      fileType: 'input',
+      inputType,
     };
     if (inputType.fields.length === 0) {
       removeTypes.add(inputType.name);

src/handlers/generate-files.ts

@@ -10,7 +10,7 @@ import { ImportDeclarationMap } from '../helpers/import-declaration-map';
 import { EventArguments } from '../types';
 
 export async function generateFiles(args: EventArguments) {
-  const { project, config, output, eventEmitter } = args;
+  const { config, eventEmitter, output, project } = args;
 
   if (config.emitSingle) {
     const rootDirectory =
@@ -76,9 +76,9 @@ export async function generateFiles(args: EventArguments) {
           }
           if (statement.defaultImport) {
             imports.create({
+              defaultImport: statement.defaultImport,
               from: statement.moduleSpecifier,
               name: statement.defaultImport,
-              defaultImport: statement.defaultImport,
             });
           }
           if (statement.namespaceImport) {
@@ -110,9 +110,9 @@ export async function generateFiles(args: EventArguments) {
     project.compilerOptions.set({
       declaration: true,
       declarationDir: output,
-      rootDir: output,
-      outDir: output,
       emitDecoratorMetadata: false,
+      outDir: output,
+      rootDir: output,
       skipLibCheck: true,
     });
     const emitResult = await project.emit();

src/handlers/output-type.ts

@@ -1,8 +1,9 @@
 import { ok } from 'assert';
 import JSON5 from 'json5';
-import { castArray, last } from 'lodash';
+import { castArray } from 'lodash';
 import { ClassDeclarationStructure, StructureKind } from 'ts-morph';
 
+import { getEnumName } from '../helpers/get-enum-name';
 import { getGraphqlImport } from '../helpers/get-graphql-import';
 import { getOutputTypeName } from '../helpers/get-output-type-name';
 import { getPropertyType } from '../helpers/get-property-type';
@@ -13,7 +14,7 @@ import { EventArguments, OutputType } from '../types';
 const nestjsGraphql = '@nestjs/graphql';
 
 export function outputType(outputType: OutputType, args: EventArguments) {
-  const { getSourceFile, models, eventEmitter, fieldSettings, getModelName, config } =
+  const { config, eventEmitter, fieldSettings, getModelName, getSourceFile, models } =
     args;
   const importDeclarations = new ImportDeclarationMap();
 
@@ -42,23 +43,23 @@ export function outputType(outputType: OutputType, args: EventArguments) {
   });
 
   const classStructure: ClassDeclarationStructure = {
-    kind: StructureKind.Class,
-    isExported: true,
-    name: outputType.name,
     decorators: [
       {
-        name: 'ObjectType',
         arguments: [],
+        name: 'ObjectType',
       },
     ],
+    isExported: true,
+    kind: StructureKind.Class,
+    name: outputType.name,
     properties: [],
   };
 
   importDeclarations.add('Field', nestjsGraphql);
   importDeclarations.add('ObjectType', nestjsGraphql);
 
   for (const field of outputType.fields) {
-    const { location, isList, type } = field.outputType;
+    const { isList, location, type } = field.outputType;
     const outputTypeName = getOutputTypeName(String(type));
     const settings = isCountOutput
       ? undefined
@@ -67,6 +68,7 @@ export function outputType(outputType: OutputType, args: EventArguments) {
       name: outputType.name,
       output: true,
     });
+
     const isCustomsApplicable =
       outputTypeName === model?.fields.find(f => f.name === field.name)?.type;
 
@@ -81,11 +83,11 @@ export function outputType(outputType: OutputType, args: EventArguments) {
     );
 
     const property = propertyStructure({
-      name: field.name,
-      isNullable: field.isNullable,
       hasQuestionToken: isCountOutput ? true : undefined,
-      propertyType,
       isList,
+      isNullable: field.isNullable,
+      name: field.name,
+      propertyType,
     });
 
     classStructure.properties?.push(property);
@@ -122,19 +124,17 @@ export function outputType(outputType: OutputType, args: EventArguments) {
     } else {
       const graphqlImport = getGraphqlImport({
         config,
-        sourceFile,
         fileType,
-        location,
+        getSourceFile,
         isId: false,
+        location,
+        sourceFile,
         typeName: outputTypeName,
-        getSourceFile,
       });
+      const referenceName =
+        location === 'enumTypes' ? getEnumName(propertyType[0]) : propertyType[0];
 
       graphqlType = graphqlImport.name;
-      let referenceName = propertyType[0];
-      if (location === 'enumTypes') {
-        referenceName = last(referenceName.split(' ')) as string;
-      }
 
       if (
         graphqlImport.specifier &&
@@ -143,8 +143,8 @@ export function outputType(outputType: OutputType, args: EventArguments) {
           (shouldHideField && referenceName === graphqlImport.name))
       ) {
         importDeclarations.set(graphqlImport.name, {
-          namedImports: [{ name: graphqlImport.name }],
           moduleSpecifier: graphqlImport.specifier,
+          namedImports: [{ name: graphqlImport.name }],
         });
       }
     }
@@ -153,18 +153,18 @@ export function outputType(outputType: OutputType, args: EventArguments) {
 
     if (shouldHideField) {
       importDeclarations.add('HideField', nestjsGraphql);
-      property.decorators.push({ name: 'HideField', arguments: [] });
+      property.decorators.push({ arguments: [], name: 'HideField' });
     } else {
       // Generate `@Field()` decorator
       property.decorators.push({
-        name: 'Field',
         arguments: [
           isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`,
           JSON5.stringify({
             ...settings?.fieldArguments(),
             nullable: Boolean(field.isNullable),
           }),
         ],
+        name: 'Field',
       });
 
       if (isCustomsApplicable) {
@@ -176,8 +176,8 @@ export function outputType(outputType: OutputType, args: EventArguments) {
             true
           ) {
             property.decorators.push({
-              name: options.name,
               arguments: options.arguments as string[],
+              name: options.name,
             });
             ok(options.from, "Missed 'from' part in configuration or field setting");
             importDeclarations.create(options);
@@ -187,8 +187,8 @@ export function outputType(outputType: OutputType, args: EventArguments) {
     }
 
     eventEmitter.emitSync('ClassProperty', property, {
-      location,
       isList,
+      location,
       propertyType,
     });
   }

src/helpers/generate-file-name.ts

@@ -8,16 +8,16 @@ export function generateFileName(args: {
   getModelName(name: string): string | undefined;
   template: string;
 }) {
-  const { template, type, name, getModelName } = args;
+  const { getModelName, name, template, type } = args;
 
   return pupa(template, {
-    type,
     get model() {
       const result = getModelName(name) || 'prisma';
       return kebabCase(result);
     },
     get name() {
       let result = kebabCase(name);
+
       for (const suffix of ['input', 'args', 'enum']) {
         const ending = `-${suffix}`;
         if (type === suffix && result.endsWith(ending)) {
@@ -31,5 +31,6 @@ export function generateFileName(args: {
         return pluralize(type);
       },
     },
+    type,
   });
 }

src/helpers/get-enum-name.ts

@@ -0,0 +1,4 @@
+export function getEnumName(referenceName: string) {
+  // `${Role}`
+  return referenceName.slice(3, -2);
+}

src/helpers/get-graphql-import.ts

@@ -17,12 +17,12 @@ export function getGraphqlImport(args: {
   const {
     config,
     fileType,
-    location,
-    typeName,
+    getSourceFile,
     isId,
+    location,
     noTypeId,
     sourceFile,
-    getSourceFile,
+    typeName,
   } = args;
 
   if (location === 'scalar') {
@@ -69,8 +69,8 @@ export function getGraphqlImport(args: {
   const specifier = relativePath(
     sourceFile.getFilePath(),
     getSourceFile({
-      type: sourceFileType,
       name: typeName,
+      type: sourceFileType,
     }).getFilePath(),
   );
 

src/helpers/get-property-type.ts

@@ -42,7 +42,9 @@ export function getPropertyType(args: {
     return [type];
   }
   if (location === 'enumTypes') {
-    return [`keyof typeof ${type}`];
+    const enumType = '`${' + type + '}`';
+
+    return [enumType];
   }
   if (location === 'scalar') {
     return [type];

src/test/compatibility.ts

@@ -120,22 +120,25 @@ let $prisma = new PrismaClient();
     by: ['id'] as UserScalarFieldEnum[],
   };
   p = x;
-  p;
-  x;
 }
 {
   let x: DummyCreateInput = { decimal: 0 as any, id: '1' };
   let p: Prisma.DummyCreateInput = { decimal: 0 as any, id: '2' };
   p = x;
-  p;
-  x;
 }
 {
   let x: DummyCreateInput['json'] = {};
   let p: Prisma.DummyCreateInput['json'] = {};
   p = x;
   p;
 }
+{
+  // Will not be fixed, but can by adding id?: `${SortOrder}` | Prisma.Types.Skip
+  // let x: UserMaxOrderByAggregateInput['id'] =
+  //   null as unknown as Prisma.UserMaxOrderByAggregateInput['id'];
+  let p: Prisma.UserMaxOrderByAggregateInput['id'] =
+    null as unknown as UserMaxOrderByAggregateInput['id'];
+}
 {
   let x: UserMaxOrderByAggregateInput = {};
   let p: Prisma.UserMaxOrderByAggregateInput = {};
@@ -146,14 +149,12 @@ let $prisma = new PrismaClient();
 {
   let x: UserCreateInput = {} as unknown as UserCreateInput;
   let p: Prisma.UserCreateInput = {} as unknown as Prisma.UserCreateInput;
-  p = x;
-  p;
 }
 {
   let x: Dummy['bytes'] = null as unknown as P.Dummy['bytes'];
   let p: P.Dummy['bytes'] = null as unknown as Dummy['bytes'];
-  x;
-  p;
+  p = x;
+  x = p;
 }
 {
   let x: Dummy = {} as unknown as Dummy;
@@ -208,7 +209,6 @@ let $prisma = new PrismaClient();
       console.log('result', result);
     });
 }
-
 {
   class UserWhereUniqueInput1 extends UserWhereUniqueInput {
     @Field(() => String, { nullable: true })