prisma-nestjs-graphql 16.0.1 → 17.0.0

package/README.md

@@ -10,10 +10,18 @@ Generate object types, inputs, args, etc. from prisma schema file for usage with
 
 ## Install
 
+Prisma v3
+
 ```sh
 npm install --save-dev prisma-nestjs-graphql
 ```
 
+Prisma v4
+
+```
+npm install --save-dev prisma-nestjs-graphql@next
+```
+
 ## Usage
 
 1. Add new generator section to `schema.prisma` file
@@ -703,6 +711,7 @@ export class User {}
 
 ## Similar Projects
 
+- https://github.com/jasonraimondi/prisma-generator-nestjs-graphql
 - https://github.com/omar-dulaimi/prisma-class-validator-generator
 - https://github.com/kimjbstar/prisma-class-generator
 - https://github.com/odroe/nest-gql-mix

package/index.js

@@ -1,3 +1,4 @@
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -50,7 +51,7 @@ function argsType(field, args) {
       className = `${modelName}GroupByArgs`;
       break;
   }
-  const inputType1 = {
+  const inputType2 = {
     constraints: {
       maxNumFields: null,
       minNumFields: null
@@ -71,17 +72,17 @@ function argsType(field, args) {
       "Min",
       "Max"
     ];
-    if (`${modelName}GroupByArgs` === inputType1.name) {
-      const byField = inputType1.fields.find((f) => f.name === "by");
+    if (`${modelName}GroupByArgs` === inputType2.name) {
+      const byField = inputType2.fields.find((f) => f.name === "by");
       if (byField?.inputTypes) {
-        byField.inputTypes = byField.inputTypes.filter((inputType2) => inputType2.isList);
+        byField.inputTypes = byField.inputTypes.filter((inputType3) => inputType3.isList);
       }
     }
     for (const name of names) {
       if (!typeNames.has(`${modelName}${name}AggregateInput`)) {
         continue;
       }
-      inputType1.fields.push({
+      inputType2.fields.push({
         name: `_${name.toLowerCase()}`,
         isRequired: false,
         isNullable: true,
@@ -97,7 +98,7 @@ function argsType(field, args) {
   }
   eventEmitter.emitSync("InputType", {
     ...args,
-    inputType: inputType1,
+    inputType: inputType2,
     fileType: "args",
     classDecoratorName: "ArgsType"
   });
@@ -280,14 +281,14 @@ async function generateFiles(args) {
     const sourceFile = rootDirectory.getSourceFile("index.ts") || rootDirectory.createSourceFile("index.ts", void 0, {
       overwrite: true
     });
-    const statements1 = project.getSourceFiles().flatMap((s) => {
+    const statements = project.getSourceFiles().flatMap((s) => {
       if (s === sourceFile) {
         return [];
       }
       const classDeclaration = s.getClass(() => true);
-      const statements = s.getStructure().statements;
-      if (Array.isArray(statements)) {
-        for (const statement of statements) {
+      const statements2 = s.getStructure().statements;
+      if (Array.isArray(statements2)) {
+        for (const statement of statements2) {
           if (!(typeof statement === "object" && statement.kind === import_ts_morph2.StructureKind.Class)) {
             continue;
           }
@@ -301,47 +302,47 @@ async function generateFiles(args) {
         }
       }
       project.removeSourceFile(s);
-      return statements;
+      return statements2;
     });
     const imports = new ImportDeclarationMap();
     const enums = [];
     const classes = [];
-    for (const statement1 of statements1) {
-      if (typeof statement1 === "string") {
-        if (statement1.startsWith("registerEnumType")) {
-          enums.push(statement1);
+    for (const statement of statements) {
+      if (typeof statement === "string") {
+        if (statement.startsWith("registerEnumType")) {
+          enums.push(statement);
         }
         continue;
       }
-      switch (statement1.kind) {
+      switch (statement.kind) {
         case import_ts_morph2.StructureKind.ImportDeclaration:
-          if (statement1.moduleSpecifier.startsWith("./") || statement1.moduleSpecifier.startsWith("..")) {
+          if (statement.moduleSpecifier.startsWith("./") || statement.moduleSpecifier.startsWith("..")) {
             continue;
           }
-          for (const namedImport of statement1.namedImports) {
+          for (const namedImport of statement.namedImports) {
             const name = namedImport.alias || namedImport.name;
-            imports.add(name, statement1.moduleSpecifier);
+            imports.add(name, statement.moduleSpecifier);
           }
-          if (statement1.defaultImport) {
+          if (statement.defaultImport) {
             imports.create({
-              from: statement1.moduleSpecifier,
-              name: statement1.defaultImport,
-              defaultImport: statement1.defaultImport
+              from: statement.moduleSpecifier,
+              name: statement.defaultImport,
+              defaultImport: statement.defaultImport
             });
           }
-          if (statement1.namespaceImport) {
+          if (statement.namespaceImport) {
             imports.create({
-              from: statement1.moduleSpecifier,
-              name: statement1.namespaceImport,
-              namespaceImport: statement1.namespaceImport
+              from: statement.moduleSpecifier,
+              name: statement.namespaceImport,
+              namespaceImport: statement.namespaceImport
             });
           }
           break;
         case import_ts_morph2.StructureKind.Enum:
-          enums.unshift(statement1);
+          enums.unshift(statement);
           break;
         case import_ts_morph2.StructureKind.Class:
-          classes.push(statement1);
+          classes.push(statement);
           break;
       }
     }
@@ -604,11 +605,11 @@ __name(getPropertyType, "getPropertyType");
 var import_ts_morph3 = require("ts-morph");
 function propertyStructure(args) {
   const { isNullable, propertyType, name, isList, hasQuestionToken, hasExclamationToken } = args;
-  const type1 = propertyType.map((type) => isList ? `Array<${type}>` : type).join(" | ");
+  const type = propertyType.map((type2) => isList ? `Array<${type2}>` : type2).join(" | ");
   return {
     kind: import_ts_morph3.StructureKind.Property,
     name,
-    type: type1,
+    type,
     hasQuestionToken: hasQuestionToken ?? isNullable,
     hasExclamationToken: hasExclamationToken ?? !isNullable,
     decorators: [],
@@ -619,17 +620,17 @@ __name(propertyStructure, "propertyStructure");
 
 // src/handlers/input-type.ts
 function inputType(args) {
-  const { classDecoratorName, classTransformerTypeModels, config, eventEmitter, fieldSettings, fileType, getModelName: getModelName2, getSourceFile, inputType: inputType1, models, removeTypes, typeNames } = args;
-  typeNames.add(inputType1.name);
+  const { classDecoratorName, classTransformerTypeModels, config, eventEmitter, fieldSettings, fileType, getModelName: getModelName2, getSourceFile, inputType: inputType2, models, removeTypes, typeNames } = args;
+  typeNames.add(inputType2.name);
   const importDeclarations = new ImportDeclarationMap();
   const sourceFile = getSourceFile({
-    name: inputType1.name,
+    name: inputType2.name,
     type: fileType
   });
   const classStructure = {
     kind: import_ts_morph4.StructureKind.Class,
     isExported: true,
-    name: inputType1.name,
+    name: inputType2.name,
     decorators: [
       {
         name: classDecoratorName,
@@ -638,7 +639,7 @@ function inputType(args) {
     ],
     properties: []
   };
-  const modelName = getModelName2(inputType1.name) || "";
+  const modelName = getModelName2(inputType2.name) || "";
   const model = models.get(modelName);
   const modelFieldSettings = model && fieldSettings.get(model.name);
   const moduleSpecifier = "@nestjs/graphql";
@@ -657,8 +658,8 @@ function inputType(args) {
     ],
     moduleSpecifier
   });
-  const useInputType = config.useInputType.find((x) => inputType1.name.includes(x.typeName));
-  for (const field of inputType1.fields) {
+  const useInputType = config.useInputType.find((x) => inputType2.name.includes(x.typeName));
+  for (const field of inputType2.fields) {
     field.inputTypes = field.inputTypes.filter((t) => !removeTypes.has(String(t.type)));
     eventEmitter.emitSync("BeforeGenerateField", field, args);
     const { inputTypes, isRequired, name } = field;
@@ -671,7 +672,7 @@ function inputType(args) {
     const typeName = String(type);
     const settings = modelFieldSettings?.get(name);
     const propertySettings = settings?.getPropertyType({
-      name: inputType1.name,
+      name: inputType2.name,
       input: true
     });
     const modelField = model?.fields.find((f) => f.name === name);
@@ -696,11 +697,11 @@ function inputType(args) {
     }
     let graphqlType;
     const shouldHideField = settings?.shouldHideField({
-      name: inputType1.name,
+      name: inputType2.name,
       input: true
-    }) || config.decorate.some((d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(name) && d.isMatchType(inputType1.name));
+    }) || config.decorate.some((d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(name) && d.isMatchType(inputType2.name));
     const fieldType = settings?.getFieldType({
-      name: inputType1.name,
+      name: inputType2.name,
       input: true
     });
     if (fieldType && isCustomsApplicable && !shouldHideField) {
@@ -721,7 +722,7 @@ function inputType(args) {
       if (location === "enumTypes") {
         referenceName = (0, import_lodash3.last)(referenceName.split(" "));
       }
-      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && graphqlImport.name !== inputType1.name) {
+      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && graphqlImport.name !== inputType2.name) {
         importDeclarations.set(graphqlImport.name, {
           namedImports: [
             {
@@ -801,7 +802,7 @@ function inputType(args) {
         }
       }
       for (const decorate of config.decorate) {
-        if (decorate.isMatchField(name) && decorate.isMatchType(inputType1.name)) {
+        if (decorate.isMatchField(name) && decorate.isMatchType(inputType2.name)) {
           property.decorators.push({
             name: decorate.name,
             arguments: decorate.arguments?.map((x) => (0, import_pupa.default)(x, {
@@ -884,9 +885,9 @@ var ObjectSettings = class extends Array {
     return resultArguments.map((x) => import_json52.default.stringify(x));
   }
   fieldArguments() {
-    const item1 = this.find((item) => item.kind === "Field");
-    if (item1) {
-      return item1.arguments;
+    const item = this.find((item2) => item2.kind === "Field");
+    if (item) {
+      return item.arguments;
     }
   }
 };
@@ -958,24 +959,24 @@ function createSettingElement({ line, config, fieldElement, match }) {
     "FieldType",
     "PropertyType"
   ].includes(name) && match.groups?.args) {
-    const options2 = customType(match.groups.args);
-    (0, import_lodash4.merge)(element, options2.namespace && config.fields[options2.namespace], options2, {
+    const options = customType(match.groups.args);
+    (0, import_lodash4.merge)(element, options.namespace && config.fields[options.namespace], options, {
       kind: name
     });
     return result;
   }
   if (name === "ObjectType" && match.groups?.args) {
     element.kind = "ObjectType";
-    const options2 = customType(match.groups.args);
-    if (typeof options2[0] === "string" && options2[0]) {
-      options2.name = options2[0];
+    const options1 = customType(match.groups.args);
+    if (typeof options1[0] === "string" && options1[0]) {
+      options1.name = options1[0];
     }
-    if ((0, import_lodash4.isObject)(options2[1])) {
-      (0, import_lodash4.merge)(options2, options2[1]);
+    if ((0, import_lodash4.isObject)(options1[1])) {
+      (0, import_lodash4.merge)(options1, options1[1]);
     }
     element.arguments = {
-      name: options2.name,
-      isAbstract: options2.isAbstract
+      name: options1.name,
+      isAbstract: options1.isAbstract
     };
     return result;
   }
@@ -994,11 +995,11 @@ function createSettingElement({ line, config, fieldElement, match }) {
   }
   const namespace = getNamespace(name);
   element.namespaceImport = namespace;
-  const options = {
+  const options3 = {
     name,
     arguments: (match.groups?.args || "").split(",").map((s) => (0, import_lodash4.trim)(s)).filter(Boolean)
   };
-  (0, import_lodash4.merge)(element, namespace && config.fields[namespace], options);
+  (0, import_lodash4.merge)(element, namespace && config.fields[namespace], options3);
   return result;
 }
 __name(createSettingElement, "createSettingElement");
@@ -1090,16 +1091,16 @@ function modelData(model, args) {
   modelFields.set(model.name, modelFieldsValue);
   const fieldSettingsValue = /* @__PURE__ */ new Map();
   fieldSettings.set(model.name, fieldSettingsValue);
-  for (const field1 of model.fields) {
-    if (field1.documentation) {
+  for (const field of model.fields) {
+    if (field.documentation) {
       const { documentation, settings } = createObjectSettings({
-        text: field1.documentation,
+        text: field.documentation,
         config
       });
-      field1.documentation = documentation;
-      fieldSettingsValue.set(field1.name, settings);
+      field.documentation = documentation;
+      fieldSettingsValue.set(field.name, settings);
     }
-    modelFieldsValue.set(field1.name, field1);
+    modelFieldsValue.set(field.name, field);
   }
   if (model.fields.some((field) => field.type === "Decimal")) {
     classTransformerTypeModels.add(model.name);
@@ -1194,12 +1195,12 @@ function modelOutputType(outputType2, args) {
       outputTypeName = getOutputTypeName(outputTypeName);
     }
     const modelField = modelFields.get(model.name)?.get(field.name);
-    const settings = fieldSettings.get(model.name)?.get(field.name);
-    const fieldType = settings?.getFieldType({
+    const settings1 = fieldSettings.get(model.name)?.get(field.name);
+    const fieldType = settings1?.getFieldType({
       name: outputType2.name,
       output: true
     });
-    const propertySettings = settings?.getPropertyType({
+    const propertySettings = settings1?.getPropertyType({
       name: outputType2.name,
       output: true
     });
@@ -1242,7 +1243,7 @@ function modelOutputType(outputType2, args) {
       isList
     });
     if (typeof property.leadingTrivia === "string" && modelField?.documentation) {
-      property.leadingTrivia += createComment(modelField.documentation, settings);
+      property.leadingTrivia += createComment(modelField.documentation, settings1);
     }
     classStructure.properties?.push(property);
     if (propertySettings) {
@@ -1253,7 +1254,7 @@ function modelOutputType(outputType2, args) {
       importDeclarations.add("Decimal", "@prisma/client/runtime");
     }
     (0, import_assert3.ok)(property.decorators, "property.decorators is undefined");
-    if (settings?.shouldHideField({
+    if (settings1?.shouldHideField({
       name: outputType2.name,
       output: true
     })) {
@@ -1268,7 +1269,7 @@ function modelOutputType(outputType2, args) {
         arguments: [
           isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`,
           import_json53.default.stringify({
-            ...settings?.fieldArguments(),
+            ...settings1?.fieldArguments(),
             nullable: Boolean(field.isNullable),
             defaultValue: [
               "number",
@@ -1279,7 +1280,7 @@ function modelOutputType(outputType2, args) {
           })
         ]
       });
-      for (const setting of settings || []) {
+      for (const setting of settings1 || []) {
         if (shouldBeDecorated(setting) && (setting.match?.(field.name) ?? true)) {
           property.decorators.push({
             name: setting.name,
@@ -1307,13 +1308,13 @@ function modelOutputType(outputType2, args) {
       propertyType
     });
   }
-  for (const setting of modelSettings || []) {
-    if (shouldBeDecorated(setting)) {
+  for (const setting1 of modelSettings || []) {
+    if (shouldBeDecorated(setting1)) {
       classStructure.decorators.push({
-        name: setting.name,
-        arguments: setting.arguments
+        name: setting1.name,
+        arguments: setting1.arguments
       });
-      importDeclarations.create(setting);
+      importDeclarations.create(setting1);
     }
   }
   if (exportDeclaration) {
@@ -1359,11 +1360,11 @@ function noAtomicOperations(eventEmitter) {
 }
 __name(noAtomicOperations, "noAtomicOperations");
 function beforeInputType2(args) {
-  const { inputType: inputType1, getModelName: getModelName2 } = args;
-  for (const field of inputType1.fields) {
+  const { inputType: inputType2, getModelName: getModelName2 } = args;
+  for (const field of inputType2.fields) {
     const fieldName = field.name;
-    field.inputTypes = field.inputTypes.filter((inputType2) => {
-      const inputTypeName = String(inputType2.type);
+    field.inputTypes = field.inputTypes.filter((inputType3) => {
+      const inputTypeName = String(inputType3.type);
       const modelName = getModelName2(inputTypeName);
       if (isAtomicOperation(inputTypeName) || modelName && isListInput(inputTypeName, modelName, fieldName)) {
         return false;
@@ -1401,29 +1402,29 @@ var import_json54 = __toESM(require("json5"));
 var import_lodash6 = require("lodash");
 var import_ts_morph6 = require("ts-morph");
 var nestjsGraphql2 = "@nestjs/graphql";
-function outputType(outputType1, args) {
+function outputType(outputType2, args) {
   const { getSourceFile, models, eventEmitter, fieldSettings, getModelName: getModelName2, config } = args;
   const importDeclarations = new ImportDeclarationMap();
   const fileType = "output";
-  const modelName = getModelName2(outputType1.name) || "";
+  const modelName = getModelName2(outputType2.name) || "";
   const model = models.get(modelName);
-  const isAggregateOutput = model && /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(outputType1.name) && String(outputType1.name).startsWith(model.name);
-  const isCountOutput = model?.name && outputType1.name === `${model.name}CountOutputType`;
-  outputType1.name = getOutputTypeName(outputType1.name);
+  const isAggregateOutput = model && /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(outputType2.name) && String(outputType2.name).startsWith(model.name);
+  const isCountOutput = model?.name && outputType2.name === `${model.name}CountOutputType`;
+  outputType2.name = getOutputTypeName(outputType2.name);
   if (isAggregateOutput) {
     eventEmitter.emitSync("AggregateOutput", {
       ...args,
-      outputType: outputType1
+      outputType: outputType2
     });
   }
   const sourceFile = getSourceFile({
-    name: outputType1.name,
+    name: outputType2.name,
     type: fileType
   });
   const classStructure = {
     kind: import_ts_morph6.StructureKind.Class,
     isExported: true,
-    name: outputType1.name,
+    name: outputType2.name,
     decorators: [
       {
         name: "ObjectType",
@@ -1434,12 +1435,12 @@ function outputType(outputType1, args) {
   };
   importDeclarations.add("Field", nestjsGraphql2);
   importDeclarations.add("ObjectType", nestjsGraphql2);
-  for (const field of outputType1.fields) {
+  for (const field of outputType2.fields) {
     const { location, isList, type } = field.outputType;
     const outputTypeName = getOutputTypeName(String(type));
     const settings = isCountOutput ? void 0 : model && fieldSettings.get(model.name)?.get(field.name);
     const propertySettings = settings?.getPropertyType({
-      name: outputType1.name,
+      name: outputType2.name,
       output: true
     });
     const isCustomsApplicable = outputTypeName === model?.fields.find((f) => f.name === field.name)?.type;
@@ -1465,11 +1466,11 @@ function outputType(outputType1, args) {
     }
     let graphqlType;
     const shouldHideField = settings?.shouldHideField({
-      name: outputType1.name,
+      name: outputType2.name,
       output: true
     }) || config.decorate.some((d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(field.name) && d.isMatchType(outputTypeName));
     const fieldType = settings?.getFieldType({
-      name: outputType1.name,
+      name: outputType2.name,
       output: true
     });
     if (fieldType && isCustomsApplicable && !shouldHideField) {
@@ -1492,7 +1493,7 @@ function outputType(outputType1, args) {
       if (location === "enumTypes") {
         referenceName = (0, import_lodash6.last)(referenceName.split(" "));
       }
-      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputType1.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
+      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputType2.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
         importDeclarations.set(graphqlImport.name, {
           namedImports: [
             {
@@ -1567,9 +1568,9 @@ function begin({ project, output }) {
 __name(begin, "begin");
 async function end({ project, output }) {
   const directories = project.getDirectory(output)?.getDescendantDirectories().filter((directory) => directory.getSourceFiles().length === 0).map((directory) => directory.getPath());
-  for (const directory1 of directories || []) {
+  for (const directory of directories || []) {
     try {
-      await import_fs.promises.rmdir(directory1);
+      await import_fs.promises.rmdir(directory);
     } catch {
     }
   }
@@ -1620,23 +1621,23 @@ function beforeGenerateFiles2(args) {
     }
   }
   if (config.reExport === ReExport.Single) {
-    const exportDeclarations = project.getSourceFiles().filter((sourceFile) => {
+    const exportDeclarations1 = project.getSourceFiles().filter((sourceFile) => {
       return sourceFile.getBaseName() !== "index.ts";
     }).map((sourceFile) => getExportDeclaration2(rootDirectory, sourceFile));
     rootDirectory.createSourceFile("index.ts", {
-      statements: exportDeclarations
+      statements: exportDeclarations1
     }, {
       overwrite: true
     });
   }
   if (config.reExport === ReExport.All) {
-    const exportDeclarations = [];
-    for (const directory of rootDirectory.getDirectories()) {
-      const sourceFile = directory.getSourceFileOrThrow("index.ts");
-      exportDeclarations.push(getExportDeclaration2(rootDirectory, sourceFile));
+    const exportDeclarations2 = [];
+    for (const directory1 of rootDirectory.getDirectories()) {
+      const sourceFile = directory1.getSourceFileOrThrow("index.ts");
+      exportDeclarations2.push(getExportDeclaration2(rootDirectory, sourceFile));
     }
     rootDirectory.createSourceFile("index.ts", {
-      statements: exportDeclarations
+      statements: exportDeclarations2
     }, {
       overwrite: true
     });
@@ -1867,18 +1868,18 @@ function generateFileName(args) {
       return (0, import_lodash8.kebabCase)(result);
     },
     get name() {
-      let result = (0, import_lodash8.kebabCase)(name);
+      let result1 = (0, import_lodash8.kebabCase)(name);
       for (const suffix of [
         "input",
         "args",
         "enum"
       ]) {
         const ending = `-${suffix}`;
-        if (type === suffix && result.endsWith(ending)) {
-          result = result.slice(0, -ending.length);
+        if (type === suffix && result1.endsWith(ending)) {
+          result1 = result1.slice(0, -ending.length);
         }
       }
-      return result;
+      return result1;
     },
     plural: {
       get type() {
@@ -1890,10 +1891,10 @@ function generateFileName(args) {
 __name(generateFileName, "generateFileName");
 
 // src/helpers/factory-get-source-file.ts
-function factoryGetSourceFile(args1) {
-  const { outputFilePattern, output, getModelName: getModelName2, project } = args1;
-  return /* @__PURE__ */ __name(function getSourceFile(args) {
-    const { name, type } = args;
+function factoryGetSourceFile(args) {
+  const { outputFilePattern, output, getModelName: getModelName2, project } = args;
+  return /* @__PURE__ */ __name(function getSourceFile(args2) {
+    const { name, type } = args2;
     let filePath = generateFileName({
       getModelName: getModelName2,
       name,
@@ -1930,30 +1931,30 @@ function getModelName(args) {
     }
   }
   for (const keyword1 of endsWithKeywords) {
-    const [test] = name.split(keyword1).slice(-1);
-    if (modelNames.includes(test)) {
-      return test;
+    const [test1] = name.split(keyword1).slice(-1);
+    if (modelNames.includes(test1)) {
+      return test1;
     }
   }
   for (const [start, end2] of middleKeywords) {
-    let test = name.slice(start.length).slice(0, -end2.length);
-    if (modelNames.includes(test)) {
-      return test;
+    let test2 = name.slice(start.length).slice(0, -end2.length);
+    if (modelNames.includes(test2)) {
+      return test2;
     }
-    test = name.slice(0, -(start + end2).length);
-    if (modelNames.includes(test)) {
-      return test;
+    test2 = name.slice(0, -(start + end2).length);
+    if (modelNames.includes(test2)) {
+      return test2;
     }
   }
   if (name.slice(-19) === "CompoundUniqueInput") {
-    const test = name.slice(0, -19);
-    const models = modelNames.filter((x) => test.startsWith(x)).sort((a, b) => b.length - a.length);
+    const test3 = name.slice(0, -19);
+    const models = modelNames.filter((x) => test3.startsWith(x)).sort((a, b) => b.length - a.length);
     return (0, import_lodash9.first)(models);
   }
   if (name.slice(-5) === "Count") {
-    const test = name.slice(0, -5);
-    if (modelNames.includes(test)) {
-      return test;
+    const test4 = name.slice(0, -5);
+    if (modelNames.includes(test4)) {
+      return test4;
     }
   }
   return void 0;
@@ -2153,19 +2154,19 @@ async function generate(args) {
   for (const enumType of enumTypes.prisma.concat(enumTypes.model || [])) {
     await eventEmitter.emit("EnumType", enumType, eventArguments);
   }
-  for (const outputType3 of outputObjectTypes.model) {
-    await eventEmitter.emit("ModelOutputType", outputType3, eventArguments);
+  for (const outputType1 of outputObjectTypes.model) {
+    await eventEmitter.emit("ModelOutputType", outputType1, eventArguments);
   }
   const queryOutputTypes = [];
-  for (const outputType1 of outputObjectTypes.prisma) {
+  for (const outputType2 of outputObjectTypes.prisma) {
     if ([
       "Query",
       "Mutation"
-    ].includes(outputType1.name)) {
-      queryOutputTypes.push(outputType1);
+    ].includes(outputType2.name)) {
+      queryOutputTypes.push(outputType2);
       continue;
     }
-    await eventEmitter.emit("OutputType", outputType1, eventArguments);
+    await eventEmitter.emit("OutputType", outputType2, eventArguments);
   }
   const inputTypes = inputObjectTypes.prisma.concat(inputObjectTypes.model || []);
   for (const inputType1 of inputTypes) {
@@ -2182,8 +2183,8 @@ async function generate(args) {
     await eventEmitter.emit("BeforeInputType", event);
     await eventEmitter.emit("InputType", event);
   }
-  for (const outputType2 of queryOutputTypes) {
-    for (const field of outputType2.fields) {
+  for (const outputType3 of queryOutputTypes) {
+    for (const field of outputType3.fields) {
       await eventEmitter.emit("ArgsType", field, eventArguments);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-nestjs-graphql",
-  "version": "16.0.1",
+  "version": "17.0.0",
   "license": "MIT",
   "description": "Generate object types, inputs, args, etc. from prisma schema file for usage with @nestjs/graphql module",
   "main": "index.js",
@@ -52,7 +52,7 @@
     }
   },
   "dependencies": {
-    "@prisma/generator-helper": "^3.14.0",
+    "@prisma/generator-helper": "^4.0.0",
     "await-event-emitter": "^2.0.2",
     "filenamify": "4.X",
     "flat": "^5.0.2",
@@ -73,7 +73,7 @@
     "@nestjs/graphql": "^10.0.12",
     "@nestjs/platform-express": "^8.4.5",
     "@paljs/plugins": "^4.1.0",
-    "@prisma/client": "^3.14.0",
+    "@prisma/client": "^4.0.0",
     "@semantic-release/changelog": "^6.0.1",
     "@semantic-release/git": "^10.0.1",
     "@swc/core": "^1.2.189",
@@ -114,7 +114,7 @@
     "ololog": "^1.1.175",
     "precise-commits": "^1.0.2",
     "prettier": "^2.6.2",
-    "prisma": "^3.14.0",
+    "prisma": "^4.0.0",
     "prisma-graphql-type-decimal": "^2.0.2",
     "reflect-metadata": "^0.1.13",
     "request": "^2.88.2",