prisma-nestjs-graphql 18.0.2 → 18.1.0

package/{index.js → generate.cjs}

@@ -1,55 +1,41 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
+'use strict';
 
-// src/index.ts
-var import_generator_helper = require("@prisma/generator-helper");
+Object.defineProperty(exports, '__esModule', { value: true });
 
-// src/generate.ts
-var import_assert6 = require("assert");
-var import_await_event_emitter = __toESM(require("await-event-emitter"));
-var import_lodash11 = require("lodash");
-var import_ts_morph9 = require("ts-morph");
+var assert = require('assert');
+var AwaitEventEmitter = require('await-event-emitter');
+var lodash = require('lodash');
+var tsMorph = require('ts-morph');
+var JSON5 = require('json5');
+var pupa = require('pupa');
+var getRelativePath = require('get-relative-path');
+var outmatch = require('outmatch');
+var gracefulFs = require('graceful-fs');
+var filenamify = require('filenamify');
+var flat = require('flat');
+var pluralize = require('pluralize');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var AwaitEventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(AwaitEventEmitter);
+var JSON5__default = /*#__PURE__*/_interopDefaultLegacy(JSON5);
+var pupa__default = /*#__PURE__*/_interopDefaultLegacy(pupa);
+var getRelativePath__default = /*#__PURE__*/_interopDefaultLegacy(getRelativePath);
+var outmatch__default = /*#__PURE__*/_interopDefaultLegacy(outmatch);
+var filenamify__default = /*#__PURE__*/_interopDefaultLegacy(filenamify);
+var pluralize__default = /*#__PURE__*/_interopDefaultLegacy(pluralize);
 
-// src/helpers/pascal-case.ts
-var import_lodash = require("lodash");
 function pascalCase(string) {
-  return (0, import_lodash.startCase)((0, import_lodash.camelCase)(string)).replace(/ /g, "");
+  return lodash.startCase(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;
+  const { eventEmitter, typeNames, getModelName } = args;
   let className = pascalCase(`${field.name}Args`);
-  const modelName = getModelName2(className) || "";
+  const modelName = getModelName(className) || "";
   switch (className) {
     case `Aggregate${modelName}Args`: {
       className = `${modelName}AggregateArgs`;
@@ -60,39 +46,25 @@ function argsType(field, args) {
       break;
     }
   }
-  const inputType2 = {
+  const inputType = {
     // eslint-disable-next-line unicorn/no-null
-    constraints: {
-      maxNumFields: null,
-      minNumFields: null
-    },
+    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 (byField?.inputTypes) {
-        byField.inputTypes = byField.inputTypes.filter((inputType3) => inputType3.isList);
+  if (!field.args.some((x) => x.name === "_count") && [`${modelName}AggregateArgs`, `${modelName}GroupByArgs`].includes(className)) {
+    const names = ["Count", "Avg", "Sum", "Min", "Max"];
+    if (`${modelName}GroupByArgs` === inputType.name) {
+      const byField = inputType.fields.find((f) => f.name === "by");
+      if (byField == null ? void 0 : byField.inputTypes) {
+        byField.inputTypes = byField.inputTypes.filter((inputType2) => inputType2.isList);
       }
     }
     for (const name of names) {
       if (!typeNames.has(`${modelName}${name}AggregateInput`)) {
         continue;
       }
-      inputType2.fields.push({
+      inputType.fields.push({
         name: `_${name.toLowerCase()}`,
         isRequired: false,
         isNullable: true,
@@ -108,29 +80,24 @@ function argsType(field, args) {
   }
   eventEmitter.emitSync("InputType", {
     ...args,
-    inputType: inputType2,
+    inputType,
     fileType: "args",
     classDecoratorName: "ArgsType"
   });
 }
-__name(argsType, "argsType");
 
-// src/handlers/combine-scalar-filters.ts
-var import_lodash2 = require("lodash");
 function combineScalarFilters(eventEmitter) {
-  eventEmitter.on("BeforeInputType", beforeInputType);
+  eventEmitter.on("BeforeInputType", beforeInputType$2);
   eventEmitter.on("BeforeGenerateField", beforeGenerateField);
   eventEmitter.on("PostBegin", postBegin);
 }
-__name(combineScalarFilters, "combineScalarFilters");
-function beforeInputType(args) {
-  const { inputType: inputType2, removeTypes } = args;
-  if (isContainBogus(inputType2.name) && isScalarFilter(inputType2)) {
-    removeTypes.add(inputType2.name);
-    inputType2.name = replaceBogus(inputType2.name);
+function beforeInputType$2(args) {
+  const { inputType, removeTypes } = args;
+  if (isContainBogus(inputType.name) && isScalarFilter(inputType)) {
+    removeTypes.add(inputType.name);
+    inputType.name = replaceBogus(inputType.name);
   }
 }
-__name(beforeInputType, "beforeInputType");
 function beforeGenerateField(field) {
   for (const fieldInput of field.inputTypes) {
     if (fieldInput.location !== "inputObjectTypes") {
@@ -142,32 +109,25 @@ 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")) {
+function isScalarFilter(inputType) {
+  if (!inputType.name.endsWith("Filter")) {
     return false;
   }
   let result = false;
-  const equals = inputType2.fields.find((f) => f.name === "equals");
+  const equals = inputType.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");
 function postBegin(args) {
   const { schema } = args;
   const inputTypes = schema.inputObjectTypes.prisma;
@@ -187,21 +147,18 @@ function postBegin(args) {
     const { name } = enumType;
     types.push(`Enum${name}`);
   }
-  const inputTypeByName = (0, import_lodash2.keyBy)(inputTypes, (inputType2) => inputType2.name);
-  const replaceBogusFilters = /* @__PURE__ */ __name((filterName, filterNameCandidates) => {
+  const inputTypeByName = lodash.keyBy(inputTypes, (inputType) => inputType.name);
+  const replaceBogusFilters = (filterName, filterNameCandidates) => {
     for (const filterNameCandidate of filterNameCandidates) {
       const candidate = inputTypeByName[filterNameCandidate];
       if (candidate) {
-        const inputType2 = (0, import_lodash2.cloneDeep)({
-          ...candidate,
-          name: filterName
-        });
-        inputTypes.push(inputType2);
-        inputTypeByName[filterName] = inputType2;
+        const inputType = lodash.cloneDeep({ ...candidate, name: filterName });
+        inputTypes.push(inputType);
+        inputTypeByName[filterName] = inputType;
         break;
       }
     }
-  }, "replaceBogusFilters");
+  };
   for (const type of types) {
     replaceBogusFilters(`${type}Filter`, [
       `${type}NullableFilter`,
@@ -216,54 +173,46 @@ function postBegin(args) {
       `Nested${type}NullableListFilter`
     ]);
   }
-  (0, import_lodash2.remove)(inputTypes, (inputType2) => isContainBogus(inputType2.name));
+  lodash.remove(inputTypes, (inputType) => isContainBogus(inputType.name));
 }
-__name(postBegin, "postBegin");
 
-// src/handlers/create-aggregate-input.ts
 function createAggregateInput(args) {
-  const { eventEmitter, outputType: outputType2 } = args;
-  const className = `${outputType2.name}Input`;
-  const inputType2 = {
+  const { eventEmitter, outputType } = args;
+  const className = `${outputType.name}Input`;
+  const inputType = {
     // eslint-disable-next-line unicorn/no-null
-    constraints: {
-      maxNumFields: null,
-      minNumFields: null
-    },
+    constraints: { maxNumFields: null, minNumFields: null },
     name: className,
-    fields: outputType2.fields.map((x) => ({
-      name: x.name,
-      isNullable: x.isNullable ?? true,
-      isRequired: false,
-      inputTypes: [
-        {
-          isList: false,
-          type: "true",
-          location: "scalar"
-        }
-      ]
-    }))
+    fields: outputType.fields.map((x) => {
+      var _a;
+      return {
+        name: x.name,
+        isNullable: (_a = x.isNullable) != null ? _a : true,
+        isRequired: false,
+        inputTypes: [
+          {
+            isList: false,
+            type: "true",
+            location: "scalar"
+          }
+        ]
+      };
+    })
   };
   eventEmitter.emitSync("InputType", {
     ...args,
-    inputType: inputType2,
+    inputType,
     fileType: "input",
     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) {
@@ -271,25 +220,11 @@ function classProperty(property, eventArguments) {
     }
   }
 }
-__name(classProperty, "classProperty");
-
-// src/handlers/generate-files.ts
-var import_assert = require("assert");
-var import_ts_morph2 = require("ts-morph");
 
-// src/helpers/import-declaration-map.ts
-var import_ts_morph = require("ts-morph");
-var ImportDeclarationMap = class extends Map {
+class ImportDeclarationMap 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);
     }
   }
@@ -303,11 +238,7 @@ 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;
@@ -316,11 +247,7 @@ var ImportDeclarationMap = class extends Map {
       value.namespaceImport = namespaceImport;
       name = namespaceImport;
     } else {
-      value.namedImports = [
-        {
-          name
-        }
-      ];
+      value.namedImports = [{ name }];
     }
     this.add(name, value);
   }
@@ -330,23 +257,20 @@ var ImportDeclarationMap = class extends Map {
     while (result.value) {
       yield {
         ...result.value,
-        kind: import_ts_morph.StructureKind.ImportDeclaration
+        kind: tsMorph.StructureKind.ImportDeclaration
       };
       result = iterator.next();
     }
   }
-};
-__name(ImportDeclarationMap, "ImportDeclarationMap");
+}
 
-// src/handlers/generate-files.ts
 async function generateFiles(args) {
   const { project, config, output, eventEmitter } = args;
   if (config.emitSingle) {
     const rootDirectory = project.getDirectory(output) || project.createDirectory(output);
-    const sourceFile = rootDirectory.getSourceFile("index.ts") || rootDirectory.createSourceFile("index.ts", void 0, {
-      overwrite: true
-    });
+    const sourceFile = rootDirectory.getSourceFile("index.ts") || rootDirectory.createSourceFile("index.ts", void 0, { overwrite: true });
     const statements = project.getSourceFiles().flatMap((s) => {
+      var _a, _b;
       if (s === sourceFile) {
         return [];
       }
@@ -354,13 +278,16 @@ async function generateFiles(args) {
       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)) {
+          if (!(typeof statement === "object" && statement.kind === tsMorph.StructureKind.Class)) {
             continue;
           }
           for (const property of statement.properties || []) {
             for (const decorator of property.decorators || []) {
-              const fullName = classDeclaration?.getProperty(property.name)?.getDecorator(decorator.name)?.getFullName();
-              (0, import_assert.ok)(fullName, `Cannot get full name of decorator of class ${statement.name}`);
+              const fullName = (_b = (_a = classDeclaration == null ? void 0 : classDeclaration.getProperty(property.name)) == null ? void 0 : _a.getDecorator(decorator.name)) == null ? void 0 : _b.getFullName();
+              assert.ok(
+                fullName,
+                `Cannot get full name of decorator of class ${statement.name}`
+              );
               decorator.name = fullName;
             }
           }
@@ -380,7 +307,7 @@ async function generateFiles(args) {
         continue;
       }
       switch (statement.kind) {
-        case import_ts_morph2.StructureKind.ImportDeclaration: {
+        case tsMorph.StructureKind.ImportDeclaration: {
           if (statement.moduleSpecifier.startsWith("./") || statement.moduleSpecifier.startsWith("..")) {
             continue;
           }
@@ -404,23 +331,19 @@ async function generateFiles(args) {
           }
           break;
         }
-        case import_ts_morph2.StructureKind.Enum: {
+        case tsMorph.StructureKind.Enum: {
           enums.unshift(statement);
           break;
         }
-        case import_ts_morph2.StructureKind.Class: {
+        case tsMorph.StructureKind.Class: {
           classes.push(statement);
           break;
         }
       }
     }
     sourceFile.set({
-      kind: import_ts_morph2.StructureKind.SourceFile,
-      statements: [
-        ...imports.toStatements(),
-        ...enums,
-        ...classes
-      ]
+      kind: tsMorph.StructureKind.SourceFile,
+      statements: [...imports.toStatements(), ...enums, ...classes]
     });
   }
   if (config.emitCompiled) {
@@ -441,16 +364,7 @@ async function generateFiles(args) {
     await project.save();
   }
 }
-__name(generateFiles, "generateFiles");
 
-// src/handlers/input-type.ts
-var import_assert2 = require("assert");
-var import_json5 = __toESM(require("json5"));
-var import_lodash4 = require("lodash");
-var import_pupa = __toESM(require("pupa"));
-var import_ts_morph4 = require("ts-morph");
-
-// src/helpers/file-type-by-location.ts
 function fileTypeByLocation(fieldLocation) {
   switch (fieldLocation) {
     case "inputObjectTypes": {
@@ -465,10 +379,7 @@ function fileTypeByLocation(fieldLocation) {
   }
   return "object";
 }
-__name(fileTypeByLocation, "fileTypeByLocation");
 
-// src/helpers/relative-path.ts
-var import_get_relative_path = __toESM(require("get-relative-path"));
 function relativePath(from, to) {
   if (!from.startsWith("/")) {
     from = `/${from}`;
@@ -476,7 +387,7 @@ function relativePath(from, to) {
   if (!to.startsWith("/")) {
     to = `/${to}`;
   }
-  let result = (0, import_get_relative_path.default)(from, to);
+  let result = getRelativePath__default["default"](from, to);
   if (!result.startsWith(".")) {
     result = `./${result}`;
   }
@@ -485,45 +396,37 @@ function relativePath(from, to) {
   }
   return result;
 }
-__name(relativePath, "relativePath");
 
-// src/helpers/get-graphql-import.ts
 function getGraphqlImport(args) {
-  const { config, 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
-      };
+      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 {
@@ -532,46 +435,33 @@ function getGraphqlImport(args) {
         };
       }
       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") {
     sourceFileType = "model";
   }
-  const specifier = relativePath(sourceFile.getFilePath(), getSourceFile({
-    type: sourceFileType,
-    name: typeName
-  }).getFilePath());
-  return {
-    name: typeName,
-    specifier
-  };
+  const specifier = relativePath(
+    sourceFile.getFilePath(),
+    getSourceFile({
+      type: sourceFileType,
+      name: typeName
+    }).getFilePath()
+  );
+  return { name: typeName, specifier };
 }
-__name(getGraphqlImport, "getGraphqlImport");
 
-// src/helpers/get-graphql-input-type.ts
-var import_lodash3 = 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 = (0, import_lodash3.uniqWith)(inputTypes, import_lodash3.isEqual);
+  inputTypes = inputTypes.filter((t) => !["null", "Null"].includes(String(t.type)));
+  inputTypes = lodash.uniqWith(inputTypes, lodash.isEqual);
   if (inputTypes.length === 1) {
     return inputTypes[0];
   }
-  const countTypes = (0, import_lodash3.countBy)(inputTypes, (x) => x.location);
+  const countTypes = lodash.countBy(inputTypes, (x) => x.location);
   const isOneType = Object.keys(countTypes).length === 1;
   if (isOneType) {
     result = inputTypes.find((x) => x.isList);
@@ -582,9 +472,7 @@ 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 = outmatch__default["default"](patternValue, { separator: false });
       result = inputTypes.find((x) => isMatch(String(x.type)));
       if (result) {
         return result;
@@ -606,11 +494,15 @@ function getGraphqlInputType(inputTypes, pattern) {
     }
   }
   if ((countTypes.scalar >= 1 || countTypes.enumTypes >= 1) && countTypes.fieldRefTypes === 1) {
-    result = inputTypes.find((x) => (x.location === "scalar" || x.location === "enumTypes") && x.isList);
+    result = inputTypes.find(
+      (x) => (x.location === "scalar" || x.location === "enumTypes") && x.isList
+    );
     if (result) {
       return result;
     }
-    result = inputTypes.find((x) => x.location === "scalar" || x.location === "enumTypes");
+    result = inputTypes.find(
+      (x) => x.location === "scalar" || x.location === "enumTypes"
+    );
     if (result) {
       return result;
     }
@@ -620,105 +512,88 @@ function getGraphqlInputType(inputTypes, pattern) {
     `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) {
   const { type, location } = 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": {
-      return [
-        "Decimal"
-      ];
+      return ["Decimal"];
     }
     case "Json": {
-      return [
-        "any"
-      ];
+      return ["any"];
     }
     case "Null": {
-      return [
-        "null"
-      ];
+      return ["null"];
     }
     case "Bytes": {
-      return [
-        "Buffer"
-      ];
+      return ["Buffer"];
     }
     case "BigInt": {
-      return [
-        "bigint",
-        "number"
-      ];
+      return ["bigint", "number"];
     }
   }
-  if ([
-    "inputObjectTypes",
-    "outputObjectTypes"
-  ].includes(location)) {
-    return [
-      type
-    ];
+  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 {
+    isNullable,
+    propertyType,
+    name,
+    isList,
+    hasQuestionToken,
+    hasExclamationToken
+  } = args;
   const type = propertyType.map((type2) => isList ? `Array<${type2}>` : type2).join(" | ");
   return {
-    kind: import_ts_morph3.StructureKind.Property,
+    kind: tsMorph.StructureKind.Property,
     name,
     type,
-    hasQuestionToken: hasQuestionToken ?? isNullable,
-    hasExclamationToken: hasExclamationToken ?? !isNullable,
+    hasQuestionToken: hasQuestionToken != null ? hasQuestionToken : isNullable,
+    hasExclamationToken: hasExclamationToken != null ? hasExclamationToken : !isNullable,
     decorators: [],
     leadingTrivia: "\n"
   };
 }
-__name(propertyStructure, "propertyStructure");
 
-// src/handlers/input-type.ts
 function inputType(args) {
-  const { classDecoratorName, classTransformerTypeModels, config, eventEmitter, fieldSettings, fileType, getModelName: getModelName2, getSourceFile, inputType: inputType2, models, removeTypes, typeNames } = args;
+  var _a, _b, _c, _d;
+  const {
+    classDecoratorName,
+    classTransformerTypeModels,
+    config,
+    eventEmitter,
+    fieldSettings,
+    fileType,
+    getModelName,
+    getSourceFile,
+    inputType: inputType2,
+    models,
+    removeTypes,
+    typeNames
+  } = args;
   typeNames.add(inputType2.name);
   const importDeclarations = new ImportDeclarationMap();
   const sourceFile = getSourceFile({
@@ -726,7 +601,7 @@ function inputType(args) {
     type: fileType
   });
   const classStructure = {
-    kind: import_ts_morph4.StructureKind.Class,
+    kind: tsMorph.StructureKind.Class,
     isExported: true,
     name: inputType2.name,
     decorators: [
@@ -737,26 +612,20 @@ function inputType(args) {
     ],
     properties: []
   };
-  const modelName = getModelName2(inputType2.name) || "";
+  const modelName = getModelName(inputType2.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));
+  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);
@@ -764,21 +633,23 @@ function inputType(args) {
     if (inputTypes.length === 0) {
       continue;
     }
-    const usePattern = useInputType?.ALL || useInputType?.[name];
+    const usePattern = (useInputType == null ? void 0 : useInputType.ALL) || (useInputType == null ? void 0 : useInputType[name]);
     const graphqlInputType = getGraphqlInputType(inputTypes, usePattern);
     const { isList, location, type } = graphqlInputType;
     const typeName = String(type);
-    const settings = modelFieldSettings?.get(name);
-    const propertySettings = settings?.getPropertyType({
+    const settings = modelFieldSettings == null ? void 0 : modelFieldSettings.get(name);
+    const propertySettings = settings == null ? void 0 : settings.getPropertyType({
       name: inputType2.name,
       input: true
     });
-    const modelField = model?.fields.find((f) => f.name === name);
-    const isCustomsApplicable = typeName === modelField?.type;
-    const propertyType = (0, import_lodash4.castArray)(propertySettings?.name || getPropertyType({
-      location,
-      type: typeName
-    }));
+    const modelField = model == null ? void 0 : model.fields.find((f) => f.name === name);
+    const isCustomsApplicable = typeName === (modelField == null ? void 0 : modelField.type);
+    const propertyType = lodash.castArray(
+      (propertySettings == null ? void 0 : propertySettings.name) || getPropertyType({
+        location,
+        type: typeName
+      })
+    );
     const property = propertyStructure({
       name,
       isNullable: !isRequired,
@@ -787,26 +658,24 @@ function inputType(args) {
     });
     classStructure.properties.push(property);
     if (propertySettings) {
-      importDeclarations.create({
-        ...propertySettings
-      });
+      importDeclarations.create({ ...propertySettings });
     } else if (propertyType.includes("Decimal")) {
       importDeclarations.add("Decimal", "@prisma/client/runtime/library");
     }
     let graphqlType;
-    const shouldHideField = settings?.shouldHideField({
+    const shouldHideField = (settings == null ? void 0 : settings.shouldHideField({
       name: inputType2.name,
       input: true
-    }) || config.decorate.some((d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(name) && d.isMatchType(inputType2.name));
-    const fieldType = settings?.getFieldType({
+    })) || config.decorate.some(
+      (d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(name) && d.isMatchType(inputType2.name)
+    );
+    const fieldType = settings == null ? void 0 : settings.getFieldType({
       name: inputType2.name,
       input: true
     });
     if (fieldType && isCustomsApplicable && !shouldHideField) {
       graphqlType = fieldType.name;
-      importDeclarations.create({
-        ...fieldType
-      });
+      importDeclarations.create({ ...fieldType });
     } else {
       const graphqlImport = getGraphqlImport({
         config,
@@ -818,33 +687,26 @@ function inputType(args) {
       graphqlType = graphqlImport.name;
       let referenceName = propertyType[0];
       if (location === "enumTypes") {
-        referenceName = (0, import_lodash4.last)(referenceName.split(" "));
+        referenceName = lodash.last(referenceName.split(" "));
       }
       if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && graphqlImport.name !== inputType2.name) {
         importDeclarations.set(graphqlImport.name, {
-          namedImports: [
-            {
-              name: graphqlImport.name
-            }
-          ],
+          namedImports: [{ name: graphqlImport.name }],
           moduleSpecifier: graphqlImport.specifier
         });
       }
     }
-    (0, import_assert2.ok)(property.decorators, "property.decorators is undefined");
+    assert.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",
         arguments: [
           isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`,
-          import_json5.default.stringify({
-            ...settings?.fieldArguments(),
+          JSON5__default["default"].stringify({
+            ...settings == null ? void 0 : settings.fieldArguments(),
             nullable: !isRequired
           })
         ]
@@ -853,18 +715,17 @@ function inputType(args) {
         importDeclarations.add("transformToDecimal", "prisma-graphql-type-decimal");
         importDeclarations.add("Transform", "class-transformer");
         importDeclarations.add("Type", "class-transformer");
-        property.decorators.push({
-          name: "Type",
-          arguments: [
-            "() => Object"
-          ]
-        }, {
-          name: "Transform",
-          arguments: [
-            "transformToDecimal"
-          ]
-        });
-      } else if (location === "inputObjectTypes" && (modelField?.type === "Decimal" || [
+        property.decorators.push(
+          {
+            name: "Type",
+            arguments: ["() => Object"]
+          },
+          {
+            name: "Transform",
+            arguments: ["transformToDecimal"]
+          }
+        );
+      } else if (location === "inputObjectTypes" && ((modelField == null ? void 0 : modelField.type) === "Decimal" || [
         "connect",
         "connectOrCreate",
         "create",
@@ -878,23 +739,20 @@ function inputType(args) {
         "updateMany",
         "upsert",
         "where"
-      ].includes(name) || classTransformerTypeModels.has(getModelName2(graphqlType) || "") || modelField?.kind === "object" && models.get(modelField.type) && models.get(modelField.type)?.fields.some((field2) => field2.kind === "object" && classTransformerTypeModels.has(field2.type)))) {
+      ].includes(name) || classTransformerTypeModels.has(getModelName(graphqlType) || "") || (modelField == null ? void 0 : modelField.kind) === "object" && models.get(modelField.type) && ((_a = models.get(modelField.type)) == null ? void 0 : _a.fields.some(
+        (field2) => field2.kind === "object" && classTransformerTypeModels.has(field2.type)
+      )))) {
         importDeclarations.add("Type", "class-transformer");
-        property.decorators.push({
-          name: "Type",
-          arguments: [
-            `() => ${graphqlType}`
-          ]
-        });
+        property.decorators.push({ name: "Type", arguments: [`() => ${graphqlType}`] });
       }
       if (isCustomsApplicable) {
         for (const options of settings || []) {
-          if ((options.kind === "Decorator" && options.input && options.match?.(name)) ?? true) {
+          if ((_c = options.kind === "Decorator" && options.input && ((_b = options.match) == null ? void 0 : _b.call(options, name))) != null ? _c : true) {
             property.decorators.push({
               name: options.name,
               arguments: options.arguments
             });
-            (0, import_assert2.ok)(options.from, "Missed 'from' part in configuration or field setting");
+            assert.ok(options.from, "Missed 'from' part in configuration or field setting");
             importDeclarations.create(options);
           }
         }
@@ -903,9 +761,7 @@ function inputType(args) {
         if (decorate.isMatchField(name) && decorate.isMatchType(inputType2.name)) {
           property.decorators.push({
             name: decorate.name,
-            arguments: decorate.arguments?.map((x) => (0, import_pupa.default)(x, {
-              propertyType
-            }))
+            arguments: (_d = decorate.arguments) == null ? void 0 : _d.map((x) => pupa__default["default"](x, { propertyType }))
           });
           importDeclarations.create(decorate);
         }
@@ -918,24 +774,27 @@ 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_lodash5 = require("lodash");
-var import_outmatch2 = __toESM(require("outmatch"));
-var ObjectSettings = class extends Array {
-  shouldHideField({ name, input = false, output = false }) {
+class ObjectSettings extends Array {
+  shouldHideField({
+    name,
+    input = false,
+    output = false
+  }) {
+    var _a;
     const hideField = this.find((s) => s.name === "HideField");
-    return Boolean(hideField?.input && input || hideField?.output && output || hideField?.match?.(name));
+    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;
@@ -951,7 +810,11 @@ var ObjectSettings = class extends Array {
     }
     return fieldType;
   }
-  getPropertyType({ name, input, output }) {
+  getPropertyType({
+    name,
+    input,
+    output
+  }) {
     const propertyType = this.find((s) => s.kind === "PropertyType");
     if (!propertyType) {
       return void 0;
@@ -968,19 +831,17 @@ var ObjectSettings = class extends Array {
     return propertyType;
   }
   getObjectTypeArguments(options) {
-    const objectTypeOptions = (0, import_lodash5.merge)({}, options);
-    const resultArguments = [
-      objectTypeOptions
-    ];
+    const objectTypeOptions = lodash.merge({}, options);
+    const resultArguments = [objectTypeOptions];
     const objectType = this.find((s) => s.kind === "ObjectType");
-    if (objectType && (0, import_lodash5.isObject)(objectType.arguments)) {
+    if (objectType && lodash.isObject(objectType.arguments)) {
       const name = objectType.arguments.name;
-      (0, import_lodash5.merge)(objectTypeOptions, (0, import_lodash5.omit)(objectType.arguments, "name"));
+      lodash.merge(objectTypeOptions, lodash.omit(objectType.arguments, "name"));
       if (name) {
         resultArguments.unshift(name);
       }
     }
-    return resultArguments.map((x) => import_json52.default.stringify(x));
+    return resultArguments.map((x) => JSON5__default["default"].stringify(x));
   }
   fieldArguments() {
     const item = this.find((item2) => item2.kind === "Field");
@@ -988,8 +849,7 @@ var ObjectSettings = class extends Array {
       return item.arguments;
     }
   }
-};
-__name(ObjectSettings, "ObjectSettings");
+}
 function createObjectSettings(args) {
   const { config, text } = args;
   const result = new ObjectSettings();
@@ -1023,18 +883,23 @@ function createObjectSettings(args) {
     documentation: documentationLines.filter(Boolean).join("\n") || void 0
   };
 }
-__name(createObjectSettings, "createObjectSettings");
-function createSettingElement({ line, config, fieldElement, match }) {
+function createSettingElement({
+  line,
+  config,
+  fieldElement,
+  match
+}) {
+  var _a, _b, _c, _d, _e;
   const result = {
     documentLine: "",
     element: void 0
   };
   if (line.startsWith("@deprecated")) {
-    fieldElement.arguments["deprecationReason"] = (0, import_lodash5.trim)(line.slice(11));
+    fieldElement.arguments["deprecationReason"] = lodash.trim(line.slice(11));
     result.element = fieldElement;
     return result;
   }
-  const name = match?.groups?.name;
+  const name = (_a = match == null ? void 0 : match.groups) == null ? void 0 : _a.name;
   if (!(match && name)) {
     result.documentLine = line;
     return result;
@@ -1053,24 +918,21 @@ function createSettingElement({ line, config, fieldElement, match }) {
     Object.assign(element, hideFieldDecorator(match));
     return result;
   }
-  if ([
-    "FieldType",
-    "PropertyType"
-  ].includes(name) && match.groups?.args) {
+  if (["FieldType", "PropertyType"].includes(name) && ((_b = match.groups) == null ? void 0 : _b.args)) {
     const options2 = customType(match.groups.args);
-    (0, import_lodash5.merge)(element, options2.namespace && config.fields[options2.namespace], options2, {
+    lodash.merge(element, options2.namespace && config.fields[options2.namespace], options2, {
       kind: name
     });
     return result;
   }
-  if (name === "ObjectType" && match.groups?.args) {
+  if (name === "ObjectType" && ((_c = match.groups) == null ? void 0 : _c.args)) {
     element.kind = "ObjectType";
     const options2 = customType(match.groups.args);
     if (typeof options2[0] === "string" && options2[0]) {
       options2.name = options2[0];
     }
-    if ((0, import_lodash5.isObject)(options2[1])) {
-      (0, import_lodash5.merge)(options2, options2[1]);
+    if (lodash.isObject(options2[1])) {
+      lodash.merge(options2, options2[1]);
     }
     element.arguments = {
       name: options2.name,
@@ -1078,16 +940,13 @@ function createSettingElement({ line, config, fieldElement, match }) {
     };
     return result;
   }
-  if (name === "Directive" && match.groups?.args) {
+  if (name === "Directive" && ((_d = match.groups) == null ? void 0 : _d.args)) {
     const options2 = customType(match.groups.args);
-    (0, import_lodash5.merge)(element, {
-      model: true,
-      from: "@nestjs/graphql"
-    }, options2, {
+    lodash.merge(element, { model: true, from: "@nestjs/graphql" }, options2, {
       name,
       namespace: false,
       kind: "Decorator",
-      arguments: Array.isArray(options2.arguments) ? options2.arguments.map((s) => import_json52.default.stringify(s)) : options2.arguments
+      arguments: Array.isArray(options2.arguments) ? options2.arguments.map((s) => JSON5__default["default"].stringify(s)) : options2.arguments
     });
     return result;
   }
@@ -1095,35 +954,31 @@ function createSettingElement({ line, config, fieldElement, match }) {
   element.namespaceImport = namespace;
   const options = {
     name,
-    arguments: (match.groups?.args || "").split(",").map((s) => (0, import_lodash5.trim)(s)).filter(Boolean)
+    arguments: (((_e = match.groups) == null ? void 0 : _e.args) || "").split(",").map((s) => lodash.trim(s)).filter(Boolean)
   };
-  (0, import_lodash5.merge)(element, namespace && config.fields[namespace], options);
+  lodash.merge(element, namespace && config.fields[namespace], options);
   return result;
 }
-__name(createSettingElement, "createSettingElement");
 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);
   result.namespace = namespace;
-  if (options.name?.includes(".")) {
+  if ((_a = options.name) == null ? void 0 : _a.includes(".")) {
     result.namespaceImport = namespace;
   }
   if (typeof options.match === "string" || Array.isArray(options.match)) {
-    result.match = (0, import_outmatch2.default)(options.match, {
-      separator: false
-    });
+    result.match = outmatch__default["default"](options.match, { separator: false });
   }
   return result;
 }
-__name(customType, "customType");
 function hideFieldDecorator(match) {
+  var _a;
   const result = {
     name: "HideField",
     arguments: [],
@@ -1132,7 +987,7 @@ function hideFieldDecorator(match) {
     namespaceImport: void 0,
     match: void 0
   };
-  if (!match.groups?.args) {
+  if (!((_a = match.groups) == null ? void 0 : _a.args)) {
     result.output = true;
     return result;
   }
@@ -1141,9 +996,7 @@ 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 = outmatch__default["default"](options.match, { separator: false });
     }
   } else {
     if (/output:\s*true/.test(match.groups.args)) {
@@ -1155,19 +1008,17 @@ function hideFieldDecorator(match) {
   }
   return result;
 }
-__name(hideFieldDecorator, "hideFieldDecorator");
 function parseArgs(string) {
   try {
-    return import_json52.default.parse(string);
+    return JSON5__default["default"].parse(string);
   } catch {
     try {
-      return import_json52.default.parse(`[${string}]`);
+      return JSON5__default["default"].parse(`[${string}]`);
     } catch {
       throw new Error(`Failed to parse: ${string}`);
     }
   }
 }
-__name(parseArgs, "parseArgs");
 function getNamespace(name) {
   if (name === void 0) {
     return void 0;
@@ -1178,11 +1029,16 @@ function getNamespace(name) {
   }
   return result;
 }
-__name(getNamespace, "getNamespace");
 
-// src/handlers/model-data.ts
 function modelData(model, args) {
-  const { config, modelNames, models, modelFields, fieldSettings, classTransformerTypeModels } = args;
+  const {
+    config,
+    modelNames,
+    models,
+    modelFields,
+    fieldSettings,
+    classTransformerTypeModels
+  } = args;
   modelNames.push(model.name);
   models.set(model.name, model);
   const modelFieldsValue = /* @__PURE__ */ new Map();
@@ -1204,56 +1060,46 @@ function modelData(model, args) {
     classTransformerTypeModels.add(model.name);
   }
 }
-__name(modelData, "modelData");
-
-// src/handlers/model-output-type.ts
-var import_assert3 = require("assert");
-var import_json53 = __toESM(require("json5"));
-var import_lodash6 = require("lodash");
-var import_pupa2 = __toESM(require("pupa"));
-var import_ts_morph5 = require("ts-morph");
 
-// src/helpers/create-comment.ts
 function createComment(documentation, settings) {
+  var _a;
   const documentationLines = documentation.split("\n");
-  const commentLines = [
-    "/**"
-  ];
+  const commentLines = ["/**"];
   for (const line of documentationLines) {
     commentLines.push(` * ${line}`);
   }
-  const deprecationReason = settings?.fieldArguments()?.deprecationReason;
+  const deprecationReason = (_a = settings == null ? void 0 : settings.fieldArguments()) == null ? void 0 : _a.deprecationReason;
   if (deprecationReason) {
     commentLines.push(` * @deprecated ${deprecationReason}`);
   }
   commentLines.push(" */\n");
   return commentLines.join("\n");
 }
-__name(createComment, "createComment");
 
-// src/helpers/get-output-type-name.ts
 function getOutputTypeName(name) {
   return name.replace(/(?:OutputType|Output)$/, "");
 }
-__name(getOutputTypeName, "getOutputTypeName");
 
-// src/handlers/model-output-type.ts
-var nestjsGraphql = "@nestjs/graphql";
-function modelOutputType(outputType2, args) {
+const nestjsGraphql$1 = "@nestjs/graphql";
+function modelOutputType(outputType, args) {
+  var _a, _b, _c, _d, _e, _f;
   const { getSourceFile, models, config, modelFields, fieldSettings, eventEmitter } = args;
-  const model = models.get(outputType2.name);
-  (0, import_assert3.ok)(model, `Cannot find model by name ${outputType2.name}`);
+  const model = models.get(outputType.name);
+  assert.ok(model, `Cannot find model by name ${outputType.name}`);
   const sourceFile = getSourceFile({
-    name: outputType2.name,
+    name: outputType.name,
     type: "model"
   });
   const sourceFileStructure = sourceFile.getStructure();
-  const exportDeclaration = getExportDeclaration(model.name, sourceFileStructure.statements);
+  const exportDeclaration = getExportDeclaration$1(
+    model.name,
+    sourceFileStructure.statements
+  );
   const importDeclarations = new ImportDeclarationMap();
   const classStructure = {
-    kind: import_ts_morph5.StructureKind.Class,
+    kind: tsMorph.StructureKind.Class,
     isExported: true,
-    name: outputType2.name,
+    name: outputType.name,
     decorators: [
       {
         name: "ObjectType",
@@ -1263,9 +1109,9 @@ function modelOutputType(outputType2, args) {
     properties: []
   };
   sourceFileStructure.statements.push(classStructure);
-  (0, import_assert3.ok)(classStructure.decorators, "classStructure.decorators is undefined");
+  assert.ok(classStructure.decorators, "classStructure.decorators is undefined");
   const decorator = classStructure.decorators.find((d) => d.name === "ObjectType");
-  (0, import_assert3.ok)(decorator, "ObjectType decorator not found");
+  assert.ok(decorator, "ObjectType decorator not found");
   let modelSettings;
   if (model.documentation) {
     const objectTypeOptions = {};
@@ -1282,9 +1128,9 @@ function modelOutputType(outputType2, args) {
     decorator.arguments = settings.getObjectTypeArguments(objectTypeOptions);
     modelSettings = settings;
   }
-  importDeclarations.add("Field", nestjsGraphql);
-  importDeclarations.add("ObjectType", nestjsGraphql);
-  for (const field of outputType2.fields) {
+  importDeclarations.add("Field", nestjsGraphql$1);
+  importDeclarations.add("ObjectType", nestjsGraphql$1);
+  for (const field of outputType.fields) {
     let fileType = "model";
     const { location, isList, type, namespace } = field.outputType;
     let outputTypeName = String(type);
@@ -1292,20 +1138,22 @@ function modelOutputType(outputType2, args) {
       fileType = "output";
       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({
-      name: outputType2.name,
+    const modelField = (_a = modelFields.get(model.name)) == null ? void 0 : _a.get(field.name);
+    const settings = (_b = fieldSettings.get(model.name)) == null ? void 0 : _b.get(field.name);
+    const fieldType = settings == null ? void 0 : settings.getFieldType({
+      name: outputType.name,
       output: true
     });
-    const propertySettings = settings?.getPropertyType({
-      name: outputType2.name,
+    const propertySettings = settings == null ? void 0 : settings.getPropertyType({
+      name: outputType.name,
       output: true
     });
-    const propertyType = (0, import_lodash6.castArray)(propertySettings?.name || getPropertyType({
-      location,
-      type: outputTypeName
-    }));
+    const propertyType = lodash.castArray(
+      (propertySettings == null ? void 0 : propertySettings.name) || getPropertyType({
+        location,
+        type: outputTypeName
+      })
+    );
     propertyType.splice(1, propertyType.length);
     if (field.isNullable && !isList) {
       propertyType.push("null");
@@ -1313,22 +1161,20 @@ function modelOutputType(outputType2, args) {
     let graphqlType;
     if (fieldType) {
       graphqlType = fieldType.name;
-      importDeclarations.create({
-        ...fieldType
-      });
+      importDeclarations.create({ ...fieldType });
     } else {
       const graphqlImport = getGraphqlImport({
         config,
         sourceFile,
         fileType,
         location,
-        isId: modelField?.isId,
+        isId: modelField == null ? void 0 : modelField.isId,
         noTypeId: config.noTypeId,
         typeName: outputTypeName,
         getSourceFile
       });
       graphqlType = graphqlImport.name;
-      if (graphqlImport.name !== outputType2.name && graphqlImport.specifier) {
+      if (graphqlImport.name !== outputType.name && graphqlImport.specifier) {
         importDeclarations.add(graphqlImport.name, graphqlImport.specifier);
       }
     }
@@ -1340,52 +1186,44 @@ function modelOutputType(outputType2, args) {
       propertyType,
       isList
     });
-    if (typeof property.leadingTrivia === "string" && modelField?.documentation) {
+    if (typeof property.leadingTrivia === "string" && (modelField == null ? void 0 : modelField.documentation)) {
       property.leadingTrivia += createComment(modelField.documentation, settings);
     }
-    classStructure.properties?.push(property);
+    (_c = classStructure.properties) == null ? void 0 : _c.push(property);
     if (propertySettings) {
-      importDeclarations.create({
-        ...propertySettings
-      });
+      importDeclarations.create({ ...propertySettings });
     } else if (propertyType.includes("Decimal")) {
       importDeclarations.add("Decimal", "@prisma/client/runtime/library");
     }
-    (0, import_assert3.ok)(property.decorators, "property.decorators is undefined");
-    const shouldHideField = settings?.shouldHideField({
-      name: outputType2.name,
-      output: true
-    }) || config.decorate.some((d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(field.name) && d.isMatchType(outputTypeName));
+    assert.ok(property.decorators, "property.decorators is undefined");
+    const shouldHideField = (settings == null ? void 0 : settings.shouldHideField({ name: outputType.name, output: true })) || config.decorate.some(
+      (d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(field.name) && d.isMatchType(outputTypeName)
+    );
     if (shouldHideField) {
-      importDeclarations.add("HideField", nestjsGraphql);
-      property.decorators.push({
-        name: "HideField",
-        arguments: []
-      });
+      importDeclarations.add("HideField", nestjsGraphql$1);
+      property.decorators.push({ name: "HideField", arguments: [] });
     } else {
       property.decorators.push({
         name: "Field",
         arguments: [
           isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`,
-          import_json53.default.stringify({
-            ...settings?.fieldArguments(),
+          JSON5__default["default"].stringify({
+            ...settings == null ? void 0 : settings.fieldArguments(),
             nullable: Boolean(field.isNullable),
-            defaultValue: [
-              "number",
-              "string",
-              "boolean"
-            ].includes(typeof modelField?.default) ? modelField?.default : void 0,
-            description: modelField?.documentation
+            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
           })
         ]
       });
       for (const setting of settings || []) {
-        if (shouldBeDecorated(setting) && (setting.match?.(field.name) ?? true)) {
+        if (shouldBeDecorated(setting) && ((_e = (_d = setting.match) == null ? void 0 : _d.call(setting, field.name)) != null ? _e : true)) {
           property.decorators.push({
             name: setting.name,
             arguments: setting.arguments
           });
-          (0, import_assert3.ok)(setting.from, "Missed 'from' part in configuration or field setting");
+          assert.ok(setting.from, "Missed 'from' part in configuration or field setting");
           importDeclarations.create(setting);
         }
       }
@@ -1393,9 +1231,7 @@ function modelOutputType(outputType2, args) {
         if (decorate.isMatchField(field.name) && decorate.isMatchType(outputTypeName)) {
           property.decorators.push({
             name: decorate.name,
-            arguments: decorate.arguments?.map((x) => (0, import_pupa2.default)(x, {
-              propertyType
-            }))
+            arguments: (_f = decorate.arguments) == null ? void 0 : _f.map((x) => pupa__default["default"](x, { propertyType }))
           });
           importDeclarations.create(decorate);
         }
@@ -1418,53 +1254,40 @@ 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) {
+function getExportDeclaration$1(name, statements) {
   return statements.find((structure) => {
-    return structure.kind === import_ts_morph5.StructureKind.ExportDeclaration && structure.namedExports.some((o) => (o.alias || o.name) === name);
+    return structure.kind === tsMorph.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", beforeGenerateFiles);
+  eventEmitter.on("BeforeInputType", beforeInputType$1);
+  eventEmitter.on("BeforeGenerateFiles", beforeGenerateFiles$1);
 }
-__name(noAtomicOperations, "noAtomicOperations");
-function beforeInputType2(args) {
-  const { inputType: inputType2, getModelName: getModelName2 } = args;
-  for (const field of inputType2.fields) {
+function beforeInputType$1(args) {
+  const { inputType, getModelName } = args;
+  for (const field of inputType.fields) {
     const fieldName = field.name;
-    field.inputTypes = field.inputTypes.filter((inputType3) => {
-      const inputTypeName = String(inputType3.type);
-      const modelName = getModelName2(inputTypeName);
+    field.inputTypes = field.inputTypes.filter((inputType2) => {
+      const inputTypeName = String(inputType2.type);
+      const modelName = getModelName(inputTypeName);
       if (isAtomicOperation(inputTypeName) || modelName && isListInput(inputTypeName, modelName, fieldName)) {
         return false;
       }
@@ -1472,56 +1295,46 @@ function beforeInputType2(args) {
     });
   }
 }
-__name(beforeInputType2, "beforeInputType");
-function beforeGenerateFiles(args) {
+function beforeGenerateFiles$1(args) {
+  var _a;
   const { project } = args;
   for (const sourceFile of project.getSourceFiles()) {
-    const className = sourceFile.getClass(() => true)?.getName();
+    const className = (_a = sourceFile.getClass(() => true)) == null ? void 0 : _a.getName();
     if (className && isAtomicOperation(className)) {
       project.removeSourceFile(sourceFile);
     }
   }
 }
-__name(beforeGenerateFiles, "beforeGenerateFiles");
 function isAtomicOperation(typeName) {
   if (typeName.endsWith("FieldUpdateOperationsInput")) {
     return true;
   }
   return false;
 }
-__name(isAtomicOperation, "isAtomicOperation");
 function isListInput(typeName, model, field) {
   return typeName === `${model}Create${field}Input` || typeName === `${model}Update${field}Input`;
 }
-__name(isListInput, "isListInput");
 
-// src/handlers/output-type.ts
-var import_assert4 = require("assert");
-var import_json54 = __toESM(require("json5"));
-var import_lodash7 = require("lodash");
-var import_ts_morph6 = require("ts-morph");
-var nestjsGraphql2 = "@nestjs/graphql";
+const nestjsGraphql = "@nestjs/graphql";
 function outputType(outputType2, args) {
-  const { getSourceFile, models, eventEmitter, fieldSettings, getModelName: getModelName2, config } = args;
+  var _a, _b, _c, _d, _e;
+  const { getSourceFile, models, eventEmitter, fieldSettings, getModelName, config } = args;
   const importDeclarations = new ImportDeclarationMap();
   const fileType = "output";
-  const modelName = getModelName2(outputType2.name) || "";
+  const modelName = getModelName(outputType2.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?.name && outputType2.name === `${model.name}CountOutputType`;
+  const isCountOutput = (model == null ? void 0 : model.name) && outputType2.name === `${model.name}CountOutputType`;
   outputType2.name = getOutputTypeName(outputType2.name);
   if (isAggregateOutput) {
-    eventEmitter.emitSync("AggregateOutput", {
-      ...args,
-      outputType: outputType2
-    });
+    eventEmitter.emitSync("AggregateOutput", { ...args, outputType: outputType2 });
   }
   const sourceFile = getSourceFile({
     name: outputType2.name,
     type: fileType
   });
   const classStructure = {
-    kind: import_ts_morph6.StructureKind.Class,
+    kind: tsMorph.StructureKind.Class,
     isExported: true,
     name: outputType2.name,
     decorators: [
@@ -1532,22 +1345,24 @@ function outputType(outputType2, args) {
     ],
     properties: []
   };
-  importDeclarations.add("Field", nestjsGraphql2);
-  importDeclarations.add("ObjectType", nestjsGraphql2);
+  importDeclarations.add("Field", nestjsGraphql);
+  importDeclarations.add("ObjectType", nestjsGraphql);
   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({
+    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,
       output: true
     });
-    const isCustomsApplicable = outputTypeName === model?.fields.find((f) => f.name === field.name)?.type;
+    const isCustomsApplicable = outputTypeName === ((_b = model == null ? void 0 : model.fields.find((f) => f.name === field.name)) == null ? void 0 : _b.type);
     field.outputType.type = outputTypeName;
-    const propertyType = (0, import_lodash7.castArray)(propertySettings?.name || getPropertyType({
-      location,
-      type: outputTypeName
-    }));
+    const propertyType = lodash.castArray(
+      (propertySettings == null ? void 0 : propertySettings.name) || getPropertyType({
+        location,
+        type: outputTypeName
+      })
+    );
     const property = propertyStructure({
       name: field.name,
       isNullable: field.isNullable,
@@ -1555,28 +1370,26 @@ function outputType(outputType2, args) {
       propertyType,
       isList
     });
-    classStructure.properties?.push(property);
+    (_c = classStructure.properties) == null ? void 0 : _c.push(property);
     if (propertySettings) {
-      importDeclarations.create({
-        ...propertySettings
-      });
+      importDeclarations.create({ ...propertySettings });
     } else if (propertyType.includes("Decimal")) {
       importDeclarations.add("Decimal", "@prisma/client/runtime/library");
     }
     let graphqlType;
-    const shouldHideField = settings?.shouldHideField({
+    const shouldHideField = (settings == null ? void 0 : settings.shouldHideField({
       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({
+    })) || config.decorate.some(
+      (d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(field.name) && d.isMatchType(outputTypeName)
+    );
+    const fieldType = settings == null ? void 0 : settings.getFieldType({
       name: outputType2.name,
       output: true
     });
     if (fieldType && isCustomsApplicable && !shouldHideField) {
       graphqlType = fieldType.name;
-      importDeclarations.create({
-        ...fieldType
-      });
+      importDeclarations.create({ ...fieldType });
     } else {
       const graphqlImport = getGraphqlImport({
         config,
@@ -1590,45 +1403,38 @@ function outputType(outputType2, args) {
       graphqlType = graphqlImport.name;
       let referenceName = propertyType[0];
       if (location === "enumTypes") {
-        referenceName = (0, import_lodash7.last)(referenceName.split(" "));
+        referenceName = lodash.last(referenceName.split(" "));
       }
       if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputType2.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
         importDeclarations.set(graphqlImport.name, {
-          namedImports: [
-            {
-              name: graphqlImport.name
-            }
-          ],
+          namedImports: [{ name: graphqlImport.name }],
           moduleSpecifier: graphqlImport.specifier
         });
       }
     }
-    (0, import_assert4.ok)(property.decorators, "property.decorators is undefined");
+    assert.ok(property.decorators, "property.decorators is undefined");
     if (shouldHideField) {
-      importDeclarations.add("HideField", nestjsGraphql2);
-      property.decorators.push({
-        name: "HideField",
-        arguments: []
-      });
+      importDeclarations.add("HideField", nestjsGraphql);
+      property.decorators.push({ name: "HideField", arguments: [] });
     } else {
       property.decorators.push({
         name: "Field",
         arguments: [
           isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`,
-          import_json54.default.stringify({
-            ...settings?.fieldArguments(),
+          JSON5__default["default"].stringify({
+            ...settings == null ? void 0 : settings.fieldArguments(),
             nullable: Boolean(field.isNullable)
           })
         ]
       });
       if (isCustomsApplicable) {
         for (const options of settings || []) {
-          if ((options.kind === "Decorator" && options.output && options.match?.(field.name)) ?? true) {
+          if ((_e = options.kind === "Decorator" && options.output && ((_d = options.match) == null ? void 0 : _d.call(options, field.name))) != null ? _e : true) {
             property.decorators.push({
               name: options.name,
               arguments: options.arguments
             });
-            (0, import_assert4.ok)(options.from, "Missed 'from' part in configuration or field setting");
+            assert.ok(options.from, "Missed 'from' part in configuration or field setting");
             importDeclarations.create(options);
           }
         }
@@ -1641,128 +1447,126 @@ function outputType(outputType2, args) {
     });
   }
   sourceFile.set({
-    statements: [
-      ...importDeclarations.toStatements(),
-      classStructure
-    ]
+    statements: [...importDeclarations.toStatements(), classStructure]
   });
 }
-__name(outputType, "outputType");
 
-// src/handlers/purge-output.ts
-var import_graceful_fs = require("graceful-fs");
 function purgeOutput(emitter) {
   emitter.on("Begin", begin);
   emitter.on("End", end);
 }
-__name(purgeOutput, "purgeOutput");
 function begin({ project, output }) {
-  const sourceFiles = project.getDirectory(output)?.getDescendantSourceFiles();
+  var _a;
+  const sourceFiles = (_a = project.getDirectory(output)) == null ? void 0 : _a.getDescendantSourceFiles();
   if (sourceFiles) {
     for (const sourceFile of sourceFiles) {
       sourceFile.delete();
     }
   }
 }
-__name(begin, "begin");
 function end({ project, output }) {
-  const directories = project.getDirectory(output)?.getDescendantDirectories().filter((directory) => directory.getSourceFiles().length === 0).map((directory) => directory.getPath());
+  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 || []) {
     try {
-      (0, import_graceful_fs.rmdirSync)(directory);
+      gracefulFs.rmdirSync(directory);
     } catch {
     }
   }
 }
-__name(end, "end");
 
-// src/handlers/re-export.ts
-var import_ts_morph7 = require("ts-morph");
-var ReExport;
-(function(ReExport2) {
+var ReExport = /* @__PURE__ */ ((ReExport2) => {
   ReExport2["None"] = "None";
   ReExport2["Directories"] = "Directories";
   ReExport2["Single"] = "Single";
   ReExport2["All"] = "All";
-})(ReExport || (ReExport = {}));
+  return ReExport2;
+})(ReExport || {});
 function reExport(emitter) {
-  emitter.on("BeforeGenerateFiles", beforeGenerateFiles2);
+  emitter.on("BeforeGenerateFiles", beforeGenerateFiles);
 }
-__name(reExport, "reExport");
-function beforeGenerateFiles2(args) {
+function beforeGenerateFiles(args) {
   const { project, output, config } = args;
   const rootDirectory = project.getDirectoryOrThrow(output);
-  if ([
-    ReExport.Directories,
-    ReExport.All
-  ].includes(config.reExport)) {
+  if (["Directories" /* Directories */, "All" /* All */].includes(config.reExport)) {
     for (const directory of rootDirectory.getDescendantDirectories()) {
       let indexSourceFile;
       const exportDeclarations = directory.getSourceFiles().filter((sourceFile) => {
         return sourceFile.getBaseName() !== "index.ts";
-      }).map((sourcesFile) => getExportDeclaration2(directory, sourcesFile));
+      }).map((sourcesFile) => getExportDeclaration(directory, sourcesFile));
       if (exportDeclarations.length > 0) {
-        indexSourceFile = directory.createSourceFile("index.ts", {
-          statements: exportDeclarations
-        }, {
-          overwrite: true
-        });
+        indexSourceFile = directory.createSourceFile(
+          "index.ts",
+          {
+            statements: exportDeclarations
+          },
+          {
+            overwrite: true
+          }
+        );
       }
       if (indexSourceFile) {
         continue;
       }
-      const namespaceExportDeclarations = directory.getDirectories().map((sourceDirectory) => getNamespaceExportDeclaration(directory, sourceDirectory));
-      project.createSourceFile(`${directory.getPath()}/index.ts`, {
-        statements: namespaceExportDeclarations
-      }, {
-        overwrite: true
-      });
+      const namespaceExportDeclarations = directory.getDirectories().map(
+        (sourceDirectory) => getNamespaceExportDeclaration(directory, sourceDirectory)
+      );
+      project.createSourceFile(
+        `${directory.getPath()}/index.ts`,
+        {
+          statements: namespaceExportDeclarations
+        },
+        {
+          overwrite: true
+        }
+      );
     }
   }
-  if (config.reExport === ReExport.Single) {
+  if (config.reExport === "Single" /* Single */) {
     const exportDeclarations = project.getSourceFiles().filter((sourceFile) => {
       return sourceFile.getBaseName() !== "index.ts";
-    }).map((sourceFile) => getExportDeclaration2(rootDirectory, sourceFile));
-    rootDirectory.createSourceFile("index.ts", {
-      statements: exportDeclarations
-    }, {
-      overwrite: true
-    });
+    }).map((sourceFile) => getExportDeclaration(rootDirectory, sourceFile));
+    rootDirectory.createSourceFile(
+      "index.ts",
+      {
+        statements: exportDeclarations
+      },
+      {
+        overwrite: true
+      }
+    );
   }
-  if (config.reExport === ReExport.All) {
+  if (config.reExport === "All" /* All */) {
     const exportDeclarations = [];
     for (const directory of rootDirectory.getDirectories()) {
       const sourceFile = directory.getSourceFileOrThrow("index.ts");
-      exportDeclarations.push(getExportDeclaration2(rootDirectory, sourceFile));
+      exportDeclarations.push(getExportDeclaration(rootDirectory, sourceFile));
     }
-    rootDirectory.createSourceFile("index.ts", {
-      statements: exportDeclarations
-    }, {
-      overwrite: true
-    });
+    rootDirectory.createSourceFile(
+      "index.ts",
+      {
+        statements: exportDeclarations
+      },
+      {
+        overwrite: true
+      }
+    );
   }
 }
-__name(beforeGenerateFiles2, "beforeGenerateFiles");
-function getExportDeclaration2(directory, sourceFile) {
+function getExportDeclaration(directory, sourceFile) {
   return {
-    kind: import_ts_morph7.StructureKind.ExportDeclaration,
-    namedExports: sourceFile.getExportSymbols().map((s) => ({
-      name: s.getName()
-    })),
+    kind: tsMorph.StructureKind.ExportDeclaration,
+    namedExports: sourceFile.getExportSymbols().map((s) => ({ name: s.getName() })),
     moduleSpecifier: directory.getRelativePathAsModuleSpecifierTo(sourceFile)
   };
 }
-__name(getExportDeclaration2, "getExportDeclaration");
 function getNamespaceExportDeclaration(directory, sourceDirectory) {
   return {
-    kind: import_ts_morph7.StructureKind.ExportDeclaration,
+    kind: tsMorph.StructureKind.ExportDeclaration,
     moduleSpecifier: directory.getRelativePathAsModuleSpecifierTo(sourceDirectory)
   };
 }
-__name(getNamespaceExportDeclaration, "getNamespaceExportDeclaration");
 
-// src/handlers/register-enum.ts
-var import_ts_morph8 = require("ts-morph");
 function registerEnum(enumType, args) {
   const { getSourceFile, enums } = args;
   const dataModelEnum = enums[enumType.name];
@@ -1772,15 +1576,11 @@ function registerEnum(enumType, args) {
   });
   const importDeclarations = new ImportDeclarationMap();
   importDeclarations.set("registerEnumType", {
-    namedImports: [
-      {
-        name: "registerEnumType"
-      }
-    ],
+    namedImports: [{ name: "registerEnumType" }],
     moduleSpecifier: "@nestjs/graphql"
   });
   const enumStructure = {
-    kind: import_ts_morph8.StructureKind.Enum,
+    kind: tsMorph.StructureKind.Enum,
     isExported: true,
     name: enumType.name,
     members: enumType.values.map((v) => ({
@@ -1793,34 +1593,28 @@ function registerEnum(enumType, args) {
       ...importDeclarations.toStatements(),
       enumStructure,
       "\n",
-      `registerEnumType(${enumType.name}, { name: '${enumType.name}', description: ${JSON.stringify(dataModelEnum?.documentation)} })`
+      `registerEnumType(${enumType.name}, { name: '${enumType.name}', description: ${JSON.stringify(dataModelEnum == null ? void 0 : dataModelEnum.documentation)} })`
     ]
   });
 }
-__name(registerEnum, "registerEnum");
 
-// src/handlers/require-single-fields-in-whereunique-input.ts
 function requireSingleFieldsInWhereUniqueInput(eventEmitter) {
-  eventEmitter.on("BeforeInputType", beforeInputType3);
+  eventEmitter.on("BeforeInputType", beforeInputType);
 }
-__name(requireSingleFieldsInWhereUniqueInput, "requireSingleFieldsInWhereUniqueInput");
-function beforeInputType3(args) {
-  const { inputType: inputType2 } = args;
-  if (!isWhereUniqueInputType(inputType2.name) || inputType2.fields.length !== 1) {
+function beforeInputType(args) {
+  const { inputType } = args;
+  if (!isWhereUniqueInputType(inputType.name) || inputType.fields.length !== 1) {
     return;
   }
-  for (const field of inputType2.fields) {
+  for (const field of inputType.fields) {
     field.isRequired = true;
     field.isNullable = false;
   }
 }
-__name(beforeInputType3, "beforeInputType");
 function isWhereUniqueInputType(name) {
   return name.endsWith("WhereUniqueInput");
 }
-__name(isWhereUniqueInputType, "isWhereUniqueInputType");
 
-// src/handlers/warning.ts
 function warning(message) {
   if (Array.isArray(message)) {
     console.log("prisma-nestjs-graphql:");
@@ -1829,28 +1623,22 @@ function warning(message) {
     console.log("prisma-nestjs-graphql:", message);
   }
 }
-__name(warning, "warning");
 
-// src/helpers/create-config.ts
-var import_assert5 = require("assert");
-var import_filenamify = __toESM(require("filenamify"));
-var import_flat = require("flat");
-var import_graceful_fs2 = require("graceful-fs");
-var import_json55 = __toESM(require("json5"));
-var import_lodash8 = require("lodash");
-var import_outmatch3 = __toESM(require("outmatch"));
 function createConfig(data) {
-  const config = (0, import_lodash8.merge)({}, (0, import_flat.unflatten)(data, {
-    delimiter: "_"
-  }));
+  var _a;
+  const config = lodash.merge({}, flat.unflatten(data, { delimiter: "_" }));
   const $warnings = [];
-  const configOutputFilePattern = String(config.outputFilePattern || `{model}/{name}.{type}.ts`);
-  let outputFilePattern = (0, import_filenamify.default)(configOutputFilePattern, {
+  const configOutputFilePattern = String(
+    config.outputFilePattern || `{model}/{name}.{type}.ts`
+  );
+  let outputFilePattern = filenamify__default["default"](configOutputFilePattern, {
     replacement: "/"
   }).replace(/\.\./g, "/").replace(/\/+/g, "/");
-  outputFilePattern = (0, import_lodash8.trim)(outputFilePattern, "/");
+  outputFilePattern = lodash.trim(outputFilePattern, "/");
   if (outputFilePattern !== configOutputFilePattern) {
-    $warnings.push(`Due to invalid filepath 'outputFilePattern' changed to '${outputFilePattern}'`);
+    $warnings.push(
+      `Due to invalid filepath 'outputFilePattern' changed to '${outputFilePattern}'`
+    );
   }
   if (config.reExportAll) {
     $warnings.push(`Option 'reExportAll' is deprecated, use 'reExport' instead`);
@@ -1858,40 +1646,42 @@ function createConfig(data) {
       config.reExport = "All";
     }
   }
-  const fields = Object.fromEntries(Object.entries(config.fields ?? {}).filter(({ 1: value }) => typeof value === "object").map(([name, value]) => {
-    const fieldSetting = {
-      arguments: [],
-      output: toBoolean(value.output),
-      input: toBoolean(value.input),
-      model: toBoolean(value.model),
-      from: value.from,
-      defaultImport: toBoolean(value.defaultImport) ? true : value.defaultImport,
-      namespaceImport: value.namespaceImport
-    };
-    return [
-      name,
-      fieldSetting
-    ];
-  }));
+  const fields = Object.fromEntries(
+    Object.entries(
+      (_a = config.fields) != null ? _a : {}
+    ).filter(({ 1: value }) => typeof value === "object").map(([name, value]) => {
+      const fieldSetting = {
+        arguments: [],
+        output: toBoolean(value.output),
+        input: toBoolean(value.input),
+        model: toBoolean(value.model),
+        from: value.from,
+        defaultImport: toBoolean(value.defaultImport) ? true : value.defaultImport,
+        namespaceImport: value.namespaceImport
+      };
+      return [name, fieldSetting];
+    })
+  );
   const decorate = [];
-  const configDecorate = Object.values(config.decorate || {});
+  const configDecorate = Object.values(
+    config.decorate || {}
+  );
   for (const element of configDecorate) {
     if (!element)
       continue;
-    (0, import_assert5.ok)(element.from && element.name, `Missed 'from' or 'name' part in configuration for decorate`);
+    assert.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: outmatch__default["default"](element.field, { separator: false }),
+      isMatchType: outmatch__default["default"](element.type, { separator: false }),
       from: element.from,
       name: element.name,
       namedImport: toBoolean(element.namedImport),
       defaultImport: toBoolean(element.defaultImport) ? true : element.defaultImport,
       namespaceImport: element.namespaceImport,
-      arguments: element.arguments ? import_json55.default.parse(element.arguments) : void 0
+      arguments: element.arguments ? JSON5__default["default"].parse(element.arguments) : void 0
     });
   }
   return {
@@ -1907,14 +1697,15 @@ function createConfig(data) {
     purgeOutput: toBoolean(config.purgeOutput),
     useInputType: createUseInputType(config.useInputType),
     noTypeId: toBoolean(config.noTypeId),
-    requireSingleFieldsInWhereUniqueInput: toBoolean(config.requireSingleFieldsInWhereUniqueInput),
+    requireSingleFieldsInWhereUniqueInput: toBoolean(
+      config.requireSingleFieldsInWhereUniqueInput
+    ),
     graphqlScalars: config.graphqlScalars || {},
     decorate
   };
 }
-__name(createConfig, "createConfig");
-var tsConfigFileExists = (0, import_lodash8.memoize)((filePath) => {
-  return (0, import_graceful_fs2.existsSync)(filePath);
+const tsConfigFileExists = lodash.memoize((filePath) => {
+  return gracefulFs.existsSync(filePath);
 });
 function createTsConfigFilePathValue(value) {
   if (typeof value === "string")
@@ -1922,7 +1713,6 @@ function createTsConfigFilePathValue(value) {
   if (tsConfigFileExists("tsconfig.json"))
     return "tsconfig.json";
 }
-__name(createTsConfigFilePathValue, "createTsConfigFilePathValue");
 function createUseInputType(data) {
   if (!data) {
     return [];
@@ -1944,35 +1734,21 @@ 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_lodash9 = require("lodash");
-var import_pluralize = __toESM(require("pluralize"));
-var import_pupa3 = __toESM(require("pupa"));
 function generateFileName(args) {
-  const { template, type, name, getModelName: getModelName2 } = args;
-  return (0, import_pupa3.default)(template, {
+  const { template, type, name, getModelName } = args;
+  return pupa__default["default"](template, {
     type,
     get model() {
-      const result = getModelName2(name) || "prisma";
-      return (0, import_lodash9.kebabCase)(result);
+      const result = getModelName(name) || "prisma";
+      return lodash.kebabCase(result);
     },
     get name() {
-      let result = (0, import_lodash9.kebabCase)(name);
-      for (const suffix of [
-        "input",
-        "args",
-        "enum"
-      ]) {
+      let result = lodash.kebabCase(name);
+      for (const suffix of ["input", "args", "enum"]) {
         const ending = `-${suffix}`;
         if (type === suffix && result.endsWith(ending)) {
           result = result.slice(0, -ending.length);
@@ -1982,45 +1758,33 @@ function generateFileName(args) {
     },
     plural: {
       get type() {
-        return (0, import_pluralize.default)(type);
+        return pluralize__default["default"](type);
       }
     }
   });
 }
-__name(generateFileName, "generateFileName");
 
-// src/helpers/factory-get-source-file.ts
 function factoryGetSourceFile(args) {
-  const { outputFilePattern, output, getModelName: getModelName2, project } = args;
-  return /* @__PURE__ */ __name(function getSourceFile(args2) {
+  const { outputFilePattern, output, getModelName, project } = args;
+  return function getSourceFile(args2) {
     const { name, type } = args2;
     let filePath = generateFileName({
-      getModelName: getModelName2,
+      getModelName,
       name,
       type,
       template: outputFilePattern
     });
     filePath = `${output}/${filePath}`;
-    return project.getSourceFile(filePath) || project.createSourceFile(filePath, void 0, {
-      overwrite: true
-    });
-  }, "getSourceFile");
+    return project.getSourceFile(filePath) || project.createSourceFile(filePath, void 0, { overwrite: true });
+  };
 }
-__name(factoryGetSourceFile, "factoryGetSourceFile");
 
-// src/helpers/get-model-name.ts
-var import_lodash10 = require("lodash");
 function createGetModelName(modelNames) {
-  return (0, import_lodash10.memoize)(tryGetName);
+  return lodash.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) {
@@ -2035,12 +1799,12 @@ function getModelName(args) {
       return test;
     }
   }
-  for (const [start, end2] of middleKeywords) {
-    let test = name.slice(start.length).slice(0, -end2.length);
+  for (const [start, end] of middleKeywords) {
+    let test = name.slice(start.length).slice(0, -end.length);
     if (modelNames.includes(test)) {
       return test;
     }
-    test = name.slice(0, -(start + end2).length);
+    test = name.slice(0, -(start + end).length);
     if (modelNames.includes(test)) {
       return test;
     }
@@ -2048,7 +1812,7 @@ function getModelName(args) {
   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);
-    return (0, import_lodash10.first)(models);
+    return lodash.first(models);
   }
   if (name.slice(-5) === "Count") {
     const test = name.slice(0, -5);
@@ -2058,8 +1822,7 @@ function getModelName(args) {
   }
   return void 0;
 }
-__name(getModelName, "getModelName");
-var splitKeywords = [
+const splitKeywords = [
   "CreateInput",
   "CreateMany",
   "CreateNested",
@@ -2102,7 +1865,7 @@ var splitKeywords = [
   "Create",
   "Update"
 ].sort((a, b) => b.length - a.length);
-var endsWithKeywords = [
+const endsWithKeywords = [
   "Aggregate",
   "GroupBy",
   "CreateOne",
@@ -2115,75 +1878,30 @@ var endsWithKeywords = [
   "UpdateOne",
   "UpsertOne"
 ];
-var middleKeywords = [
-  [
-    "FindFirst",
-    "OrThrowArgs"
-  ],
-  [
-    "FindUnique",
-    "OrThrowArgs"
-  ],
-  [
-    "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"
-  ]
+const middleKeywords = [
+  ["FindFirst", "OrThrowArgs"],
+  ["FindUnique", "OrThrowArgs"],
+  ["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
 async function generate(args) {
+  var _a;
   const { connectCallback, generator, skipAddOutputSourceFiles, dmmf } = args;
-  const generatorOutputValue = generator.output?.value;
-  (0, import_assert6.ok)(generatorOutputValue, "Missing generator configuration: output");
-  const eventEmitter = new import_await_event_emitter.default();
+  const generatorOutputValue = (_a = generator.output) == null ? void 0 : _a.value;
+  assert.ok(generatorOutputValue, "Missing generator configuration: output");
+  const eventEmitter = new AwaitEventEmitter__default["default"]();
   eventEmitter.on("Warning", warning);
   eventEmitter.on("Model", modelData);
   eventEmitter.on("EnumType", registerEnum);
@@ -2197,12 +1915,12 @@ async function generate(args) {
   for (const message of config.$warnings) {
     eventEmitter.emitSync("Warning", message);
   }
-  const project = new import_ts_morph9.Project({
+  const project = new tsMorph.Project({
     tsConfigFilePath: config.tsConfigFilePath,
     skipAddingFilesFromTsConfig: true,
     skipLoadingLibFiles: !config.emitCompiled,
     manipulationSettings: {
-      quoteKind: import_ts_morph9.QuoteKind.Single
+      quoteKind: tsMorph.QuoteKind.Single
     }
   });
   if (!skipAddOutputSourceFiles) {
@@ -2221,11 +1939,11 @@ async function generate(args) {
   const modelNames = [];
   const modelFields = /* @__PURE__ */ new Map();
   const fieldSettings = /* @__PURE__ */ new Map();
-  const getModelName2 = createGetModelName(modelNames);
+  const getModelName = createGetModelName(modelNames);
   const getSourceFile = factoryGetSourceFile({
     output: generatorOutputValue,
     project,
-    getModelName: getModelName2,
+    getModelName,
     outputFilePattern: config.outputFilePattern,
     eventEmitter
   });
@@ -2243,8 +1961,8 @@ async function generate(args) {
     getSourceFile,
     eventEmitter,
     typeNames: /* @__PURE__ */ new Set(),
-    enums: (0, import_lodash11.mapKeys)(datamodel.enums, (x) => x.name),
-    getModelName: getModelName2,
+    enums: lodash.mapKeys(datamodel.enums, (x) => x.name),
+    getModelName,
     removeTypes,
     classTransformerTypeModels: /* @__PURE__ */ new Set()
   };
@@ -2268,10 +1986,7 @@ async function generate(args) {
   }
   const queryOutputTypes = [];
   for (const outputType2 of outputObjectTypes.prisma) {
-    if ([
-      "Query",
-      "Mutation"
-    ].includes(outputType2.name)) {
+    if (["Query", "Mutation"].includes(outputType2.name)) {
       queryOutputTypes.push(outputType2);
       continue;
     }
@@ -2304,17 +2019,5 @@ async function generate(args) {
     eventEmitter.off(name);
   }
 }
-__name(generate, "generate");
 
-// src/index.ts
-(0, import_generator_helper.generatorHandler)({
-  async onGenerate(options) {
-    await generate(options);
-  },
-  onManifest() {
-    return {
-      defaultOutput: ".",
-      prettyName: "Prisma NestJS/GraphQL"
-    };
-  }
-});
+exports.generate = generate;