prisma-nestjs-graphql 14.6.2 → 14.7.0

package/index.js

@@ -22,6 +22,7 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __reExport = (target, module2, copyDefault, desc) => {
   if (module2 && typeof module2 === "object" || typeof module2 === "function") {
     for (let key of __getOwnPropNames(module2))
@@ -48,10 +49,14 @@ var import_lodash = require("lodash");
 function pascalCase(string) {
   return (0, import_lodash.startCase)((0, import_lodash.camelCase)(string)).replace(/ /g, "");
 }
+__name(pascalCase, "pascalCase");
 
 // src/handlers/args-type.ts
 function argsType(field, args) {
-  if (["queryRaw", "executeRaw"].includes(field.name)) {
+  if ([
+    "queryRaw",
+    "executeRaw"
+  ].includes(field.name)) {
     return;
   }
   const { eventEmitter, typeNames, getModelName: getModelName2 } = args;
@@ -65,24 +70,38 @@ function argsType(field, args) {
       className = `${modelName}GroupByArgs`;
       break;
   }
-  const inputType2 = {
-    constraints: { maxNumFields: null, minNumFields: null },
+  const inputType1 = {
+    constraints: {
+      maxNumFields: null,
+      minNumFields: null
+    },
     name: className,
-    fields: [...field.args]
+    fields: [
+      ...field.args
+    ]
   };
-  if (!field.args.some((x) => x.name === "_count") && [`${modelName}AggregateArgs`, `${modelName}GroupByArgs`].includes(className)) {
-    const names = ["Count", "Avg", "Sum", "Min", "Max"];
-    if (`${modelName}GroupByArgs` === inputType2.name) {
-      const byField = inputType2.fields.find((f) => f.name === "by");
+  if (!field.args.some((x) => x.name === "_count") && [
+    `${modelName}AggregateArgs`,
+    `${modelName}GroupByArgs`
+  ].includes(className)) {
+    const names = [
+      "Count",
+      "Avg",
+      "Sum",
+      "Min",
+      "Max"
+    ];
+    if (`${modelName}GroupByArgs` === inputType1.name) {
+      const byField = inputType1.fields.find((f) => f.name === "by");
       if (byField == null ? void 0 : byField.inputTypes) {
-        byField.inputTypes = byField.inputTypes.filter((inputType3) => inputType3.isList);
+        byField.inputTypes = byField.inputTypes.filter((inputType2) => inputType2.isList);
       }
     }
     for (const name of names) {
       if (!typeNames.has(`${modelName}${name}AggregateInput`)) {
         continue;
       }
-      inputType2.fields.push({
+      inputType1.fields.push({
         name: `_${name.toLowerCase()}`,
         isRequired: false,
         isNullable: true,
@@ -97,23 +116,26 @@ function argsType(field, args) {
     }
   }
   eventEmitter.emitSync("InputType", __spreadProps(__spreadValues({}, args), {
-    inputType: inputType2,
+    inputType: inputType1,
     fileType: "args",
     classDecoratorName: "ArgsType"
   }));
 }
+__name(argsType, "argsType");
 
 // src/handlers/combine-scalar-filters.ts
 function combineScalarFilters(eventEmitter) {
   eventEmitter.on("BeforeInputType", beforeInputType);
   eventEmitter.on("BeforeGenerateField", beforeGenerateField);
 }
+__name(combineScalarFilters, "combineScalarFilters");
 function beforeInputType(args) {
   const { inputType: inputType2 } = args;
   if (isContainBogus(inputType2.name) && isScalarFilter(inputType2)) {
     inputType2.name = replaceBogus(String(inputType2.name));
   }
 }
+__name(beforeInputType, "beforeInputType");
 function beforeGenerateField(field) {
   for (const fieldInput of field.inputTypes) {
     if (fieldInput.location !== "inputObjectTypes") {
@@ -125,12 +147,15 @@ function beforeGenerateField(field) {
     }
   }
 }
+__name(beforeGenerateField, "beforeGenerateField");
 function replaceBogus(name) {
   return name.replace(/(Nullable|Nested)/g, "");
 }
+__name(replaceBogus, "replaceBogus");
 function isContainBogus(name) {
   return name.startsWith("Nested") || name.includes("Nullable") && name.endsWith("Filter") || name.endsWith("NullableFilter");
 }
+__name(isContainBogus, "isContainBogus");
 function isScalarFilter(inputType2) {
   if (!inputType2.name.endsWith("Filter")) {
     return false;
@@ -139,18 +164,25 @@ function isScalarFilter(inputType2) {
   const equals = inputType2.fields.find((f) => f.name === "equals");
   if (equals) {
     result = equals.inputTypes.every((x) => {
-      return ["enumTypes", "scalar"].includes(x.location);
+      return [
+        "enumTypes",
+        "scalar"
+      ].includes(x.location);
     });
   }
   return result;
 }
+__name(isScalarFilter, "isScalarFilter");
 
 // src/handlers/create-aggregate-input.ts
 function createAggregateInput(args) {
   const { eventEmitter, outputType: outputType2 } = args;
   const className = `${outputType2.name}Input`;
   const inputType2 = {
-    constraints: { maxNumFields: null, minNumFields: null },
+    constraints: {
+      maxNumFields: null,
+      minNumFields: null
+    },
     name: className,
     fields: outputType2.fields.map((x) => {
       var _a;
@@ -174,14 +206,19 @@ function createAggregateInput(args) {
     classDecoratorName: "InputType"
   }));
 }
+__name(createAggregateInput, "createAggregateInput");
 
 // src/handlers/emit-single.ts
 function emitSingle(emitter) {
   emitter.on("ClassProperty", classProperty);
 }
+__name(emitSingle, "emitSingle");
 function classProperty(property, eventArguments) {
   const { location, isList, propertyType } = eventArguments;
-  if (["inputObjectTypes", "outputObjectTypes"].includes(location) && !isList) {
+  if ([
+    "inputObjectTypes",
+    "outputObjectTypes"
+  ].includes(location) && !isList) {
     const types = propertyType.filter((t) => t !== "null");
     property.type = types.map((t) => `InstanceType<typeof ${t}>`).join(" | ");
     if (types.length !== propertyType.length) {
@@ -189,6 +226,7 @@ function classProperty(property, eventArguments) {
     }
   }
 }
+__name(classProperty, "classProperty");
 
 // src/handlers/generate-files.ts
 var import_assert = require("assert");
@@ -199,7 +237,14 @@ var import_ts_morph = require("ts-morph");
 var ImportDeclarationMap = class extends Map {
   add(name, value) {
     if (!this.has(name)) {
-      const structure = typeof value === "string" ? { moduleSpecifier: value, namedImports: [{ name }] } : value;
+      const structure = typeof value === "string" ? {
+        moduleSpecifier: value,
+        namedImports: [
+          {
+            name
+          }
+        ]
+      } : value;
       this.set(name, structure);
     }
   }
@@ -213,7 +258,11 @@ var ImportDeclarationMap = class extends Map {
       namespaceImport: void 0
     };
     if (namedImport === true && namespaceImport) {
-      value.namedImports = [{ name: namespaceImport }];
+      value.namedImports = [
+        {
+          name: namespaceImport
+        }
+      ];
       name = namespaceImport;
     } else if (defaultImport) {
       value.defaultImport = defaultImport === true ? name : defaultImport;
@@ -222,7 +271,11 @@ var ImportDeclarationMap = class extends Map {
       value.namespaceImport = namespaceImport;
       name = namespaceImport;
     } else {
-      value.namedImports = [{ name }];
+      value.namedImports = [
+        {
+          name
+        }
+      ];
     }
     this.add(name, value);
   }
@@ -237,6 +290,7 @@ var ImportDeclarationMap = class extends Map {
     }
   }
 };
+__name(ImportDeclarationMap, "ImportDeclarationMap");
 
 // src/handlers/generate-files.ts
 function beforeGenerateFiles(args) {
@@ -244,15 +298,15 @@ function beforeGenerateFiles(args) {
   if (config.emitSingle) {
     const rootDirectory = project.getDirectory(output) || project.createDirectory(output);
     const sourceFile = rootDirectory.getSourceFile("index.ts") || rootDirectory.createSourceFile("index.ts");
-    const statements = project.getSourceFiles().flatMap((s) => {
+    const statements1 = project.getSourceFiles().flatMap((s) => {
       var _a, _b;
       if (s === sourceFile) {
         return [];
       }
       const classDeclaration = s.getClass(() => true);
-      const statements2 = s.getStructure().statements;
-      if (Array.isArray(statements2)) {
-        for (const statement of statements2) {
+      const statements = s.getStructure().statements;
+      if (Array.isArray(statements)) {
+        for (const statement of statements) {
           if (!(typeof statement === "object" && statement.kind === import_ts_morph2.StructureKind.Class)) {
             continue;
           }
@@ -266,56 +320,61 @@ function beforeGenerateFiles(args) {
         }
       }
       project.removeSourceFile(s);
-      return statements2;
+      return statements;
     });
     const imports = new ImportDeclarationMap();
     const enums = [];
     const classes = [];
-    for (const statement of statements) {
-      if (typeof statement === "string") {
-        if (statement.startsWith("registerEnumType")) {
-          enums.push(statement);
+    for (const statement1 of statements1) {
+      if (typeof statement1 === "string") {
+        if (statement1.startsWith("registerEnumType")) {
+          enums.push(statement1);
         }
         continue;
       }
-      switch (statement.kind) {
+      switch (statement1.kind) {
         case import_ts_morph2.StructureKind.ImportDeclaration:
-          if (statement.moduleSpecifier.startsWith("./") || statement.moduleSpecifier.startsWith("..")) {
+          if (statement1.moduleSpecifier.startsWith("./") || statement1.moduleSpecifier.startsWith("..")) {
             continue;
           }
-          for (const namedImport of statement.namedImports) {
+          for (const namedImport of statement1.namedImports) {
             const name = namedImport.alias || namedImport.name;
-            imports.add(name, statement.moduleSpecifier);
+            imports.add(name, statement1.moduleSpecifier);
           }
-          if (statement.defaultImport) {
+          if (statement1.defaultImport) {
             imports.create({
-              from: statement.moduleSpecifier,
-              name: statement.defaultImport,
-              defaultImport: statement.defaultImport
+              from: statement1.moduleSpecifier,
+              name: statement1.defaultImport,
+              defaultImport: statement1.defaultImport
             });
           }
-          if (statement.namespaceImport) {
+          if (statement1.namespaceImport) {
             imports.create({
-              from: statement.moduleSpecifier,
-              name: statement.namespaceImport,
-              namespaceImport: statement.namespaceImport
+              from: statement1.moduleSpecifier,
+              name: statement1.namespaceImport,
+              namespaceImport: statement1.namespaceImport
             });
           }
           break;
         case import_ts_morph2.StructureKind.Enum:
-          enums.unshift(statement);
+          enums.unshift(statement1);
           break;
         case import_ts_morph2.StructureKind.Class:
-          classes.push(statement);
+          classes.push(statement1);
           break;
       }
     }
     sourceFile.set({
       kind: import_ts_morph2.StructureKind.SourceFile,
-      statements: [...imports.toStatements(), ...enums, ...classes]
+      statements: [
+        ...imports.toStatements(),
+        ...enums,
+        ...classes
+      ]
     });
   }
 }
+__name(beforeGenerateFiles, "beforeGenerateFiles");
 async function generateFiles(args) {
   const { project, config, output, eventEmitter } = args;
   if (config.emitCompiled) {
@@ -336,6 +395,7 @@ async function generateFiles(args) {
     await project.save();
   }
 }
+__name(generateFiles, "generateFiles");
 
 // src/handlers/input-type.ts
 var import_assert2 = require("assert");
@@ -356,6 +416,7 @@ function fileTypeByLocation(fieldLocation) {
   }
   return "object";
 }
+__name(fileTypeByLocation, "fileTypeByLocation");
 
 // src/helpers/relative-path.ts
 var import_get_relative_path = __toESM(require("get-relative-path"));
@@ -375,32 +436,58 @@ function relativePath(from, to) {
   }
   return result;
 }
+__name(relativePath, "relativePath");
 
 // src/helpers/get-graphql-import.ts
 function getGraphqlImport(args) {
-  const { fileType, location, typeName, isId, noTypeId, sourceFile, getSourceFile } = args;
+  const { config, fileType, location, typeName, isId, noTypeId, sourceFile, getSourceFile } = args;
   if (location === "scalar") {
     if (isId && !noTypeId) {
-      return { name: "ID", specifier: "@nestjs/graphql" };
+      return {
+        name: "ID",
+        specifier: "@nestjs/graphql"
+      };
+    }
+    const graphqlType = config.graphqlScalars[typeName];
+    if (graphqlType) {
+      return {
+        name: graphqlType.name,
+        specifier: graphqlType.specifier
+      };
     }
     switch (typeName) {
       case "Float":
       case "Int":
-        return { name: typeName, specifier: "@nestjs/graphql" };
+        return {
+          name: typeName,
+          specifier: "@nestjs/graphql"
+        };
       case "DateTime":
-        return { name: "Date", specifier: void 0 };
+        return {
+          name: "Date",
+          specifier: void 0
+        };
       case "true":
       case "Boolean":
-        return { name: "Boolean", specifier: void 0 };
+        return {
+          name: "Boolean",
+          specifier: void 0
+        };
       case "Decimal":
         return {
           name: "GraphQLDecimal",
           specifier: "prisma-graphql-type-decimal"
         };
       case "Json":
-        return { name: "GraphQLJSON", specifier: "graphql-type-json" };
+        return {
+          name: "GraphQLJSON",
+          specifier: "graphql-type-json"
+        };
     }
-    return { name: "String", specifier: void 0 };
+    return {
+      name: "String",
+      specifier: void 0
+    };
   }
   let sourceFileType = fileTypeByLocation(location);
   if (sourceFileType === "output" && fileType === "model") {
@@ -410,15 +497,22 @@ function getGraphqlImport(args) {
     type: sourceFileType,
     name: typeName
   }).getFilePath());
-  return { name: typeName, specifier };
+  return {
+    name: typeName,
+    specifier
+  };
 }
+__name(getGraphqlImport, "getGraphqlImport");
 
 // src/helpers/get-graphql-input-type.ts
 var import_lodash2 = require("lodash");
 var import_outmatch = __toESM(require("outmatch"));
 function getGraphqlInputType(inputTypes, pattern) {
   let result;
-  inputTypes = inputTypes.filter((t) => !["null", "Null"].includes(String(t.type)));
+  inputTypes = inputTypes.filter((t) => ![
+    "null",
+    "Null"
+  ].includes(String(t.type)));
   if (inputTypes.length === 1) {
     return inputTypes[0];
   }
@@ -433,7 +527,9 @@ function getGraphqlInputType(inputTypes, pattern) {
   if (pattern) {
     if (pattern.startsWith("matcher:") || pattern.startsWith("match:")) {
       const { 1: patternValue } = pattern.split(":", 2);
-      const isMatch = (0, import_outmatch.default)(patternValue, { separator: false });
+      const isMatch = (0, import_outmatch.default)(patternValue, {
+        separator: false
+      });
       result = inputTypes.find((x) => isMatch(String(x.type)));
       if (result) {
         return result;
@@ -456,6 +552,7 @@ function getGraphqlInputType(inputTypes, pattern) {
   }
   throw new TypeError(`Cannot get matching input type from ${inputTypes.map((x) => x.type).join(", ") || "zero length inputTypes"}`);
 }
+__name(getGraphqlInputType, "getGraphqlInputType");
 
 // src/helpers/get-property-type.ts
 function getPropertyType(args) {
@@ -463,84 +560,96 @@ function getPropertyType(args) {
   switch (type) {
     case "Float":
     case "Int":
-      return ["number"];
+      return [
+        "number"
+      ];
     case "String":
-      return ["string"];
+      return [
+        "string"
+      ];
     case "Boolean":
-      return ["boolean"];
+      return [
+        "boolean"
+      ];
     case "DateTime":
-      return ["Date", "string"];
+      return [
+        "Date",
+        "string"
+      ];
     case "Decimal":
     case "Json":
-      return ["any"];
+      return [
+        "any"
+      ];
     case "Null":
-      return ["null"];
+      return [
+        "null"
+      ];
     case "Bytes":
-      return ["Buffer"];
+      return [
+        "Buffer"
+      ];
     case "BigInt":
-      return ["bigint", "number"];
-  }
-  if (["inputObjectTypes", "outputObjectTypes"].includes(location)) {
-    return [type];
+      return [
+        "bigint",
+        "number"
+      ];
+  }
+  if ([
+    "inputObjectTypes",
+    "outputObjectTypes"
+  ].includes(location)) {
+    return [
+      type
+    ];
   }
   if (location === "enumTypes") {
-    return [`keyof typeof ${type}`];
+    return [
+      `keyof typeof ${type}`
+    ];
   }
   if (location === "scalar") {
-    return [type];
+    return [
+      type
+    ];
   }
-  return ["unknown"];
+  return [
+    "unknown"
+  ];
 }
+__name(getPropertyType, "getPropertyType");
 
 // src/helpers/property-structure.ts
 var import_ts_morph3 = require("ts-morph");
 function propertyStructure(args) {
-  const {
-    isNullable,
-    propertyType,
-    name,
-    isList,
-    hasQuestionToken,
-    hasExclamationToken
-  } = args;
-  const type = propertyType.map((type2) => isList ? `Array<${type2}>` : type2).join(" | ");
+  const { isNullable, propertyType, name, isList, hasQuestionToken, hasExclamationToken } = args;
+  const type1 = propertyType.map((type) => isList ? `Array<${type}>` : type).join(" | ");
   return {
     kind: import_ts_morph3.StructureKind.Property,
     name,
-    type,
+    type: type1,
     hasQuestionToken: hasQuestionToken != null ? hasQuestionToken : isNullable,
     hasExclamationToken: hasExclamationToken != null ? hasExclamationToken : !isNullable,
     decorators: [],
     leadingTrivia: "\n"
   };
 }
+__name(propertyStructure, "propertyStructure");
 
 // src/handlers/input-type.ts
 function inputType(args) {
   var _a, _b, _c, _d;
-  const {
-    inputType: inputType2,
-    fileType,
-    getSourceFile,
-    config,
-    eventEmitter,
-    classDecoratorName,
-    fieldSettings,
-    getModelName: getModelName2,
-    models,
-    removeTypes,
-    typeNames
-  } = args;
-  typeNames.add(inputType2.name);
+  const { inputType: inputType1, fileType, getSourceFile, config, eventEmitter, classDecoratorName, fieldSettings, getModelName: getModelName2, models, removeTypes, typeNames } = args;
+  typeNames.add(inputType1.name);
   const importDeclarations = new ImportDeclarationMap();
   const sourceFile = getSourceFile({
-    name: inputType2.name,
+    name: inputType1.name,
     type: fileType
   });
   const classStructure = {
     kind: import_ts_morph4.StructureKind.Class,
     isExported: true,
-    name: inputType2.name,
+    name: inputType1.name,
     decorators: [
       {
         name: classDecoratorName,
@@ -549,19 +658,27 @@ function inputType(args) {
     ],
     properties: []
   };
-  const modelName = getModelName2(inputType2.name) || "";
+  const modelName = getModelName2(inputType1.name) || "";
   const model = models.get(modelName);
   const modelFieldSettings = model && fieldSettings.get(model.name);
   const moduleSpecifier = "@nestjs/graphql";
   importDeclarations.set("Field", {
-    namedImports: [{ name: "Field" }],
+    namedImports: [
+      {
+        name: "Field"
+      }
+    ],
     moduleSpecifier
   }).set(classDecoratorName, {
-    namedImports: [{ name: classDecoratorName }],
+    namedImports: [
+      {
+        name: classDecoratorName
+      }
+    ],
     moduleSpecifier
   });
-  const useInputType = config.useInputType.find((x) => inputType2.name.includes(x.typeName));
-  for (const field of inputType2.fields) {
+  const useInputType = config.useInputType.find((x) => inputType1.name.includes(x.typeName));
+  for (const field of inputType1.fields) {
     field.inputTypes = field.inputTypes.filter((t) => !removeTypes.has(String(t.type)));
     eventEmitter.emitSync("BeforeGenerateField", field, args);
     const { inputTypes, isRequired, name } = field;
@@ -571,7 +688,7 @@ function inputType(args) {
     const typeName = String(type);
     const settings = modelFieldSettings == null ? void 0 : modelFieldSettings.get(name);
     const propertySettings = settings == null ? void 0 : settings.getPropertyType({
-      name: inputType2.name,
+      name: inputType1.name,
       input: true
     });
     const isCustomsApplicable = typeName === ((_a = model == null ? void 0 : model.fields.find((f) => f.name === name)) == null ? void 0 : _a.type);
@@ -591,11 +708,11 @@ function inputType(args) {
     }
     let graphqlType;
     const shouldHideField = settings == null ? void 0 : settings.shouldHideField({
-      name: inputType2.name,
+      name: inputType1.name,
       input: true
     });
     const fieldType = settings == null ? void 0 : settings.getFieldType({
-      name: inputType2.name,
+      name: inputType1.name,
       input: true
     });
     if (fieldType && isCustomsApplicable && !shouldHideField) {
@@ -603,6 +720,7 @@ function inputType(args) {
       importDeclarations.create(__spreadValues({}, fieldType));
     } else {
       const graphqlImport = getGraphqlImport({
+        config,
         sourceFile,
         location,
         typeName,
@@ -613,9 +731,13 @@ function inputType(args) {
       if (location === "enumTypes") {
         referenceName = (0, import_lodash3.last)(referenceName.split(" "));
       }
-      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== inputType2.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
+      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== inputType1.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
         importDeclarations.set(graphqlImport.name, {
-          namedImports: [{ name: graphqlImport.name }],
+          namedImports: [
+            {
+              name: graphqlImport.name
+            }
+          ],
           moduleSpecifier: graphqlImport.specifier
         });
       }
@@ -623,7 +745,10 @@ function inputType(args) {
     (0, import_assert2.ok)(property.decorators, "property.decorators is undefined");
     if (shouldHideField) {
       importDeclarations.add("HideField", "@nestjs/graphql");
-      property.decorators.push({ name: "HideField", arguments: [] });
+      property.decorators.push({
+        name: "HideField",
+        arguments: []
+      });
     } else {
       property.decorators.push({
         name: "Field",
@@ -647,10 +772,12 @@ function inputType(args) {
         }
       }
       for (const decorate of config.decorate) {
-        if (decorate.isMatchField(name) && decorate.isMatchType(inputType2.name)) {
+        if (decorate.isMatchField(name) && decorate.isMatchType(inputType1.name)) {
           property.decorators.push({
             name: decorate.name,
-            arguments: (_d = decorate.arguments) == null ? void 0 : _d.map((x) => (0, import_pupa.default)(x, { propertyType }))
+            arguments: (_d = decorate.arguments) == null ? void 0 : _d.map((x) => (0, import_pupa.default)(x, {
+              propertyType
+            }))
           });
           importDeclarations.create(decorate);
         }
@@ -663,29 +790,25 @@ function inputType(args) {
     });
   }
   sourceFile.set({
-    statements: [...importDeclarations.toStatements(), classStructure]
+    statements: [
+      ...importDeclarations.toStatements(),
+      classStructure
+    ]
   });
 }
+__name(inputType, "inputType");
 
 // src/helpers/object-settings.ts
 var import_json52 = __toESM(require("json5"));
 var import_lodash4 = require("lodash");
 var import_outmatch2 = __toESM(require("outmatch"));
 var ObjectSettings = class extends Array {
-  shouldHideField({
-    name,
-    input = false,
-    output = false
-  }) {
+  shouldHideField({ name, input = false, output = false }) {
     var _a;
     const hideField = this.find((s) => s.name === "HideField");
     return Boolean((hideField == null ? void 0 : hideField.input) && input || (hideField == null ? void 0 : hideField.output) && output || ((_a = hideField == null ? void 0 : hideField.match) == null ? void 0 : _a.call(hideField, name)));
   }
-  getFieldType({
-    name,
-    input,
-    output
-  }) {
+  getFieldType({ name, input, output }) {
     const fieldType = this.find((s) => s.kind === "FieldType");
     if (!fieldType) {
       return void 0;
@@ -713,7 +836,9 @@ var ObjectSettings = class extends Array {
   }
   getObjectTypeArguments(options) {
     const objectTypeOptions = (0, import_lodash4.merge)({}, options);
-    const resultArguments = [objectTypeOptions];
+    const resultArguments = [
+      objectTypeOptions
+    ];
     const objectType = this.find((s) => s.kind === "ObjectType");
     if (objectType && (0, import_lodash4.isObject)(objectType.arguments)) {
       const name = objectType.arguments.name;
@@ -725,6 +850,7 @@ var ObjectSettings = class extends Array {
     return resultArguments.map((x) => import_json52.default.stringify(x));
   }
 };
+__name(ObjectSettings, "ObjectSettings");
 function createObjectSettings(args) {
   var _a, _b, _c, _d, _e;
   const { config, text } = args;
@@ -749,9 +875,14 @@ function createObjectSettings(args) {
     };
     if (name === "TypeGraphQL.omit" || name === "HideField") {
       Object.assign(element, hideFieldDecorator(match));
-    } else if (["FieldType", "PropertyType"].includes(name) && ((_b = match.groups) == null ? void 0 : _b.args)) {
+    } else if ([
+      "FieldType",
+      "PropertyType"
+    ].includes(name) && ((_b = match.groups) == null ? void 0 : _b.args)) {
       const options = customType(match.groups.args);
-      (0, import_lodash4.merge)(element, options.namespace && config.fields[options.namespace], options, { kind: name });
+      (0, import_lodash4.merge)(element, options.namespace && config.fields[options.namespace], options, {
+        kind: name
+      });
     } else if (name === "ObjectType" && ((_c = match.groups) == null ? void 0 : _c.args)) {
       element.kind = "ObjectType";
       const options = customType(match.groups.args);
@@ -767,7 +898,10 @@ function createObjectSettings(args) {
       };
     } else if (name === "Directive" && ((_d = match.groups) == null ? void 0 : _d.args)) {
       const options = customType(match.groups.args);
-      (0, import_lodash4.merge)(element, { model: true, from: "@nestjs/graphql" }, options, {
+      (0, import_lodash4.merge)(element, {
+        model: true,
+        from: "@nestjs/graphql"
+      }, options, {
         name,
         namespace: false,
         kind: "Decorator",
@@ -789,12 +923,15 @@ function createObjectSettings(args) {
     documentation: documentationLines.filter(Boolean).join("\\n") || void 0
   };
 }
+__name(createObjectSettings, "createObjectSettings");
 function customType(args) {
   var _a;
   const result = {};
   let options = parseArgs(args);
   if (typeof options === "string") {
-    options = { name: options };
+    options = {
+      name: options
+    };
   }
   Object.assign(result, options);
   const namespace = getNamespace(options.name);
@@ -803,10 +940,13 @@ function customType(args) {
     result.namespaceImport = namespace;
   }
   if (typeof options.match === "string" || Array.isArray(options.match)) {
-    result.match = (0, import_outmatch2.default)(options.match, { separator: false });
+    result.match = (0, import_outmatch2.default)(options.match, {
+      separator: false
+    });
   }
   return result;
 }
+__name(customType, "customType");
 function hideFieldDecorator(match) {
   var _a;
   const result = {
@@ -826,7 +966,9 @@ function hideFieldDecorator(match) {
     result.output = Boolean(options.output);
     result.input = Boolean(options.input);
     if (typeof options.match === "string" || Array.isArray(options.match)) {
-      result.match = (0, import_outmatch2.default)(options.match, { separator: false });
+      result.match = (0, import_outmatch2.default)(options.match, {
+        separator: false
+      });
     }
   } else {
     if (/output:\s*true/.test(match.groups.args)) {
@@ -838,6 +980,7 @@ function hideFieldDecorator(match) {
   }
   return result;
 }
+__name(hideFieldDecorator, "hideFieldDecorator");
 function parseArgs(string) {
   try {
     return import_json52.default.parse(string);
@@ -849,6 +992,7 @@ function parseArgs(string) {
     }
   }
 }
+__name(parseArgs, "parseArgs");
 function getNamespace(name) {
   if (name === void 0) {
     return void 0;
@@ -859,6 +1003,7 @@ function getNamespace(name) {
   }
   return result;
 }
+__name(getNamespace, "getNamespace");
 
 // src/handlers/model-data.ts
 function modelData(model, args) {
@@ -881,6 +1026,7 @@ function modelData(model, args) {
     modelFieldsValue.set(field.name, field);
   }
 }
+__name(modelData, "modelData");
 
 // src/handlers/model-output-type.ts
 var import_assert3 = require("assert");
@@ -893,6 +1039,7 @@ var import_ts_morph5 = require("ts-morph");
 function getOutputTypeName(name) {
   return name.replace(/(?:OutputType|Output)$/, "");
 }
+__name(getOutputTypeName, "getOutputTypeName");
 
 // src/handlers/model-output-type.ts
 var nestjsGraphql = "@nestjs/graphql";
@@ -975,6 +1122,7 @@ function modelOutputType(outputType2, args) {
       importDeclarations.create(__spreadValues({}, fieldType));
     } else {
       const graphqlImport = getGraphqlImport({
+        config,
         sourceFile,
         fileType,
         location,
@@ -1005,9 +1153,15 @@ function modelOutputType(outputType2, args) {
       importDeclarations.create(__spreadValues({}, propertySettings));
     }
     (0, import_assert3.ok)(property.decorators, "property.decorators is undefined");
-    if (settings == null ? void 0 : settings.shouldHideField({ name: outputType2.name, output: true })) {
+    if (settings == null ? void 0 : settings.shouldHideField({
+      name: outputType2.name,
+      output: true
+    })) {
       importDeclarations.add("HideField", nestjsGraphql);
-      property.decorators.push({ name: "HideField", arguments: [] });
+      property.decorators.push({
+        name: "HideField",
+        arguments: []
+      });
     } else {
       property.decorators.push({
         name: "Field",
@@ -1015,7 +1169,11 @@ function modelOutputType(outputType2, args) {
           isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`,
           import_json53.default.stringify({
             nullable: Boolean(field.isNullable),
-            defaultValue: ["number", "string", "boolean"].includes(typeof (modelField == null ? void 0 : modelField.default)) ? modelField == null ? void 0 : modelField.default : void 0,
+            defaultValue: [
+              "number",
+              "string",
+              "boolean"
+            ].includes(typeof (modelField == null ? void 0 : modelField.default)) ? modelField == null ? void 0 : modelField.default : void 0,
             description: modelField == null ? void 0 : modelField.documentation
           })
         ]
@@ -1034,7 +1192,9 @@ function modelOutputType(outputType2, args) {
         if (decorate.isMatchField(field.name) && decorate.isMatchType(outputTypeName)) {
           property.decorators.push({
             name: decorate.name,
-            arguments: (_f = decorate.arguments) == null ? void 0 : _f.map((x) => (0, import_pupa2.default)(x, { propertyType }))
+            arguments: (_f = decorate.arguments) == null ? void 0 : _f.map((x) => (0, import_pupa2.default)(x, {
+              propertyType
+            }))
           });
           importDeclarations.create(decorate);
         }
@@ -1057,43 +1217,58 @@ function modelOutputType(outputType2, args) {
   }
   if (exportDeclaration) {
     sourceFile.set({
-      statements: [exportDeclaration, "\n", classStructure]
+      statements: [
+        exportDeclaration,
+        "\n",
+        classStructure
+      ]
     });
     const classDeclaration = sourceFile.getClassOrThrow(model.name);
     const commentedText = classDeclaration.getText().split("\n").map((x) => `// ${x}`);
     classDeclaration.remove();
-    sourceFile.addStatements(["\n", ...commentedText]);
+    sourceFile.addStatements([
+      "\n",
+      ...commentedText
+    ]);
   } else {
     sourceFile.set({
-      statements: [...importDeclarations.toStatements(), classStructure]
+      statements: [
+        ...importDeclarations.toStatements(),
+        classStructure
+      ]
     });
   }
 }
+__name(modelOutputType, "modelOutputType");
 function shouldBeDecorated(setting) {
   return setting.kind === "Decorator" && (setting.output || setting.model) && !(setting.output && setting.model);
 }
+__name(shouldBeDecorated, "shouldBeDecorated");
 function getExportDeclaration(name, statements) {
   return statements.find((structure) => {
     return structure.kind === import_ts_morph5.StructureKind.ExportDeclaration && structure.namedExports.some((o) => (o.alias || o.name) === name);
   });
 }
+__name(getExportDeclaration, "getExportDeclaration");
 
 // src/handlers/no-atomic-operations.ts
 function noAtomicOperations(eventEmitter) {
   eventEmitter.on("BeforeInputType", beforeInputType2);
   eventEmitter.on("BeforeGenerateFiles", beforeGenerateFiles2);
 }
+__name(noAtomicOperations, "noAtomicOperations");
 function beforeInputType2(args) {
-  const { inputType: inputType2 } = args;
-  for (const field of inputType2.fields) {
-    field.inputTypes = field.inputTypes.filter((inputType3) => {
-      if (isAtomicOperation(String(inputType3.type))) {
+  const { inputType: inputType1 } = args;
+  for (const field of inputType1.fields) {
+    field.inputTypes = field.inputTypes.filter((inputType2) => {
+      if (isAtomicOperation(String(inputType2.type))) {
         return false;
       }
       return true;
     });
   }
 }
+__name(beforeInputType2, "beforeInputType");
 function beforeGenerateFiles2(args) {
   var _a;
   const { project } = args;
@@ -1104,9 +1279,11 @@ function beforeGenerateFiles2(args) {
     }
   }
 }
+__name(beforeGenerateFiles2, "beforeGenerateFiles");
 function isAtomicOperation(name) {
   return name.endsWith("FieldUpdateOperationsInput");
 }
+__name(isAtomicOperation, "isAtomicOperation");
 
 // src/handlers/output-type.ts
 var import_assert4 = require("assert");
@@ -1114,27 +1291,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(outputType2, args) {
+function outputType(outputType1, args) {
   var _a, _b, _c, _d, _e;
-  const { getSourceFile, models, eventEmitter, fieldSettings, getModelName: getModelName2 } = args;
+  const { getSourceFile, models, eventEmitter, fieldSettings, getModelName: getModelName2, config } = args;
   const importDeclarations = new ImportDeclarationMap();
   const fileType = "output";
-  const modelName = getModelName2(outputType2.name) || "";
+  const modelName = getModelName2(outputType1.name) || "";
   const model = models.get(modelName);
-  const isAggregateOutput = model && /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(outputType2.name) && String(outputType2.name).startsWith(model.name);
-  const isCountOutput = (model == null ? void 0 : model.name) && outputType2.name === `${model.name}CountOutputType`;
-  outputType2.name = getOutputTypeName(outputType2.name);
+  const isAggregateOutput = model && /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(outputType1.name) && String(outputType1.name).startsWith(model.name);
+  const isCountOutput = (model == null ? void 0 : model.name) && outputType1.name === `${model.name}CountOutputType`;
+  outputType1.name = getOutputTypeName(outputType1.name);
   if (isAggregateOutput) {
-    eventEmitter.emitSync("AggregateOutput", __spreadProps(__spreadValues({}, args), { outputType: outputType2 }));
+    eventEmitter.emitSync("AggregateOutput", __spreadProps(__spreadValues({}, args), {
+      outputType: outputType1
+    }));
   }
   const sourceFile = getSourceFile({
-    name: outputType2.name,
+    name: outputType1.name,
     type: fileType
   });
   const classStructure = {
     kind: import_ts_morph6.StructureKind.Class,
     isExported: true,
-    name: outputType2.name,
+    name: outputType1.name,
     decorators: [
       {
         name: "ObjectType",
@@ -1145,12 +1324,12 @@ function outputType(outputType2, args) {
   };
   importDeclarations.add("Field", nestjsGraphql2);
   importDeclarations.add("ObjectType", nestjsGraphql2);
-  for (const field of outputType2.fields) {
+  for (const field of outputType1.fields) {
     const { location, isList, type } = field.outputType;
     const outputTypeName = getOutputTypeName(String(type));
     const settings = isCountOutput ? void 0 : model && ((_a = fieldSettings.get(model.name)) == null ? void 0 : _a.get(field.name));
     const propertySettings = settings == null ? void 0 : settings.getPropertyType({
-      name: outputType2.name,
+      name: outputType1.name,
       output: true
     });
     const isCustomsApplicable = outputTypeName === ((_b = model == null ? void 0 : model.fields.find((f) => f.name === field.name)) == null ? void 0 : _b.type);
@@ -1172,11 +1351,11 @@ function outputType(outputType2, args) {
     }
     let graphqlType;
     const shouldHideField = settings == null ? void 0 : settings.shouldHideField({
-      name: outputType2.name,
+      name: outputType1.name,
       output: true
     });
     const fieldType = settings == null ? void 0 : settings.getFieldType({
-      name: outputType2.name,
+      name: outputType1.name,
       output: true
     });
     if (fieldType && isCustomsApplicable && !shouldHideField) {
@@ -1184,6 +1363,7 @@ function outputType(outputType2, args) {
       importDeclarations.create(__spreadValues({}, fieldType));
     } else {
       const graphqlImport = getGraphqlImport({
+        config,
         sourceFile,
         fileType,
         location,
@@ -1196,9 +1376,13 @@ function outputType(outputType2, args) {
       if (location === "enumTypes") {
         referenceName = (0, import_lodash6.last)(referenceName.split(" "));
       }
-      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputType2.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
+      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputType1.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
         importDeclarations.set(graphqlImport.name, {
-          namedImports: [{ name: graphqlImport.name }],
+          namedImports: [
+            {
+              name: graphqlImport.name
+            }
+          ],
           moduleSpecifier: graphqlImport.specifier
         });
       }
@@ -1206,7 +1390,10 @@ function outputType(outputType2, args) {
     (0, import_assert4.ok)(property.decorators, "property.decorators is undefined");
     if (shouldHideField) {
       importDeclarations.add("HideField", nestjsGraphql2);
-      property.decorators.push({ name: "HideField", arguments: [] });
+      property.decorators.push({
+        name: "HideField",
+        arguments: []
+      });
     } else {
       property.decorators.push({
         name: "Field",
@@ -1237,9 +1424,13 @@ function outputType(outputType2, args) {
     });
   }
   sourceFile.set({
-    statements: [...importDeclarations.toStatements(), classStructure]
+    statements: [
+      ...importDeclarations.toStatements(),
+      classStructure
+    ]
   });
 }
+__name(outputType, "outputType");
 
 // src/handlers/purge-output.ts
 var import_fs = require("fs");
@@ -1247,6 +1438,7 @@ function purgeOutput(emitter) {
   emitter.on("Begin", begin);
   emitter.on("End", end);
 }
+__name(purgeOutput, "purgeOutput");
 function begin({ project, output }) {
   var _a;
   const sourceFiles = (_a = project.getDirectory(output)) == null ? void 0 : _a.getDescendantSourceFiles();
@@ -1256,33 +1448,39 @@ function begin({ project, output }) {
     }
   }
 }
+__name(begin, "begin");
 async function end({ project, output }) {
   var _a;
   const directories = (_a = project.getDirectory(output)) == null ? void 0 : _a.getDescendantDirectories().filter((directory) => directory.getSourceFiles().length === 0).map((directory) => directory.getPath());
-  for (const directory of directories || []) {
+  for (const directory1 of directories || []) {
     try {
-      await import_fs.promises.rmdir(directory);
+      await import_fs.promises.rmdir(directory1);
     } catch (e) {
     }
   }
 }
+__name(end, "end");
 
 // src/handlers/re-export.ts
 var import_ts_morph7 = require("ts-morph");
-var ReExport = /* @__PURE__ */ ((ReExport2) => {
+var ReExport;
+(function(ReExport2) {
   ReExport2["None"] = "None";
   ReExport2["Directories"] = "Directories";
   ReExport2["Single"] = "Single";
   ReExport2["All"] = "All";
-  return ReExport2;
-})(ReExport || {});
+})(ReExport || (ReExport = {}));
 function reExport(emitter) {
   emitter.on("BeforeGenerateFiles", beforeGenerateFiles3);
 }
+__name(reExport, "reExport");
 function beforeGenerateFiles3(args) {
   const { project, output, config } = args;
   const rootDirectory = project.getDirectoryOrThrow(output);
-  if (["Directories" /* Directories */, "All" /* All */].includes(config.reExport)) {
+  if ([
+    ReExport.Directories,
+    ReExport.All
+  ].includes(config.reExport)) {
     for (const directory of rootDirectory.getDirectories()) {
       const exportDeclarations = directory.getSourceFiles().filter((sourceFile) => {
         return sourceFile.getBaseName() !== "index.ts";
@@ -1294,7 +1492,7 @@ function beforeGenerateFiles3(args) {
       });
     }
   }
-  if (config.reExport === "Single" /* Single */) {
+  if (config.reExport === ReExport.Single) {
     const exportDeclarations = project.getSourceFiles().filter((sourceFile) => {
       return sourceFile.getBaseName() !== "index.ts";
     }).map((sourceFile) => getExportDeclaration2(rootDirectory, sourceFile));
@@ -1304,7 +1502,7 @@ function beforeGenerateFiles3(args) {
       overwrite: true
     });
   }
-  if (config.reExport === "All" /* All */) {
+  if (config.reExport === ReExport.All) {
     const exportDeclarations = [];
     for (const directory of rootDirectory.getDirectories()) {
       const sourceFile = directory.getSourceFileOrThrow("index.ts");
@@ -1317,13 +1515,17 @@ function beforeGenerateFiles3(args) {
     });
   }
 }
+__name(beforeGenerateFiles3, "beforeGenerateFiles");
 function getExportDeclaration2(directory, sourceFile) {
   return {
     kind: import_ts_morph7.StructureKind.ExportDeclaration,
-    namedExports: sourceFile.getExportSymbols().map((s) => ({ name: s.getName() })),
+    namedExports: sourceFile.getExportSymbols().map((s) => ({
+      name: s.getName()
+    })),
     moduleSpecifier: directory.getRelativePathAsModuleSpecifierTo(sourceFile)
   };
 }
+__name(getExportDeclaration2, "getExportDeclaration");
 
 // src/handlers/register-enum.ts
 var import_ts_morph8 = require("ts-morph");
@@ -1336,7 +1538,11 @@ function registerEnum(enumType, args) {
   });
   const importDeclarations = new ImportDeclarationMap();
   importDeclarations.set("registerEnumType", {
-    namedImports: [{ name: "registerEnumType" }],
+    namedImports: [
+      {
+        name: "registerEnumType"
+      }
+    ],
     moduleSpecifier: "@nestjs/graphql"
   });
   const enumStructure = {
@@ -1357,11 +1563,13 @@ function registerEnum(enumType, args) {
     ]
   });
 }
+__name(registerEnum, "registerEnum");
 
 // src/handlers/require-single-fields-in-whereunique-input.ts
 function requireSingleFieldsInWhereUniqueInput(eventEmitter) {
   eventEmitter.on("BeforeInputType", beforeInputType3);
 }
+__name(requireSingleFieldsInWhereUniqueInput, "requireSingleFieldsInWhereUniqueInput");
 function beforeInputType3(args) {
   const { inputType: inputType2 } = args;
   if (!isWhereUniqueInputType(inputType2.name) || inputType2.fields.length !== 1) {
@@ -1372,9 +1580,11 @@ function beforeInputType3(args) {
     field.isNullable = false;
   }
 }
+__name(beforeInputType3, "beforeInputType");
 function isWhereUniqueInputType(name) {
   return name.endsWith("WhereUniqueInput");
 }
+__name(isWhereUniqueInputType, "isWhereUniqueInputType");
 
 // src/handlers/warning.ts
 function warning(message) {
@@ -1385,6 +1595,7 @@ function warning(message) {
     console.log("prisma-nestjs-graphql:", message);
   }
 }
+__name(warning, "warning");
 
 // src/helpers/create-config.ts
 var import_assert5 = require("assert");
@@ -1395,7 +1606,9 @@ var import_lodash7 = require("lodash");
 var import_outmatch3 = __toESM(require("outmatch"));
 function createConfig(data) {
   var _a;
-  const config = (0, import_lodash7.merge)({}, (0, import_flat.unflatten)(data, { delimiter: "_" }));
+  const config = (0, import_lodash7.merge)({}, (0, import_flat.unflatten)(data, {
+    delimiter: "_"
+  }));
   const $warnings = [];
   const configOutputFilePattern = String(config.outputFilePattern || `{model}/{name}.{type}.ts`);
   let outputFilePattern = (0, import_filenamify.default)(configOutputFilePattern, {
@@ -1421,7 +1634,10 @@ function createConfig(data) {
       defaultImport: toBoolean(value.defaultImport) ? true : value.defaultImport,
       namespaceImport: value.namespaceImport
     };
-    return [name, fieldSetting];
+    return [
+      name,
+      fieldSetting
+    ];
   }));
   const decorate = [];
   const configDecorate = Object.values(config.decorate || {});
@@ -1430,8 +1646,12 @@ function createConfig(data) {
       continue;
     (0, import_assert5.ok)(element.from && element.name, `Missed 'from' or 'name' part in configuration for decorate`);
     decorate.push({
-      isMatchField: (0, import_outmatch3.default)(element.field, { separator: false }),
-      isMatchType: (0, import_outmatch3.default)(element.type, { separator: false }),
+      isMatchField: (0, import_outmatch3.default)(element.field, {
+        separator: false
+      }),
+      isMatchType: (0, import_outmatch3.default)(element.type, {
+        separator: false
+      }),
       from: element.from,
       name: element.name,
       namedImport: toBoolean(element.namedImport),
@@ -1445,7 +1665,7 @@ function createConfig(data) {
     tsConfigFilePath: void 0,
     combineScalarFilters: toBoolean(config.combineScalarFilters),
     noAtomicOperations: toBoolean(config.noAtomicOperations),
-    reExport: ReExport[String(config.reExport)] || "None" /* None */,
+    reExport: ReExport[String(config.reExport)] || ReExport.None,
     emitSingle: toBoolean(config.emitSingle),
     emitCompiled: toBoolean(config.emitCompiled),
     $warnings,
@@ -1454,9 +1674,11 @@ function createConfig(data) {
     useInputType: createUseInputType(config.useInputType),
     noTypeId: toBoolean(config.noTypeId),
     requireSingleFieldsInWhereUniqueInput: toBoolean(config.requireSingleFieldsInWhereUniqueInput),
+    graphqlScalars: config.graphqlScalars || {},
     decorate
   };
 }
+__name(createConfig, "createConfig");
 function createUseInputType(data) {
   if (!data) {
     return [];
@@ -1478,9 +1700,15 @@ function createUseInputType(data) {
   }
   return result;
 }
+__name(createUseInputType, "createUseInputType");
 function toBoolean(value) {
-  return ["true", "1", "on"].includes(String(value));
+  return [
+    "true",
+    "1",
+    "on"
+  ].includes(String(value));
 }
+__name(toBoolean, "toBoolean");
 
 // src/helpers/generate-file-name.ts
 var import_lodash8 = require("lodash");
@@ -1496,7 +1724,11 @@ function generateFileName(args) {
     },
     get name() {
       let result = (0, import_lodash8.kebabCase)(name);
-      for (const suffix of ["input", "args", "enum"]) {
+      for (const suffix of [
+        "input",
+        "args",
+        "enum"
+      ]) {
         const ending = `-${suffix}`;
         if (type === suffix && result.endsWith(ending)) {
           result = result.slice(0, -ending.length);
@@ -1511,12 +1743,13 @@ function generateFileName(args) {
     }
   });
 }
+__name(generateFileName, "generateFileName");
 
 // src/helpers/factory-get-source-file.ts
-function factoryGetSourceFile(args) {
-  const { outputFilePattern, output, getModelName: getModelName2, project } = args;
-  return function getSourceFile(args2) {
-    const { name, type } = args2;
+function factoryGetSourceFile(args1) {
+  const { outputFilePattern, output, getModelName: getModelName2, project } = args1;
+  return /* @__PURE__ */ __name(function getSourceFile(args) {
+    const { name, type } = args;
     let filePath = generateFileName({
       getModelName: getModelName2,
       name,
@@ -1525,17 +1758,23 @@ function factoryGetSourceFile(args) {
     });
     filePath = `${output}/${filePath}`;
     return project.getSourceFile(filePath) || project.createSourceFile(filePath);
-  };
+  }, "getSourceFile");
 }
+__name(factoryGetSourceFile, "factoryGetSourceFile");
 
 // src/helpers/get-model-name.ts
 var import_lodash9 = require("lodash");
 function createGetModelName(modelNames) {
   return (0, import_lodash9.memoize)(tryGetName);
   function tryGetName(name) {
-    return getModelName({ modelNames, name });
+    return getModelName({
+      modelNames,
+      name
+    });
   }
+  __name(tryGetName, "tryGetName");
 }
+__name(createGetModelName, "createGetModelName");
 function getModelName(args) {
   const { name, modelNames } = args;
   for (const keyword of splitKeywords) {
@@ -1544,8 +1783,8 @@ function getModelName(args) {
       return test;
     }
   }
-  for (const keyword of endsWithKeywords) {
-    const [test] = name.split(keyword).slice(-1);
+  for (const keyword1 of endsWithKeywords) {
+    const [test] = name.split(keyword1).slice(-1);
     if (modelNames.includes(test)) {
       return test;
     }
@@ -1573,6 +1812,7 @@ function getModelName(args) {
   }
   return void 0;
 }
+__name(getModelName, "getModelName");
 var splitKeywords = [
   "CreateInput",
   "CreateMany",
@@ -1628,19 +1868,58 @@ var endsWithKeywords = [
   "UpsertOne"
 ];
 var middleKeywords = [
-  ["Aggregate", "Args"],
-  ["CreateOne", "Args"],
-  ["DeleteMany", "Args"],
-  ["DeleteOne", "Args"],
-  ["FindMany", "Args"],
-  ["FindFirst", "Args"],
-  ["FindOne", "Args"],
-  ["FindUnique", "Args"],
-  ["UpdateMany", "Args"],
-  ["UpdateOne", "Args"],
-  ["UpsertOne", "Args"],
-  ["GroupBy", "Args"],
-  ["OrderBy", "Args"]
+  [
+    "Aggregate",
+    "Args"
+  ],
+  [
+    "CreateOne",
+    "Args"
+  ],
+  [
+    "DeleteMany",
+    "Args"
+  ],
+  [
+    "DeleteOne",
+    "Args"
+  ],
+  [
+    "FindMany",
+    "Args"
+  ],
+  [
+    "FindFirst",
+    "Args"
+  ],
+  [
+    "FindOne",
+    "Args"
+  ],
+  [
+    "FindUnique",
+    "Args"
+  ],
+  [
+    "UpdateMany",
+    "Args"
+  ],
+  [
+    "UpdateOne",
+    "Args"
+  ],
+  [
+    "UpsertOne",
+    "Args"
+  ],
+  [
+    "GroupBy",
+    "Args"
+  ],
+  [
+    "OrderBy",
+    "Args"
+  ]
 ];
 
 // src/generate.ts
@@ -1680,7 +1959,7 @@ async function generate(args) {
   }
   config.combineScalarFilters && combineScalarFilters(eventEmitter);
   config.noAtomicOperations && noAtomicOperations(eventEmitter);
-  config.reExport !== "None" /* None */ && reExport(eventEmitter);
+  config.reExport !== ReExport.None && reExport(eventEmitter);
   config.emitSingle && emitSingle(eventEmitter);
   config.purgeOutput && purgeOutput(eventEmitter);
   config.requireSingleFieldsInWhereUniqueInput && requireSingleFieldsInWhereUniqueInput(eventEmitter);
@@ -1696,10 +1975,7 @@ async function generate(args) {
     outputFilePattern: config.outputFilePattern,
     eventEmitter
   });
-  const {
-    datamodel,
-    schema: { inputObjectTypes, outputObjectTypes, enumTypes }
-  } = JSON.parse(JSON.stringify(dmmf));
+  const { datamodel, schema: { inputObjectTypes, outputObjectTypes, enumTypes } } = JSON.parse(JSON.stringify(dmmf));
   const removeTypes = /* @__PURE__ */ new Set();
   const eventArguments = {
     models,
@@ -1727,26 +2003,29 @@ async function generate(args) {
   for (const enumType of enumTypes.prisma.concat(enumTypes.model || [])) {
     await eventEmitter.emit("EnumType", enumType, eventArguments);
   }
-  for (const outputType2 of outputObjectTypes.model) {
-    await eventEmitter.emit("ModelOutputType", outputType2, eventArguments);
+  for (const outputType3 of outputObjectTypes.model) {
+    await eventEmitter.emit("ModelOutputType", outputType3, eventArguments);
   }
   const queryOutputTypes = [];
-  for (const outputType2 of outputObjectTypes.prisma) {
-    if (["Query", "Mutation"].includes(outputType2.name)) {
-      queryOutputTypes.push(outputType2);
+  for (const outputType1 of outputObjectTypes.prisma) {
+    if ([
+      "Query",
+      "Mutation"
+    ].includes(outputType1.name)) {
+      queryOutputTypes.push(outputType1);
       continue;
     }
-    await eventEmitter.emit("OutputType", outputType2, eventArguments);
+    await eventEmitter.emit("OutputType", outputType1, eventArguments);
   }
   const inputTypes = inputObjectTypes.prisma.concat(inputObjectTypes.model || []);
-  for (const inputType2 of inputTypes) {
+  for (const inputType1 of inputTypes) {
     const event = __spreadProps(__spreadValues({}, eventArguments), {
-      inputType: inputType2,
+      inputType: inputType1,
       fileType: "input",
       classDecoratorName: "InputType"
     });
-    if (inputType2.fields.length === 0) {
-      removeTypes.add(inputType2.name);
+    if (inputType1.fields.length === 0) {
+      removeTypes.add(inputType1.name);
       continue;
     }
     await eventEmitter.emit("BeforeInputType", event);
@@ -1764,6 +2043,7 @@ async function generate(args) {
     eventEmitter.off(name);
   }
 }
+__name(generate, "generate");
 
 // src/index.ts
 (0, import_generator_helper.generatorHandler)({