prisma-nestjs-graphql 21.2.0 → 22.0.0

package/prisma-nestjs-graphql.mjs

@@ -0,0 +1,2352 @@
+import { ok } from 'node:assert';
+import awaitEventEmitterModule from 'await-event-emitter';
+import { StructureKind, Project, QuoteKind } from 'ts-morph';
+import lodash from 'lodash';
+import { ok as ok$1 } from 'assert';
+import JSON5 from 'json5';
+import pupa from 'pupa';
+import path from 'node:path';
+import getRelativePath from 'get-relative-path';
+import outmatch from 'outmatch';
+import fs from 'graceful-fs';
+import filenamify from 'filenamify';
+import { unflatten } from 'flat';
+import pluralize from 'pluralize';
+
+function isManyAndReturnOutputType(name) {
+  const lowerName = name.toLowerCase();
+  if ((lowerName.startsWith('createmany') || lowerName.startsWith('updatemany')) && (lowerName.endsWith('andreturnoutputtype') || lowerName.endsWith('andreturn'))) {
+    return true;
+  }
+  return false;
+}
+
+const {
+  camelCase,
+  castArray,
+  cloneDeep,
+  countBy,
+  first,
+  isEqual,
+  isObject,
+  kebabCase,
+  keyBy,
+  last,
+  mapKeys,
+  memoize,
+  merge,
+  omit,
+  partition,
+  remove,
+  startCase,
+  trim,
+  uniq,
+  uniqWith
+} = lodash;
+function pascalCase(string) {
+  return startCase(camelCase(string)).replaceAll(' ', '');
+}
+
+/**
+ * See https://github.com/prisma/prisma/blob/master/src/packages/client/src/generation/TSClient/Model.ts@getAggregationTypes
+ * Subcribes on: 'ArgsType'
+ */
+function argsType(field, args) {
+  if (['queryRaw', 'executeRaw'].includes(field.name)) {
+    return;
+  }
+  if (isManyAndReturnOutputType(field.name)) return;
+  const {
+    eventEmitter,
+    getModelName,
+    typeNames
+  } = args;
+  let className = pascalCase(`${field.name}Args`);
+  const modelName = getModelName(className) || '';
+  switch (className) {
+    case `Aggregate${modelName}Args`:
+      {
+        className = `${modelName}AggregateArgs`;
+        break;
+      }
+    case `GroupBy${modelName}Args`:
+      {
+        className = `${modelName}GroupByArgs`;
+        break;
+      }
+  }
+  const inputType = {
+    constraints: {
+      maxNumFields: null,
+      minNumFields: null
+    },
+    fields: [...field.args],
+    name: className
+  };
+  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) {
+      // Make `by` property array only, noEnumerable
+      const byField = inputType.fields.find(f => f.name === 'by');
+      if (byField?.inputTypes) {
+        byField.inputTypes = byField.inputTypes.filter(inputType => inputType.isList);
+      }
+    }
+    for (const name of names) {
+      if (!typeNames.has(`${modelName}${name}AggregateInput`)) {
+        continue;
+      }
+      inputType.fields.push({
+        inputTypes: [{
+          isList: false,
+          location: 'inputObjectTypes',
+          type: `${modelName}${name}AggregateInput`
+        }],
+        isNullable: true,
+        isParameterizable: false,
+        // ?
+        isRequired: false,
+        name: `_${name.toLowerCase()}`
+      });
+    }
+  }
+  eventEmitter.emitSync('InputType', {
+    ...args,
+    classDecoratorName: 'ArgsType',
+    fileType: 'args',
+    inputType
+  });
+}
+
+const BeforeGenerateField = 'BeforeGenerateField';
+
+/**
+ * Subscribes on 'BeforeInputType'
+ */
+function combineScalarFilters(eventEmitter) {
+  eventEmitter.on('BeforeInputType', beforeInputType$2);
+  eventEmitter.on(BeforeGenerateField, beforeGenerateField);
+  eventEmitter.on('PostBegin', postBegin);
+}
+function beforeInputType$2(args) {
+  const {
+    inputType,
+    removeTypes
+  } = args;
+  if (isContainBogus(inputType.name) && isScalarFilter(inputType)) {
+    removeTypes.add(inputType.name);
+    inputType.name = replaceBogus(inputType.name);
+  }
+}
+function beforeGenerateField(field) {
+  for (const fieldInput of field.inputTypes) {
+    if (fieldInput.location !== 'inputObjectTypes') {
+      continue;
+    }
+    const fieldInputType = String(fieldInput.type);
+    if (isContainBogus(fieldInputType)) {
+      fieldInput.type = replaceBogus(fieldInputType);
+    }
+  }
+}
+function replaceBogus(name) {
+  return name.replaceAll(/Nullable|Nested/g, '');
+}
+function isContainBogus(name) {
+  return name.startsWith('Nested') || name.includes('Nullable') && name.endsWith('Filter') || name.endsWith('NullableFilter');
+}
+function isScalarFilter(inputType) {
+  if (!inputType.name.endsWith('Filter')) {
+    return false;
+  }
+  let result = false;
+  const equals = inputType.fields.find(f => f.name === 'equals');
+  if (equals) {
+    result = equals.inputTypes.every(x => {
+      return ['enumTypes', 'scalar'].includes(x.location);
+    });
+  }
+  return result;
+}
+function postBegin(args) {
+  const {
+    modelNames,
+    schema
+  } = args;
+  const inputTypes = schema.inputObjectTypes.prisma ?? [];
+  const enumTypes = schema.enumTypes.model || [];
+  const types = ['Bool', 'Int', 'String', 'DateTime', 'Decimal', 'Float', 'Json', 'Bytes', 'BigInt'];
+  for (const enumType of enumTypes) {
+    const {
+      name
+    } = enumType;
+    types.push(`Enum${name}`);
+  }
+  const inputTypeByName = keyBy(inputTypes, inputType => inputType.name);
+  const replaceBogusFilters = (filterName, filterNameCandidates) => {
+    for (const filterNameCandidate of filterNameCandidates) {
+      const candidate = inputTypeByName[filterNameCandidate];
+      if (candidate) {
+        const inputType = cloneDeep({
+          ...candidate,
+          name: filterName
+        });
+        inputTypes.push(inputType);
+        inputTypeByName[filterName] = inputType;
+        break;
+      }
+    }
+  };
+  for (const type of types) {
+    // Scalar filters
+    replaceBogusFilters(`${type}Filter`, [`${type}NullableFilter`, `Nested${type}NullableFilter`]);
+    replaceBogusFilters(`${type}WithAggregatesFilter`, [`${type}NullableWithAggregatesFilter`, `Nested${type}NullableWithAggregatesFilter`]);
+    replaceBogusFilters(`${type}ListFilter`, [`${type}NullableListFilter`, `Nested${type}NullableListFilter`]);
+  }
+  for (const modelName of modelNames) {
+    replaceBogusFilters(`${modelName}RelationFilter`, [`${modelName}NullableRelationFilter`]);
+  }
+  for (const modelName of modelNames) {
+    replaceBogusFilters(`${modelName}ScalarRelationFilter`, [`${modelName}NullableScalarRelationFilter`]);
+  }
+  remove(inputTypes, inputType => {
+    return isContainBogus(inputType.name);
+  });
+}
+
+/**
+ * Create aggregate inputs from aggregate outputs.
+ * See client/src/generation/TSClient.ts @ getAggregationTypes
+ * Subcribes on: 'AggregateOutput'
+ */
+function createAggregateInput(args) {
+  const {
+    eventEmitter,
+    outputType
+  } = args;
+  const className = `${outputType.name}Input`;
+
+  // console.dir({ outputType, className, __filename }, { depth: 5 });
+
+  const inputType = {
+    constraints: {
+      maxNumFields: null,
+      minNumFields: null
+    },
+    fields: outputType.fields.map(x => ({
+      inputTypes: [{
+        isList: false,
+        location: 'scalar',
+        type: 'true'
+      }],
+      isNullable: x.isNullable ?? true,
+      isParameterizable: false,
+      // ?
+      isRequired: false,
+      name: x.name
+    })),
+    name: className
+  };
+  eventEmitter.emitSync('InputType', {
+    ...args,
+    classDecoratorName: 'InputType',
+    fileType: 'input',
+    inputType
+  });
+}
+
+class ImportDeclarationMap extends Map {
+  add(name, value) {
+    if (!this.has(name)) {
+      if (typeof value === 'string') {
+        this.set(name, {
+          moduleSpecifier: value,
+          namedImports: [{
+            name
+          }]
+        });
+      } else {
+        this.set(name, value);
+      }
+    }
+  }
+  create(args) {
+    const {
+      config,
+      propertySettings,
+      propertyType
+    } = args;
+    if (propertySettings) {
+      return this.createFrom({
+        ...propertySettings
+      });
+    }
+    if (/\bIdentity</.test(propertyType)) {
+      this.add('Identity', {
+        isTypeOnly: true,
+        moduleSpecifier: 'identity-type',
+        namedImports: [{
+          name: 'Identity'
+        }]
+      });
+    }
+    if ([/\bDecimal\b/, /\bArray<Decimal>\b/].some(re => re.test(propertyType))) {
+      // TODO: Deprecated and should be removed
+      this.add('Decimal', '@prisma/client-runtime-utils');
+    }
+    if (/\bPrisma\./.test(propertyType)) {
+      this.add('Prisma', config.prismaClientImport);
+    }
+  }
+  createFrom(args) {
+    const {
+      defaultImport,
+      from,
+      namedImport,
+      namespaceImport
+    } = args;
+    let name = args.name;
+    const value = {
+      defaultImport: undefined,
+      moduleSpecifier: from,
+      namedImports: [],
+      namespaceImport: undefined
+    };
+    if (namedImport === true && namespaceImport) {
+      value.namedImports = [{
+        name: namespaceImport
+      }];
+      name = namespaceImport;
+    } else if (defaultImport) {
+      value.defaultImport = defaultImport === true ? name : defaultImport;
+      name = value.defaultImport;
+    } else if (namespaceImport) {
+      value.namespaceImport = namespaceImport;
+      name = namespaceImport;
+    } else {
+      value.namedImports = [{
+        name
+      }];
+    }
+    this.add(name, value);
+  }
+  *toStatements() {
+    const iterator = this.values();
+    let result = iterator.next();
+    while (result.value) {
+      yield {
+        ...result.value,
+        kind: StructureKind.ImportDeclaration
+      };
+      result = iterator.next();
+    }
+  }
+}
+
+async function generateFiles(args) {
+  const {
+    config,
+    eventEmitter,
+    output,
+    project
+  } = args;
+  if (config.emitSingle) {
+    combineToSingle({
+      config,
+      output,
+      project
+    });
+  }
+  if (config.emitCompiled) {
+    project.compilerOptions.set({
+      declaration: true,
+      declarationDir: output,
+      emitDecoratorMetadata: false,
+      outDir: output,
+      rootDir: output,
+      skipLibCheck: true
+    });
+    const emitResult = await project.emit();
+    const errors = emitResult.getDiagnostics().map(d => String(d.getMessageText()));
+    if (errors.length > 0) {
+      eventEmitter.emitSync('Warning', errors);
+    }
+  } else {
+    await project.save();
+  }
+}
+function combineToSingle(args) {
+  const {
+    config,
+    output,
+    project
+  } = args;
+  const rootDirectory = project.getDirectory(output) || project.createDirectory(output);
+  const sourceFile = rootDirectory.getSourceFile('index.ts') || rootDirectory.createSourceFile('index.ts', undefined, {
+    overwrite: true
+  });
+  const statements = project.getSourceFiles().flatMap(s => {
+    if (s === sourceFile) {
+      return [];
+    }
+    const classDeclaration = s.getClass(() => true);
+    const statements = s.getStructure().statements;
+    // Reget decorator full name
+    // TODO: Check possible bug of ts-morph
+    if (Array.isArray(statements)) {
+      for (const statement of statements) {
+        if (!(typeof statement === 'object' && statement.kind === 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();
+            ok(fullName, `Cannot get full name of decorator of class ${statement.name}`);
+            decorator.name = fullName;
+          }
+        }
+      }
+    }
+    project.removeSourceFile(s);
+    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);
+      }
+      continue;
+    }
+    switch (statement.kind) {
+      case StructureKind.ImportDeclaration:
+        {
+          if (statement.moduleSpecifier.startsWith('.')) {
+            continue;
+          }
+          for (const namedImport of statement.namedImports) {
+            const name = namedImport.alias || namedImport.name;
+            if (statement.moduleSpecifier === 'identity-type') {
+              imports.add(name, statement);
+              continue;
+            }
+            imports.add(name, statement.moduleSpecifier);
+          }
+          if (statement.defaultImport) {
+            imports.createFrom({
+              defaultImport: statement.defaultImport,
+              from: statement.moduleSpecifier,
+              name: statement.defaultImport
+            });
+          }
+          if (statement.namespaceImport) {
+            imports.createFrom({
+              from: statement.moduleSpecifier,
+              name: statement.namespaceImport,
+              namespaceImport: statement.namespaceImport
+            });
+          }
+          break;
+        }
+      case StructureKind.Enum:
+        {
+          enums.unshift(statement);
+          break;
+        }
+      case StructureKind.Class:
+        {
+          classes.push(statement);
+          break;
+        }
+    }
+  }
+  for (const customImport of config.customImport) {
+    imports.createFrom(customImport);
+  }
+  sourceFile.set({
+    kind: StructureKind.SourceFile,
+    statements: [...imports.toStatements(), ...enums, ...classes]
+  });
+}
+
+const extensions = new Set(['.js', '.mjs', '.ts', '.mts']);
+function adjustModuleSpecifier(moduleSpecifier, importExtension) {
+  if (moduleSpecifier.startsWith('.')) {
+    let specifierWithoutExtension = moduleSpecifier;
+    const extension = path.extname(moduleSpecifier);
+    if (extensions.has(extension)) {
+      specifierWithoutExtension = moduleSpecifier.slice(0, -extension.length);
+    }
+    if (!importExtension) return specifierWithoutExtension;
+    if (extension !== `.${importExtension}`) {
+      return `${specifierWithoutExtension}.${importExtension}`;
+    }
+  }
+  return moduleSpecifier;
+}
+
+function fileTypeByLocation(fieldLocation) {
+  switch (fieldLocation) {
+    case 'inputObjectTypes':
+      {
+        return 'input';
+      }
+    case 'outputObjectTypes':
+      {
+        return 'output';
+      }
+    case 'enumTypes':
+      {
+        return 'enum';
+      }
+  }
+  return 'object';
+}
+
+function relativePath(from, to) {
+  if (!from.startsWith('/')) {
+    from = `/${from}`;
+  }
+  if (!to.startsWith('/')) {
+    to = `/${to}`;
+  }
+  let result = getRelativePath(from, to);
+  if (!result.startsWith('.')) {
+    result = `./${result}`;
+  }
+  return result;
+}
+
+function getGraphqlImport(args) {
+  const {
+    config,
+    fileType,
+    getSourceFile,
+    isId,
+    location,
+    noTypeId,
+    sourceFile,
+    typeName
+  } = args;
+  const {
+    graphqlScalars,
+    importExtension
+  } = config;
+  if (location === 'scalar') {
+    if (isId && !noTypeId) {
+      return {
+        name: 'ID',
+        specifier: '@nestjs/graphql'
+      };
+    }
+    const graphqlType = graphqlScalars[typeName];
+    if (graphqlType) {
+      return {
+        name: graphqlType.name,
+        specifier: graphqlType.specifier
+      };
+    }
+    switch (typeName) {
+      case 'Float':
+      case 'Int':
+        {
+          return {
+            name: typeName,
+            specifier: '@nestjs/graphql'
+          };
+        }
+      case 'DateTime':
+        {
+          return {
+            name: 'Date',
+            specifier: undefined
+          };
+        }
+      case 'true':
+      case 'Boolean':
+        {
+          return {
+            name: 'Boolean',
+            specifier: undefined
+          };
+        }
+      case 'Decimal':
+        {
+          return {
+            name: 'GraphQLDecimal',
+            specifier: 'prisma-graphql-type-decimal'
+          };
+        }
+      case 'Json':
+        {
+          return {
+            name: 'GraphQLJSON',
+            specifier: 'graphql-type-json'
+          };
+        }
+    }
+    return {
+      name: 'String',
+      specifier: undefined
+    };
+  }
+  let sourceFileType = fileTypeByLocation(location);
+  if (sourceFileType === 'output' && fileType === 'model') {
+    sourceFileType = 'model';
+  }
+  const specifier = adjustModuleSpecifier(relativePath(sourceFile.getFilePath(), getSourceFile({
+    name: typeName,
+    type: sourceFileType
+  }).getFilePath()), importExtension);
+  return {
+    name: typeName,
+    specifier
+  };
+}
+
+/**
+ * Find input type for graphql field decorator.
+ */
+function getGraphqlInputType(inputTypes, pattern) {
+  let result;
+  inputTypes = inputTypes.filter(t => !['null', 'Null'].includes(String(t.type)));
+  inputTypes = uniqWith(inputTypes, isEqual);
+  if (inputTypes.length === 1) {
+    return inputTypes[0];
+  }
+  const countTypes = countBy(inputTypes, x => x.location);
+  const isOneType = Object.keys(countTypes).length === 1;
+  if (isOneType) {
+    result = inputTypes.find(x => x.isList);
+    if (result) {
+      return result;
+    }
+  }
+  if (pattern) {
+    if (pattern.startsWith('matcher:') || pattern.startsWith('match:')) {
+      const {
+        1: patternValue
+      } = pattern.split(':', 2);
+      const isMatch = outmatch(patternValue, {
+        separator: false
+      });
+      result = inputTypes.find(x => isMatch(String(x.type)));
+      if (result) {
+        return result;
+      }
+    }
+    result = inputTypes.find(x => String(x.type).includes(pattern));
+    if (result) {
+      return result;
+    }
+  }
+  result = inputTypes.find(x => x.location === 'inputObjectTypes');
+  if (result) {
+    return result;
+  }
+  if (countTypes.enumTypes && countTypes.scalar && inputTypes.some(x => x.type === 'Json' && x.location === 'scalar')) {
+    result = inputTypes.find(x => x.type === 'Json' && x.location === 'scalar');
+    if (result) {
+      return result;
+    }
+  }
+  if ((countTypes.scalar >= 1 || countTypes.enumTypes >= 1) && countTypes.fieldRefTypes === 1) {
+    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');
+    if (result) {
+      return result;
+    }
+  }
+  throw new TypeError(`Cannot get matching input type from ${inputTypes.map(x => x.type).join(', ') || 'zero length inputTypes'}`);
+}
+
+/**
+ * Returns typescript property type.
+ */
+function getPropertyType(args) {
+  const {
+    location,
+    type
+  } = args;
+  switch (type) {
+    case 'Float':
+    case 'Int':
+      {
+        return ['number'];
+      }
+    case 'String':
+      {
+        return ['string'];
+      }
+    case 'Boolean':
+      {
+        return ['boolean'];
+      }
+    case 'DateTime':
+      {
+        return ['Date', 'string'];
+      }
+    case 'Decimal':
+      {
+        return ['Decimal']; // TODO: Use Prisma.Decimal
+      }
+    case 'Json':
+      {
+        return ['any'];
+      }
+    case 'Null':
+      {
+        return ['null'];
+      }
+    case 'Bytes':
+      {
+        return ['Prisma.Bytes'];
+      }
+    case 'BigInt':
+      {
+        return ['bigint', 'number'];
+      }
+  }
+  if (['inputObjectTypes', 'outputObjectTypes'].includes(location)) {
+    return [type];
+  }
+  if (location === 'enumTypes') {
+    const enumType = '`${' + type + '}`';
+    return [enumType];
+  }
+  if (location === 'scalar') {
+    return [type];
+  }
+  return ['unknown'];
+}
+
+function getWhereUniqueAtLeastKeys(model) {
+  const names = model.fields.filter(field => field.isUnique || field.isId).map(field => field.name);
+  if (model.primaryKey) {
+    names.push(createFieldName(model.primaryKey));
+  }
+  for (const uniqueIndex of model.uniqueIndexes) {
+    names.push(createFieldName(uniqueIndex));
+  }
+  return names;
+}
+function createFieldName(args) {
+  const {
+    fields,
+    name
+  } = args;
+  return name || fields.join('_');
+}
+
+function isWhereUniqueInputType(name) {
+  return name.endsWith('WhereUniqueInput');
+}
+
+/**
+ * Get property structure (field) for class.
+ */
+function propertyStructure(args) {
+  const {
+    hasExclamationToken,
+    hasQuestionToken,
+    isList,
+    isNullable,
+    location,
+    name,
+    propertyType
+  } = args;
+  const type = createProperyType({
+    isList,
+    location,
+    propertyType
+  });
+  return {
+    decorators: [],
+    hasExclamationToken: hasExclamationToken ?? !isNullable,
+    hasQuestionToken: hasQuestionToken ?? isNullable,
+    kind: StructureKind.Property,
+    leadingTrivia: '\n',
+    name,
+    type
+  };
+}
+function createProperyType(args) {
+  const {
+    isList,
+    location,
+    propertyType
+  } = args;
+  return propertyType.map(type => {
+    if (isList) return `Array<${type}>`;
+    if (type.startsWith('Prisma.')) return type;
+    if (type === 'null') return type;
+    if (['inputObjectTypes', 'outputObjectTypes'].includes(location)) {
+      return `Identity<${type}>`;
+    }
+    return type;
+  }).join(' | ');
+}
+
+function inputType(args) {
+  const {
+    classDecoratorName,
+    classTransformerTypeModels,
+    config,
+    eventEmitter,
+    fieldSettings,
+    fileType,
+    getModelName,
+    getSourceFile,
+    inputType,
+    models,
+    removeTypes,
+    typeNames
+  } = args;
+  typeNames.add(inputType.name);
+  const importDeclarations = new ImportDeclarationMap();
+  const sourceFile = getSourceFile({
+    name: inputType.name,
+    type: fileType
+  });
+  const classStructure = {
+    decorators: [{
+      arguments: [],
+      name: classDecoratorName
+    }],
+    isExported: true,
+    kind: StructureKind.Class,
+    name: inputType.name,
+    properties: []
+  };
+  const modelName = getModelName(inputType.name) || '';
+  const model = models.get(modelName);
+  const modelFieldSettings = model && fieldSettings.get(model.name);
+  const moduleSpecifier = '@nestjs/graphql';
+  importDeclarations.set('Field', {
+    moduleSpecifier,
+    namedImports: [{
+      name: 'Field'
+    }]
+  }).set(classDecoratorName, {
+    moduleSpecifier,
+    namedImports: [{
+      name: classDecoratorName
+    }]
+  });
+  const useInputType = config.useInputType.find(x => inputType.name.includes(x.typeName));
+  const isWhereUnique = isWhereUniqueInputType(inputType.name);
+
+  // if (inputType.name.includes('DecimalNullableFilter')) {
+  //   console.log({ importDeclarations, location, property, propertyType });
+  // }
+
+  for (const field of inputType.fields) {
+    field.inputTypes = field.inputTypes.filter(t => !removeTypes.has(String(t.type)));
+    eventEmitter.emitSync(BeforeGenerateField, field, args);
+    const {
+      inputTypes,
+      isRequired,
+      name
+    } = field;
+    if (inputTypes.length === 0) {
+      // No types
+      continue;
+    }
+    const usePattern = useInputType?.ALL || 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({
+      input: true,
+      name: inputType.name
+    });
+    const modelField = model?.fields.find(f => f.name === name);
+    const isCustomsApplicable = typeName === modelField?.type;
+    const atLeastKeys = model && getWhereUniqueAtLeastKeys(model);
+    const whereUniqueInputType = isWhereUniqueInputType(typeName) && atLeastKeys && `Prisma.AtLeast<${typeName}, ${atLeastKeys.map(name => `'${name}'`).join(' | ')}>`;
+    const propertyType = castArray(propertySettings?.name || whereUniqueInputType || getPropertyType({
+      location,
+      type: typeName
+    }));
+    const hasExclamationToken = Boolean(isWhereUnique && config.unsafeCompatibleWhereUniqueInput && atLeastKeys?.includes(name));
+    const property = propertyStructure({
+      hasExclamationToken: hasExclamationToken || undefined,
+      hasQuestionToken: hasExclamationToken ? false : undefined,
+      isList,
+      isNullable: !isRequired,
+      location,
+      name,
+      propertyType
+    });
+    classStructure.properties.push(property);
+    importDeclarations.create({
+      config,
+      propertySettings,
+      propertyType: property.type
+    });
+
+    // Get graphql type
+    let graphqlType;
+    const shouldHideField = settings?.shouldHideField({
+      input: true,
+      name: inputType.name
+    }) || config.decorate.some(d => d.name === 'HideField' && d.from === moduleSpecifier && d.isMatchField(name) && d.isMatchType(inputType.name));
+    const fieldType = settings?.getFieldType({
+      input: true,
+      name: inputType.name
+    });
+    if (fieldType && isCustomsApplicable && !shouldHideField) {
+      graphqlType = fieldType.name;
+      importDeclarations.createFrom({
+        ...fieldType
+      });
+    } else {
+      // Import property type class
+      const graphqlImport = getGraphqlImport({
+        config,
+        getSourceFile,
+        location,
+        sourceFile,
+        typeName
+      });
+      graphqlType = graphqlImport.name;
+      let referenceName = propertyType[0];
+      if (location === 'enumTypes') {
+        referenceName = last(referenceName.split(' '));
+      }
+      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && graphqlImport.name !== inputType.name
+      // ((graphqlImport.name !== inputType.name && !shouldHideField) ||
+      //     (shouldHideField && referenceName === graphqlImport.name))
+      ) {
+        importDeclarations.set(graphqlImport.name, {
+          moduleSpecifier: graphqlImport.specifier,
+          namedImports: [{
+            name: graphqlImport.name
+          }]
+        });
+      }
+    }
+    ok$1(property.decorators, 'property.decorators is undefined');
+    if (shouldHideField) {
+      importDeclarations.add('HideField', moduleSpecifier);
+      property.decorators.push({
+        arguments: [],
+        name: 'HideField'
+      });
+    } else {
+      // Generate `@Field()` decorator
+      property.decorators.push({
+        arguments: [isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`, JSON5.stringify({
+          ...settings?.fieldArguments(),
+          nullable: !isRequired
+        })],
+        name: 'Field'
+      });
+      if (graphqlType === 'GraphQLDecimal') {
+        importDeclarations.add('transformToDecimal', 'prisma-graphql-type-decimal');
+        importDeclarations.add('Transform', 'class-transformer');
+        importDeclarations.add('Type', 'class-transformer');
+        property.decorators.push({
+          arguments: ['() => Object'],
+          name: 'Type'
+        }, {
+          arguments: ['transformToDecimal'],
+          name: 'Transform'
+        });
+      } else if (location === 'inputObjectTypes' && (modelField?.type === 'Decimal' || ['connect', 'connectOrCreate', 'create', 'createMany', 'data', 'delete', 'deleteMany', 'disconnect', 'set', 'update', 'updateMany', 'upsert', 'where'].includes(name) || classTransformerTypeModels.has(getModelName(graphqlType) || '') || modelField?.kind === 'object' && models.get(modelField.type) && models.get(modelField.type)?.fields.some(field => field.kind === 'object' && classTransformerTypeModels.has(field.type)))) {
+        importDeclarations.add('Type', 'class-transformer');
+        property.decorators.push({
+          arguments: [`() => ${graphqlType}`],
+          name: 'Type'
+        });
+      }
+      if (isCustomsApplicable) {
+        for (const options of settings || []) {
+          if ((options.kind === 'Decorator' && options.input && options.match?.(name)) ?? true) {
+            property.decorators.push({
+              arguments: options.arguments,
+              name: options.name
+            });
+            ok$1(options.from, "Missed 'from' part in configuration or field setting");
+            importDeclarations.createFrom(options);
+          }
+        }
+      }
+      for (const decorate of config.decorate) {
+        if (decorate.isMatchField(name) && decorate.isMatchType(inputType.name)) {
+          property.decorators.push({
+            arguments: decorate.arguments?.map(x => pupa(x, {
+              propertyType
+            })),
+            name: decorate.name
+          });
+          importDeclarations.createFrom(decorate);
+        }
+      }
+    }
+    eventEmitter.emitSync('ClassProperty', property, {
+      isList,
+      location,
+      propertyType
+    });
+  }
+  sourceFile.set({
+    statements: [...importDeclarations.toStatements(), classStructure]
+  });
+}
+
+class ObjectSettings extends Array {
+  shouldHideField({
+    input = false,
+    name,
+    output = false
+  }) {
+    const hideField = this.find(s => s.name === 'HideField');
+    return Boolean(hideField?.input && input || hideField?.output && output || hideField?.match?.(name));
+  }
+  getFieldType({
+    input,
+    name,
+    output
+  }) {
+    const fieldType = this.find(s => s.kind === 'FieldType');
+    if (!fieldType) {
+      return undefined;
+    }
+    if (fieldType.match) {
+      return fieldType.match(name) ? fieldType : undefined;
+    }
+    if (input && !fieldType.input) {
+      return undefined;
+    }
+    if (output && !fieldType.output) {
+      return undefined;
+    }
+    return fieldType;
+  }
+  getPropertyType({
+    input,
+    name,
+    output
+  }) {
+    const propertyType = this.find(s => s.kind === 'PropertyType');
+    if (!propertyType) {
+      return undefined;
+    }
+    if (propertyType.match) {
+      return propertyType.match(name) ? propertyType : undefined;
+    }
+    if (input && !propertyType.input) {
+      return undefined;
+    }
+    if (output && !propertyType.output) {
+      return undefined;
+    }
+    return propertyType;
+  }
+  getObjectTypeArguments(options) {
+    const objectTypeOptions = merge({}, options);
+    const resultArguments = [objectTypeOptions];
+    const objectType = this.find(s => s.kind === 'ObjectType');
+    if (objectType && isObject(objectType.arguments)) {
+      const name = objectType.arguments.name;
+      merge(objectTypeOptions, omit(objectType.arguments, 'name'));
+      if (name) {
+        resultArguments.unshift(name);
+      }
+    }
+    return resultArguments.map(x => JSON5.stringify(x));
+  }
+  fieldArguments() {
+    const item = this.find(item => item.kind === 'Field');
+    if (item) {
+      return item.arguments;
+    }
+  }
+}
+function createObjectSettings(args) {
+  const {
+    config,
+    text
+  } = args;
+  const result = new ObjectSettings();
+  const textLines = text.split('\n');
+  const documentationLines = [];
+  let fieldElement = result.find(item => item.kind === 'Field');
+  if (!fieldElement) {
+    fieldElement = {
+      arguments: {},
+      kind: 'Field',
+      name: ''
+    };
+  }
+  for (const line of textLines) {
+    const match = /^@(?<name>\w+(\.(\w+))?)\((?<args>.*)\)/.exec(line);
+    const {
+      documentLine,
+      element
+    } = createSettingElement({
+      config,
+      fieldElement,
+      line,
+      match
+    });
+    if (element) {
+      result.push(element);
+    }
+    if (documentLine) {
+      documentationLines.push(line);
+    }
+  }
+  return {
+    documentation: documentationLines.filter(Boolean).join('\n') || undefined,
+    settings: result
+  };
+}
+function createSettingElement({
+  config,
+  fieldElement,
+  line,
+  match
+}) {
+  const result = {
+    documentLine: '',
+    element: undefined
+  };
+  if (line.startsWith('@deprecated')) {
+    fieldElement.arguments['deprecationReason'] = trim(line.slice(11));
+    result.element = fieldElement;
+    return result;
+  }
+  if (line.startsWith('@complexity')) {
+    let n = Number.parseInt(trim(line.slice(11)));
+    if (n !== n || n < 1) n = 1;
+    fieldElement.arguments['complexity'] = n;
+    result.element = fieldElement;
+    return result;
+  }
+  const name = match?.groups?.name;
+  if (!(match && name)) {
+    result.documentLine = line;
+    return result;
+  }
+  const element = {
+    arguments: [],
+    from: '',
+    input: false,
+    kind: 'Decorator',
+    model: false,
+    name: '',
+    output: false
+  };
+  result.element = element;
+  if (name === 'TypeGraphQL.omit' || name === 'HideField') {
+    Object.assign(element, hideFieldDecorator(match));
+    return result;
+  }
+  if (['FieldType', 'PropertyType'].includes(name) && match.groups?.args) {
+    const options = customType(match.groups.args);
+    merge(element, options.namespace && config.fields[options.namespace], options, {
+      kind: name
+    });
+    return result;
+  }
+  if (name === 'ObjectType' && match.groups?.args) {
+    element.kind = 'ObjectType';
+    const options = customType(match.groups.args);
+    if (typeof options[0] === 'string' && options[0]) {
+      options.name = options[0];
+    }
+    if (isObject(options[1])) {
+      merge(options, options[1]);
+    }
+    element.arguments = {
+      isAbstract: options.isAbstract,
+      name: options.name
+    };
+    return result;
+  }
+  if (name === 'Directive' && match.groups?.args) {
+    const options = customType(match.groups.args);
+    merge(element, {
+      from: '@nestjs/graphql',
+      model: true
+    }, options, {
+      arguments: Array.isArray(options.arguments) ? options.arguments.map(s => JSON5.stringify(s)) : options.arguments,
+      kind: 'Decorator',
+      name,
+      namespace: false
+    });
+    return result;
+  }
+  const namespace = getNamespace(name);
+  element.namespaceImport = namespace;
+  const options = {
+    arguments: (match.groups?.args || '').split(',').map(s => trim(s)).filter(Boolean),
+    name
+  };
+  merge(element, namespace && config.fields[namespace], options);
+  return result;
+}
+function customType(args) {
+  const result = {};
+  let options = parseArgs(args);
+  if (typeof options === 'string') {
+    options = {
+      name: options
+    };
+  }
+  Object.assign(result, options);
+  const namespace = getNamespace(options.name);
+  result.namespace = namespace;
+  if (options.name?.includes('.')) {
+    result.namespaceImport = namespace;
+  }
+  if (typeof options.match === 'string' || Array.isArray(options.match)) {
+    result.match = outmatch(options.match, {
+      separator: false
+    });
+  }
+  return result;
+}
+function hideFieldDecorator(match) {
+  const result = {
+    arguments: [],
+    defaultImport: undefined,
+    from: '@nestjs/graphql',
+    match: undefined,
+    name: 'HideField',
+    namespaceImport: undefined
+  };
+  if (!match.groups?.args) {
+    result.output = true;
+    return result;
+  }
+  if (match.groups.args.includes('{') && match.groups.args.includes('}')) {
+    const options = parseArgs(match.groups.args);
+    result.output = Boolean(options.output);
+    result.input = Boolean(options.input);
+    if (typeof options.match === 'string' || Array.isArray(options.match)) {
+      result.match = outmatch(options.match, {
+        separator: false
+      });
+    }
+  } else {
+    if (/output:\s*true/.test(match.groups.args)) {
+      result.output = true;
+    }
+    if (/input:\s*true/.test(match.groups.args)) {
+      result.input = true;
+    }
+  }
+  return result;
+}
+function parseArgs(string) {
+  try {
+    return JSON5.parse(string);
+  } catch {
+    try {
+      return JSON5.parse(`[${string}]`);
+    } catch {
+      throw new Error(`Failed to parse: ${string}`);
+    }
+  }
+}
+function getNamespace(name) {
+  if (name === undefined) {
+    return undefined;
+  }
+  let result = String(name);
+  if (result.includes('.')) {
+    [result] = result.split('.');
+  }
+  return result;
+}
+
+function modelData(model, args) {
+  const {
+    classTransformerTypeModels,
+    config,
+    fieldSettings,
+    modelFields,
+    modelNames,
+    models
+  } = args;
+  modelNames.push(model.name);
+  models.set(model.name, model);
+  const modelFieldsValue = new Map();
+  modelFields.set(model.name, modelFieldsValue);
+  const fieldSettingsValue = new Map();
+  fieldSettings.set(model.name, fieldSettingsValue);
+  for (const field of model.fields) {
+    if (field.documentation) {
+      const {
+        documentation,
+        settings
+      } = createObjectSettings({
+        config,
+        text: field.documentation
+      });
+      field.documentation = documentation;
+      fieldSettingsValue.set(field.name, settings);
+    }
+    modelFieldsValue.set(field.name, field);
+  }
+  if (model.fields.some(field => field.type === 'Decimal')) {
+    classTransformerTypeModels.add(model.name);
+  }
+}
+
+function createComment(documentation, settings) {
+  const documentationLines = documentation.split('\n');
+  const commentLines = ['/**'];
+  for (const line of documentationLines) {
+    commentLines.push(` * ${line}`);
+  }
+  const deprecationReason = settings?.fieldArguments()?.deprecationReason;
+  if (deprecationReason) {
+    commentLines.push(` * @deprecated ${deprecationReason}`);
+  }
+  commentLines.push(' */\n');
+  return commentLines.join('\n');
+}
+
+function getOutputTypeName(name) {
+  return name.replace(/(?:OutputType|Output)$/, '');
+}
+
+const nestjsGraphql$1 = '@nestjs/graphql';
+function modelOutputType(outputType, args) {
+  const {
+    config,
+    eventEmitter,
+    fieldSettings,
+    getSourceFile,
+    modelFields,
+    models
+  } = args;
+  if (isManyAndReturnOutputType(outputType.name)) return;
+  const model = models.get(outputType.name);
+  ok$1(model, `Cannot find model by name ${outputType.name}`);
+  const sourceFile = getSourceFile({
+    name: outputType.name,
+    type: 'model'
+  });
+  const sourceFileStructure = sourceFile.getStructure();
+  const exportDeclaration = getExportDeclaration$1(model.name, sourceFileStructure.statements);
+  const importDeclarations = new ImportDeclarationMap();
+  const classStructure = {
+    decorators: [{
+      arguments: [],
+      name: 'ObjectType'
+    }],
+    isExported: true,
+    kind: StructureKind.Class,
+    name: outputType.name,
+    properties: []
+  };
+  sourceFileStructure.statements.push(classStructure);
+  ok$1(classStructure.decorators, 'classStructure.decorators is undefined');
+  const decorator = classStructure.decorators.find(d => d.name === 'ObjectType');
+  ok$1(decorator, 'ObjectType decorator not found');
+  let modelSettings;
+  // Get model settings from documentation
+  if (model.documentation) {
+    const objectTypeOptions = {};
+    const {
+      documentation,
+      settings
+    } = createObjectSettings({
+      config,
+      text: model.documentation
+    });
+    if (documentation) {
+      if (!classStructure.leadingTrivia) {
+        classStructure.leadingTrivia = createComment(documentation);
+      }
+      objectTypeOptions.description = documentation;
+    }
+    decorator.arguments = settings.getObjectTypeArguments(objectTypeOptions);
+    modelSettings = settings;
+  }
+  importDeclarations.add('Field', nestjsGraphql$1);
+  importDeclarations.add('ObjectType', nestjsGraphql$1);
+  for (const field of outputType.fields) {
+    if (config.omitModelsCount && field.name === '_count') continue;
+    let fileType = 'model';
+    const {
+      isList,
+      location,
+      namespace,
+      type
+    } = field.outputType;
+    let outputTypeName = String(type);
+    if (namespace !== 'model') {
+      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: outputType.name,
+      output: true
+    });
+    const propertySettings = settings?.getPropertyType({
+      name: outputType.name,
+      output: true
+    });
+    const propertyType = castArray(propertySettings?.name || getPropertyType({
+      location,
+      type: outputTypeName
+    }));
+
+    // For model we keep only one type
+    propertyType.splice(1);
+    if (field.isNullable && !isList) {
+      propertyType.push('null');
+    }
+    let graphqlType;
+    if (fieldType) {
+      graphqlType = fieldType.name;
+      importDeclarations.createFrom({
+        ...fieldType
+      });
+    } else {
+      const graphqlImport = getGraphqlImport({
+        config,
+        fileType,
+        getSourceFile,
+        isId: modelField?.isId,
+        location,
+        noTypeId: config.noTypeId,
+        sourceFile,
+        typeName: outputTypeName
+      });
+      graphqlType = graphqlImport.name;
+      if (graphqlImport.name !== outputType.name && graphqlImport.specifier) {
+        importDeclarations.add(graphqlImport.name, graphqlImport.specifier);
+      }
+    }
+    const property = propertyStructure({
+      hasExclamationToken: true,
+      hasQuestionToken: location === 'outputObjectTypes',
+      isList,
+      isNullable: field.isNullable,
+      location,
+      name: field.name,
+      propertyType
+    });
+    if (typeof property.leadingTrivia === 'string' && modelField?.documentation) {
+      property.leadingTrivia += createComment(modelField.documentation, settings);
+    }
+    classStructure.properties?.push(property);
+    importDeclarations.create({
+      config,
+      propertySettings,
+      propertyType: property.type
+    });
+    ok$1(property.decorators, 'property.decorators is undefined');
+    const shouldHideField = 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$1);
+      property.decorators.push({
+        arguments: [],
+        name: 'HideField'
+      });
+    } else {
+      // Generate `@Field()` decorator
+      property.decorators.push({
+        arguments: [isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`, JSON5.stringify({
+          ...settings?.fieldArguments(),
+          defaultValue: ['number', 'string', 'boolean'].includes(typeof modelField?.default) ? modelField?.default : undefined,
+          description: modelField?.documentation,
+          nullable: Boolean(field.isNullable)
+        })],
+        name: 'Field'
+      });
+      for (const setting of settings || []) {
+        if (shouldBeDecorated(setting) && (setting.match?.(field.name) ?? true)) {
+          property.decorators.push({
+            arguments: setting.arguments,
+            name: setting.name
+          });
+          ok$1(setting.from, "Missed 'from' part in configuration or field setting");
+          importDeclarations.createFrom(setting);
+        }
+      }
+      for (const decorate of config.decorate) {
+        if (decorate.isMatchField(field.name) && decorate.isMatchType(outputTypeName)) {
+          property.decorators.push({
+            arguments: decorate.arguments?.map(x => pupa(x, {
+              propertyType
+            })),
+            name: decorate.name
+          });
+          importDeclarations.createFrom(decorate);
+        }
+      }
+    }
+    eventEmitter.emitSync('ClassProperty', property, {
+      isList,
+      location,
+      propertyType
+    });
+  }
+
+  // Generate class decorators from model settings
+  for (const setting of modelSettings || []) {
+    if (shouldBeDecorated(setting)) {
+      classStructure.decorators.push({
+        arguments: setting.arguments,
+        name: setting.name
+      });
+      importDeclarations.createFrom(setting);
+    }
+  }
+  if (exportDeclaration) {
+    sourceFile.set({
+      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]);
+  } else {
+    sourceFile.set({
+      statements: [...importDeclarations.toStatements(), classStructure]
+    });
+  }
+}
+function shouldBeDecorated(setting) {
+  return setting.kind === 'Decorator' && (setting.output || setting.model) && !(setting.output && setting.model);
+}
+function getExportDeclaration$1(name, statements) {
+  return statements.find(structure => {
+    return structure.kind === StructureKind.ExportDeclaration && structure.namedExports.some(o => (o.alias || o.name) === name);
+  });
+}
+
+function noAtomicOperations(eventEmitter) {
+  eventEmitter.on('BeforeInputType', beforeInputType$1);
+  eventEmitter.on('BeforeGenerateFiles', beforeGenerateFiles$1);
+}
+function beforeInputType$1(args) {
+  const {
+    getModelName,
+    inputType
+  } = args;
+  for (const field of inputType.fields) {
+    const fieldName = field.name;
+    field.inputTypes = field.inputTypes.filter(inputType => {
+      const inputTypeName = String(inputType.type);
+      const modelName = getModelName(inputTypeName);
+      if (isAtomicOperation(inputTypeName) || modelName && isListInput(inputTypeName, modelName, fieldName)) {
+        return false;
+      }
+      return true;
+    });
+  }
+}
+function beforeGenerateFiles$1(args) {
+  const {
+    project
+  } = args;
+  for (const sourceFile of project.getSourceFiles()) {
+    const className = sourceFile.getClass(() => true)?.getName();
+    if (className && isAtomicOperation(className)) {
+      project.removeSourceFile(sourceFile);
+    }
+  }
+}
+function isAtomicOperation(typeName) {
+  if (typeName.endsWith('FieldUpdateOperationsInput')) {
+    return true;
+  }
+  return false;
+}
+function isListInput(typeName, model, field) {
+  return typeName === `${model}Create${field}Input` || typeName === `${model}Update${field}Input`;
+}
+
+function getEnumName(referenceName) {
+  // `${Role}`
+  return referenceName.slice(3, -2);
+}
+
+const nestjsGraphql = '@nestjs/graphql';
+function outputType(outputType, args) {
+  const {
+    config,
+    eventEmitter,
+    fieldSettings,
+    getModelName,
+    getSourceFile,
+    models
+  } = args;
+  const importDeclarations = new ImportDeclarationMap();
+  const fileType = 'output';
+  const modelName = getModelName(outputType.name) || '';
+  const model = models.get(modelName);
+  const isAggregateOutput = model && /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(outputType.name) && String(outputType.name).startsWith(model.name);
+  const isCountOutput = model?.name && outputType.name === `${model.name}CountOutputType`;
+  if (!config.emitBlocks.outputs && !isCountOutput) return;
+
+  // Get rid of bogus suffixes
+  outputType.name = getOutputTypeName(outputType.name);
+  if (isAggregateOutput) {
+    eventEmitter.emitSync('AggregateOutput', {
+      ...args,
+      outputType
+    });
+  }
+  const sourceFile = getSourceFile({
+    name: outputType.name,
+    type: fileType
+  });
+  const classStructure = {
+    decorators: [{
+      arguments: [],
+      name: 'ObjectType'
+    }],
+    isExported: true,
+    kind: StructureKind.Class,
+    name: outputType.name,
+    properties: []
+  };
+  importDeclarations.add('Field', nestjsGraphql);
+  importDeclarations.add('ObjectType', nestjsGraphql);
+  for (const field of outputType.fields) {
+    const {
+      isList,
+      location,
+      type
+    } = field.outputType;
+    const outputTypeName = getOutputTypeName(String(type));
+    const settings = isCountOutput ? undefined : model && fieldSettings.get(model.name)?.get(field.name);
+    const propertySettings = settings?.getPropertyType({
+      name: outputType.name,
+      output: true
+    });
+    const isCustomsApplicable = outputTypeName === model?.fields.find(f => f.name === field.name)?.type;
+    field.outputType.type = outputTypeName;
+    const propertyType = castArray(propertySettings?.name || getPropertyType({
+      location,
+      type: outputTypeName
+    }));
+    const property = propertyStructure({
+      hasQuestionToken: isCountOutput ? true : undefined,
+      isList,
+      isNullable: field.isNullable,
+      location,
+      name: field.name,
+      propertyType
+    });
+    classStructure.properties?.push(property);
+    importDeclarations.create({
+      config,
+      propertySettings,
+      propertyType: property.type
+    });
+
+    // Get graphql type
+    let graphqlType;
+    const shouldHideField = 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));
+    const fieldType = settings?.getFieldType({
+      name: outputType.name,
+      output: true
+    });
+    if (fieldType && isCustomsApplicable && !shouldHideField) {
+      graphqlType = fieldType.name;
+      importDeclarations.createFrom({
+        ...fieldType
+      });
+    } else {
+      const graphqlImport = getGraphqlImport({
+        config,
+        fileType,
+        getSourceFile,
+        isId: false,
+        location,
+        sourceFile,
+        typeName: outputTypeName
+      });
+      const referenceName = location === 'enumTypes' ? getEnumName(propertyType[0]) : propertyType[0];
+      graphqlType = graphqlImport.name;
+      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputType.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
+        importDeclarations.set(graphqlImport.name, {
+          moduleSpecifier: graphqlImport.specifier,
+          namedImports: [{
+            name: graphqlImport.name
+          }]
+        });
+      }
+    }
+    ok$1(property.decorators, 'property.decorators is undefined');
+    if (shouldHideField) {
+      importDeclarations.add('HideField', nestjsGraphql);
+      property.decorators.push({
+        arguments: [],
+        name: 'HideField'
+      });
+    } else {
+      // Generate `@Field()` decorator
+      property.decorators.push({
+        arguments: [isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`, JSON5.stringify({
+          ...settings?.fieldArguments(),
+          nullable: Boolean(field.isNullable)
+        })],
+        name: 'Field'
+      });
+      if (isCustomsApplicable) {
+        for (const options of settings || []) {
+          if ((options.kind === 'Decorator' && options.output && options.match?.(field.name)) ?? true) {
+            property.decorators.push({
+              arguments: options.arguments,
+              name: options.name
+            });
+            ok$1(options.from, "Missed 'from' part in configuration or field setting");
+            importDeclarations.createFrom(options);
+          }
+        }
+      }
+    }
+    eventEmitter.emitSync('ClassProperty', property, {
+      isList,
+      location,
+      propertyType
+    });
+  }
+  sourceFile.set({
+    statements: [...importDeclarations.toStatements(), classStructure]
+  });
+}
+
+function purgeOutput(emitter) {
+  emitter.on('Begin', begin);
+  emitter.on('End', end);
+}
+function begin({
+  output,
+  project
+}) {
+  const sourceFiles = project.getDirectory(output)?.getDescendantSourceFiles();
+  if (sourceFiles) {
+    for (const sourceFile of sourceFiles) {
+      sourceFile.delete();
+    }
+  }
+}
+function end({
+  output,
+  project
+}) {
+  const directories = project.getDirectory(output)?.getDescendantDirectories().filter(directory => directory.getSourceFiles().length === 0).map(directory => directory.getPath());
+  for (const directory of directories || []) {
+    try {
+      fs.rmdirSync(directory);
+      // eslint-disable-next-line no-empty
+    } catch {}
+  }
+}
+
+const ReExport = {
+  All: 'All',
+  Directories: 'Directories',
+  None: 'None',
+  Single: 'Single'
+};
+function reExport(emitter) {
+  emitter.on('BeforeGenerateFiles', beforeGenerateFiles);
+}
+function beforeGenerateFiles(args) {
+  const {
+    config,
+    output,
+    project
+  } = args;
+  const rootDirectory = project.getDirectoryOrThrow(output);
+  const {
+    importExtension,
+    reExport
+  } = config;
+  if ([ReExport.Directories, ReExport.All].includes(reExport)) {
+    for (const directory of rootDirectory.getDescendantDirectories()) {
+      let indexSourceFile;
+      const exportDeclarations = directory.getSourceFiles().filter(sourceFile => {
+        return sourceFile.getBaseName() !== 'index.ts';
+      }).map(sourcesFile => getExportDeclaration(directory, sourcesFile, importExtension));
+      if (exportDeclarations.length > 0) {
+        indexSourceFile = directory.createSourceFile('index.ts', {
+          statements: exportDeclarations
+        }, {
+          overwrite: true
+        });
+      }
+      if (indexSourceFile) {
+        continue;
+      }
+      const namespaceExportDeclarations = directory.getDirectories().map(sourceDirectory => getNamespaceExportDeclaration(directory, sourceDirectory, importExtension));
+      project.createSourceFile(`${directory.getPath()}/index.ts`, {
+        statements: namespaceExportDeclarations
+      }, {
+        overwrite: true
+      });
+    }
+  }
+  if (reExport === ReExport.Single) {
+    const exportDeclarations = project.getSourceFiles().filter(sourceFile => {
+      return sourceFile.getBaseName() !== 'index.ts';
+    }).map(sourceFile => getExportDeclaration(rootDirectory, sourceFile, importExtension));
+    rootDirectory.createSourceFile('index.ts', {
+      statements: exportDeclarations
+    }, {
+      overwrite: true
+    });
+  }
+  if (reExport === ReExport.All) {
+    const exportDeclarations = [];
+    for (const directory of rootDirectory.getDirectories()) {
+      if (directory.getBaseName() === 'node_modules') continue;
+      const sourceFile = directory.getSourceFileOrThrow('index.ts');
+      exportDeclarations.push(getExportDeclaration(rootDirectory, sourceFile, importExtension));
+    }
+    rootDirectory.createSourceFile('index.ts', {
+      statements: exportDeclarations
+    }, {
+      overwrite: true
+    });
+  }
+}
+function getExportDeclaration(directory, sourceFile, importExtension) {
+  const moduleSpecifier = adjustModuleSpecifier(directory.getRelativePathAsModuleSpecifierTo(sourceFile), importExtension);
+  return {
+    kind: StructureKind.ExportDeclaration,
+    moduleSpecifier,
+    namedExports: sourceFile.getExportSymbols().map(s => ({
+      name: s.getName()
+    }))
+  };
+}
+function getNamespaceExportDeclaration(directory, sourceDirectory, importExtension) {
+  const moduleSpecifier = adjustModuleSpecifier(directory.getRelativePathAsModuleSpecifierTo(sourceDirectory), importExtension);
+  return {
+    kind: StructureKind.ExportDeclaration,
+    moduleSpecifier
+  };
+}
+
+// utils/prisma-enum-doc.ts
+
+function extractEnumValueDocs(values) {
+  return Object.fromEntries(values.map(value => {
+    const {
+      name
+    } = value;
+    const documentation = value.documentation;
+    if (typeof documentation !== 'string') return null;
+    if (documentation.startsWith('@deprecated')) {
+      return [name, {
+        deprecationReason: documentation.slice(11).trim()
+      }];
+    }
+    return [name, {
+      description: documentation
+    }];
+  }).filter(entry => entry !== null));
+}
+
+function registerEnum(enumType, args) {
+  const {
+    config,
+    enums,
+    getSourceFile
+  } = args;
+  if (!config.emitBlocks.prismaEnums && !enums[enumType.name]) return;
+  const dataModelEnum = enums[enumType.name];
+  const enumTypesData = dataModelEnum?.values || [];
+  const sourceFile = getSourceFile({
+    name: enumType.name,
+    type: 'enum'
+  });
+  const importDeclarations = new ImportDeclarationMap();
+  importDeclarations.set('registerEnumType', {
+    moduleSpecifier: '@nestjs/graphql',
+    namedImports: [{
+      name: 'registerEnumType'
+    }]
+  });
+
+  // Extract valuesMap from enum documentation
+  const valuesMap = extractEnumValueDocs(enumTypesData);
+
+  // Remove entries with no description or deprecationReason
+  const filteredValuesMap = Object.fromEntries(Object.entries(valuesMap).filter(([_, v]) => Object.keys(v).length > 0));
+
+  // Format only if needed
+  const hasValuesMap = Object.keys(filteredValuesMap).length > 0;
+  const formattedValuesMap = hasValuesMap ? JSON.stringify(filteredValuesMap, null, 2).replaceAll(/"([^"]+)":/g, '$1:') : '';
+  const valuesMapEntry = hasValuesMap ? `, valuesMap: ${formattedValuesMap}` : '';
+  const enumStructure = {
+    isExported: true,
+    kind: StructureKind.Enum,
+    members: enumType.values.map(v => ({
+      initializer: JSON.stringify(v),
+      name: v
+    })),
+    name: enumType.name
+  };
+  sourceFile.set({
+    statements: [...importDeclarations.toStatements(), enumStructure, '\n', `registerEnumType(${enumType.name}, { name: '${enumType.name}', description: ${JSON.stringify(dataModelEnum?.documentation)}${valuesMapEntry} })`]
+  });
+}
+
+function requireSingleFieldsInWhereUniqueInput(eventEmitter) {
+  eventEmitter.on('BeforeInputType', beforeInputType);
+}
+function beforeInputType(args) {
+  const {
+    inputType
+  } = args;
+  if (!isWhereUniqueInputType(inputType.name) || inputType.fields.length !== 1) {
+    return;
+  }
+  for (const field of inputType.fields) {
+    field.isRequired = true;
+    field.isNullable = false;
+  }
+}
+
+function warning(message) {
+  if (Array.isArray(message)) {
+    console.log('prisma-nestjs-graphql:');
+    console.log(message.join('\n'));
+  } else {
+    console.log('prisma-nestjs-graphql:', message);
+  }
+}
+
+const allEmmittedBlocks = ['prismaEnums', 'schemaEnums', 'models', 'inputs', 'args', 'outputs'];
+const blocksDependencyMap = {
+  args: ['args', 'inputs', 'prismaEnums'],
+  enums: ['schemaEnums', 'prismaEnums'],
+  inputs: ['inputs', 'prismaEnums'],
+  models: ['models', 'schemaEnums'],
+  outputs: ['outputs']
+};
+function createEmitBlocks(data) {
+  if (!data) {
+    return Object.fromEntries(allEmmittedBlocks.map(block => [block, true]));
+  }
+  let blocksToEmit = {};
+  for (const block of data) {
+    if (!Object.keys(blocksDependencyMap).includes(block)) continue;
+    blocksToEmit = {
+      ...blocksToEmit,
+      ...Object.fromEntries(blocksDependencyMap[block].map(block => [block, true]))
+    };
+  }
+  return blocksToEmit;
+}
+
+function createConfig(data) {
+  const config = merge({}, unflatten(data, {
+    delimiter: '_'
+  }));
+  const $warnings = [];
+  const configOutputFilePattern = String(config.outputFilePattern || `{model}/{name}.{type}.ts`);
+  const outputFilePattern = configOutputFilePattern.replaceAll('\\', '/').split('/').map(path => filenamify(path, {
+    replacement: ''
+  })).filter(Boolean).join('/');
+  if (outputFilePattern !== configOutputFilePattern) {
+    $warnings.push(`Due to invalid filepath 'outputFilePattern' changed to '${outputFilePattern}'`);
+  }
+  const fields = Object.fromEntries(Object.entries(config.fields ?? {}).filter(({
+    1: value
+  }) => typeof value === 'object').map(([name, value]) => {
+    const fieldSetting = {
+      arguments: [],
+      defaultImport: toBoolean(value.defaultImport) ? true : value.defaultImport,
+      from: value.from,
+      input: toBoolean(value.input),
+      model: toBoolean(value.model),
+      namespaceImport: value.namespaceImport,
+      output: toBoolean(value.output)
+    };
+    return [name, fieldSetting];
+  }));
+  const decorate = [];
+  const configDecorate = Object.values(config.decorate || {});
+  for (const element of configDecorate) {
+    if (!element) continue;
+    ok$1(element.from && element.name, `Missed 'from' or 'name' part in configuration for decorate`);
+    decorate.push({
+      arguments: element.arguments ? JSON5.parse(element.arguments) : undefined,
+      defaultImport: toBoolean(element.defaultImport) ? true : element.defaultImport,
+      from: element.from,
+      isMatchField: outmatch(element.field, {
+        separator: false
+      }),
+      isMatchType: outmatch(element.type, {
+        separator: false
+      }),
+      name: element.name,
+      namedImport: toBoolean(element.namedImport),
+      namespaceImport: element.namespaceImport
+    });
+  }
+  const customImport = [];
+  const configCustomImport = Object.values(config.customImport || {});
+  for (const element of configCustomImport) {
+    if (!element) continue;
+    ok$1(element.from && element.name, `Missed 'from' or 'name' part in configuration for customImport`);
+    customImport.push({
+      defaultImport: toBoolean(element.defaultImport) ? true : element.defaultImport,
+      from: element.from,
+      name: element.name,
+      namedImport: toBoolean(element.namedImport),
+      namespaceImport: element.namespaceImport
+    });
+  }
+  return {
+    $warnings,
+    combineScalarFilters: toBoolean(config.combineScalarFilters),
+    customImport,
+    decorate,
+    emitBlocks: createEmitBlocks(config.emitBlocks),
+    emitCompiled: toBoolean(config.emitCompiled),
+    emitSingle: toBoolean(config.emitSingle),
+    fields,
+    graphqlScalars: config.graphqlScalars || {},
+    importExtension: String(config.importExtension ?? ''),
+    noAtomicOperations: toBoolean(config.noAtomicOperations),
+    noTypeId: toBoolean(config.noTypeId),
+    omitModelsCount: toBoolean(config.omitModelsCount),
+    outputFilePattern,
+    prismaClientImport: createPrismaImport(config.prismaClientImport),
+    purgeOutput: toBoolean(config.purgeOutput),
+    reExport: ReExport[String(config.reExport)] || ReExport.None,
+    requireSingleFieldsInWhereUniqueInput: toBoolean(config.requireSingleFieldsInWhereUniqueInput),
+    tsConfigFilePath: createTsConfigFilePathValue(config.tsConfigFilePath),
+    unsafeCompatibleWhereUniqueInput: toBoolean(config.unsafeCompatibleWhereUniqueInput),
+    useInputType: createUseInputType(config.useInputType)
+  };
+}
+const tsConfigFileExists = memoize(filePath => {
+  return fs.existsSync(filePath);
+});
+function createTsConfigFilePathValue(value) {
+  if (typeof value === 'string') return value;
+  if (tsConfigFileExists('tsconfig.json')) return 'tsconfig.json';
+}
+function createPrismaImport(value) {
+  if (typeof value === 'string') return value;
+  return '@prisma/client';
+}
+function createUseInputType(data) {
+  if (!data) {
+    return [];
+  }
+  const result = [];
+  for (const [typeName, useInputs] of Object.entries(data)) {
+    const entry = {
+      ALL: undefined,
+      typeName
+    };
+    if (useInputs.ALL) {
+      entry.ALL = useInputs.ALL;
+      delete useInputs.ALL;
+    }
+    for (const [propertyName, pattern] of Object.entries(useInputs)) {
+      entry[propertyName] = pattern;
+    }
+    result.push(entry);
+  }
+  return result;
+}
+function toBoolean(value) {
+  return ['true', '1', 'on'].includes(String(value));
+}
+
+function generateFileName(args) {
+  const {
+    getModelName,
+    name,
+    template,
+    type
+  } = args;
+  return pupa(template, {
+    get model() {
+      const result = getModelName(name) || 'prisma';
+      return kebabCase(result);
+    },
+    get name() {
+      let result = kebabCase(name);
+      for (const suffix of ['input', 'args', 'enum']) {
+        const ending = `-${suffix}`;
+        if (type === suffix && result.endsWith(ending)) {
+          result = result.slice(0, -ending.length);
+        }
+      }
+      return result;
+    },
+    plural: {
+      get type() {
+        return pluralize(type);
+      }
+    },
+    type
+  });
+}
+
+function factoryGetSourceFile(args) {
+  const {
+    getModelName,
+    output,
+    outputFilePattern,
+    project
+  } = args;
+  return function getSourceFile(args) {
+    const {
+      name,
+      type
+    } = args;
+    let filePath = generateFileName({
+      getModelName,
+      name,
+      template: outputFilePattern,
+      type
+    });
+    filePath = `${output}/${filePath}`;
+    return project.getSourceFile(filePath) || project.createSourceFile(filePath, undefined, {
+      overwrite: true
+    });
+  };
+}
+
+function createGetModelName(modelNames) {
+  return memoize(tryGetName);
+  function tryGetName(name) {
+    return getModelName({
+      modelNames,
+      name
+    });
+  }
+}
+function getModelName(args) {
+  const {
+    modelNames,
+    name
+  } = args;
+  for (const keyword of splitKeywords) {
+    const [test] = name.split(keyword, 1);
+    if (modelNames.includes(test)) {
+      return test;
+    }
+  }
+  for (const keyword of endsWithKeywords) {
+    const [test] = name.split(keyword).slice(-1);
+    if (modelNames.includes(test)) {
+      return test;
+    }
+  }
+  for (const [start, end] of middleKeywords) {
+    let test = name.slice(start.length).slice(0, -end.length);
+    if (modelNames.includes(test) && name.startsWith(start) && name.endsWith(end)) {
+      return test;
+    }
+    test = name.slice(0, -(start + end).length);
+    if (modelNames.includes(test) && name.endsWith(start + end)) {
+      return test;
+    }
+  }
+
+  // test for {Model}{UniqueName}CompoundUniqueInput
+  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 first(models);
+  }
+
+  // test for {Model}Count
+  if (name.slice(-5) === 'Count') {
+    const test = name.slice(0, -5);
+    if (modelNames.includes(test)) {
+      return test;
+    }
+  }
+}
+const splitKeywords = ['CreateInput', 'CreateMany', 'CreateNested', 'CreateOneWithout', 'CreateOrConnect', 'CreateWithout', 'DistinctField', 'Filter', 'ManyWithout', 'OrderByInput', 'RelationFilter', 'NullableRelationFilter', 'ListRelationFilter', 'ScalarWhereInput', 'UpdateInput', 'UpdateMany', 'UpdateOneRequiredWithout', 'UpdateOneWithout', 'UpdateWith', 'UpsertWith', 'UpsertWithout', 'WhereInput', 'WhereUniqueInput', 'AvgAggregate', 'SumAggregate', 'MinAggregate', 'MaxAggregate', 'CountAggregate', 'ScalarField', 'GroupBy', 'OrderBy', 'UncheckedUpdate', 'UncheckedCreate', 'ScalarWhere', 'CountOutputType', 'CountOrderBy', 'SumOrderBy', 'MinOrderBy', 'MaxOrderBy', 'AvgOrderBy', 'Create', 'Update', 'ScalarRelationFilter', 'NullableScalarRelationFilter'].sort((a, b) => b.length - a.length);
+const endsWithKeywords = ['Aggregate', 'GroupBy', 'CreateOne', 'CreateMany', 'DeleteMany', 'DeleteOne', 'FindMany', 'FindOne', 'FindUnique', 'UpdateMany', 'UpdateOne', 'UpsertOne'];
+const middleKeywords = [['FindFirst', 'OrThrowArgs'], ['FindUnique', 'OrThrowArgs'], ['Aggregate', 'Args'], ['CreateOne', 'Args'], ['CreateMany', 'Args'], ['DeleteMany', 'Args'], ['DeleteOne', 'Args'], ['FindMany', 'Args'], ['FindFirst', 'Args'], ['FindOne', 'Args'], ['FindUnique', 'Args'], ['UpdateMany', 'Args'], ['UpdateMany', 'AndReturnOutputType'], ['UpdateOne', 'Args'], ['UpsertOne', 'Args'], ['GroupBy', 'Args'], ['OrderBy', 'Args']];
+
+function resolveAwaitEventEmitter() {
+  if (typeof awaitEventEmitterModule === 'function') return awaitEventEmitterModule;
+  if (typeof awaitEventEmitterModule.default === 'function') return awaitEventEmitterModule.default;
+}
+async function generate(args) {
+  const {
+    connectCallback,
+    dmmf,
+    generator,
+    skipAddOutputSourceFiles
+  } = args;
+  const generatorOutputValue = generator.output?.value;
+  ok(generatorOutputValue, 'Missing generator configuration: output');
+  const config = createConfig(generator.config);
+  const AwaitEventEmitter = resolveAwaitEventEmitter();
+  const eventEmitter = new AwaitEventEmitter();
+  eventEmitter.on('Warning', warning);
+  config.emitBlocks.models && eventEmitter.on('Model', modelData);
+  if (config.emitBlocks.prismaEnums || config.emitBlocks.schemaEnums) {
+    eventEmitter.on('EnumType', registerEnum);
+  }
+  if (config.emitBlocks.outputs || config.emitBlocks.models && !config.omitModelsCount) {
+    eventEmitter.on('OutputType', outputType);
+  }
+  config.emitBlocks.models && eventEmitter.on('ModelOutputType', modelOutputType);
+  config.emitBlocks.outputs && eventEmitter.on('AggregateOutput', createAggregateInput);
+  config.emitBlocks.inputs && eventEmitter.on('InputType', inputType);
+  config.emitBlocks.args && eventEmitter.on('ArgsType', argsType);
+  eventEmitter.on('GenerateFiles', generateFiles);
+  for (const message of config.$warnings) {
+    eventEmitter.emitSync('Warning', message);
+  }
+  const project = new Project({
+    manipulationSettings: {
+      quoteKind: QuoteKind.Single
+    },
+    skipAddingFilesFromTsConfig: true,
+    skipLoadingLibFiles: !config.emitCompiled,
+    tsConfigFilePath: config.tsConfigFilePath
+  });
+  if (!skipAddOutputSourceFiles) {
+    project.addSourceFilesAtPaths([`${generatorOutputValue}/**/*.ts`, `!${generatorOutputValue}/**/*.d.ts`]);
+  }
+  config.combineScalarFilters && combineScalarFilters(eventEmitter);
+  config.noAtomicOperations && noAtomicOperations(eventEmitter);
+  config.reExport !== ReExport.None && reExport(eventEmitter);
+  config.purgeOutput && purgeOutput(eventEmitter);
+  config.requireSingleFieldsInWhereUniqueInput && requireSingleFieldsInWhereUniqueInput(eventEmitter);
+  const models = new Map();
+  const modelNames = [];
+  const modelFields = new Map();
+  const fieldSettings = new Map();
+  const getModelName = createGetModelName(modelNames);
+  const getSourceFile = factoryGetSourceFile({
+    eventEmitter,
+    getModelName,
+    output: generatorOutputValue,
+    outputFilePattern: config.outputFilePattern,
+    project
+  });
+  const {
+    datamodel,
+    schema
+  } = structuredClone(dmmf);
+  const removeTypes = new Set();
+  const eventArguments = {
+    classTransformerTypeModels: new Set(),
+    config,
+    enums: mapKeys(datamodel.enums, x => x.name),
+    eventEmitter,
+    fieldSettings,
+    getModelName,
+    getSourceFile,
+    modelFields,
+    modelNames,
+    models,
+    output: generatorOutputValue,
+    project,
+    removeTypes,
+    schema,
+    typeNames: new Set()
+  };
+  if (connectCallback) {
+    await connectCallback(eventEmitter, eventArguments);
+  }
+  await eventEmitter.emit('Begin', eventArguments);
+  for (const model of datamodel.models) {
+    await eventEmitter.emit('Model', model, eventArguments);
+  }
+
+  // Types behaves like model
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+  for (const model of datamodel.types || []) {
+    await eventEmitter.emit('Model', model, eventArguments);
+  }
+  const {
+    enumTypes,
+    inputObjectTypes,
+    outputObjectTypes
+  } = schema;
+  await eventEmitter.emit('PostBegin', eventArguments);
+  for (const enumType of enumTypes.prisma.concat(enumTypes.model || [])) {
+    await eventEmitter.emit('EnumType', enumType, eventArguments);
+  }
+  for (const outputType of outputObjectTypes.model) {
+    await eventEmitter.emit('ModelOutputType', outputType, eventArguments);
+  }
+  const queryOutputTypes = [];
+  for (const outputType of outputObjectTypes.prisma) {
+    if (['Query', 'Mutation'].includes(outputType.name)) {
+      queryOutputTypes.push(outputType);
+      continue;
+    }
+    await eventEmitter.emit('OutputType', outputType, eventArguments);
+  }
+  const inputTypes = inputObjectTypes.prisma?.concat(inputObjectTypes.model ?? []) ?? [];
+  for (const inputType of inputTypes) {
+    const event = {
+      ...eventArguments,
+      classDecoratorName: 'InputType',
+      fileType: 'input',
+      inputType
+    };
+    if (inputType.fields.length === 0) {
+      removeTypes.add(inputType.name);
+      continue;
+    }
+    await eventEmitter.emit('BeforeInputType', event);
+    await eventEmitter.emit('InputType', event);
+  }
+  for (const outputType of queryOutputTypes) {
+    for (const field of outputType.fields) {
+      await eventEmitter.emit('ArgsType', field, eventArguments);
+    }
+  }
+  await eventEmitter.emit('BeforeGenerateFiles', eventArguments);
+  await eventEmitter.emit('GenerateFiles', eventArguments);
+  await eventEmitter.emit('End', eventArguments);
+  for (const name of Object.keys(eventEmitter._events)) {
+    eventEmitter.off(name);
+  }
+}
+const generatorHandlerConfig = {
+  async onGenerate(options) {
+    await generate(options);
+  },
+  onManifest() {
+    return {
+      defaultOutput: '.',
+      prettyName: 'Prisma NestJS/GraphQL'
+    };
+  }
+};
+
+export { generate, generatorHandlerConfig };