@pegasusheavy/nestjs-prisma-graphql 1.4.3 → 1.6.0

package/dist/generate.js

@@ -1,2839 +1,212 @@
-import { memoize, mapKeys, merge, trim, castArray, uniqWith, isEqual, countBy, startCase, camelCase, keyBy, remove, partition, kebabCase, isObject, omit, cloneDeep } from 'lodash-es';
-import { createRequire } from 'module';
-import { Project, QuoteKind, StructureKind } from 'ts-morph';
-import { ok as ok$1 } from 'assert';
-import JSON52 from 'json5';
-import pupa from 'pupa';
-import getRelativePath from 'get-relative-path';
-import outmatch2 from 'outmatch';
-import { existsSync, rmdirSync as rmdirSync$1 } from 'fs';
-import { unflatten } from 'flat';
-import filenamify from 'filenamify';
-import pluralize from 'pluralize';
-
-// src/generate.ts
-function ok(value, message) {
-  ok$1(
-    value,
-    message
-  );
-}
-
-// src/helpers/is-many-and-return.ts
-function isManyAndReturnOutputType(name) {
-  const lowerName = name.toLowerCase();
-  if ((lowerName.startsWith("createmany") || lowerName.startsWith("updatemany")) && (lowerName.endsWith("andreturnoutputtype") || lowerName.endsWith("andreturn"))) {
-    return true;
-  }
-  return false;
-}
-function pascalCase(string) {
-  return startCase(camelCase(string)).replaceAll(" ", "");
-}
-
-// src/handlers/args-type.ts
-function argsType(field, args) {
-  if (["queryRaw", "executeRaw"].includes(field.name)) {
-    return;
-  }
-  if (isManyAndReturnOutputType(field.name)) {
-    return;
-  }
-  const { eventEmitter, getModelName: getModelName2, typeNames } = args;
-  let className = pascalCase(`${field.name}Args`);
-  const modelName = getModelName2(className) ?? "";
-  switch (className) {
-    case `Aggregate${modelName}Args`: {
-      className = `${modelName}AggregateArgs`;
-      break;
-    }
-    case `GroupBy${modelName}Args`: {
-      className = `${modelName}GroupByArgs`;
-      break;
-    }
-  }
-  const inputType2 = {
-    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` === inputType2.name) {
-      const byField = inputType2.fields.find((f) => f.name === "by");
-      if (byField?.inputTypes) {
-        byField.inputTypes = byField.inputTypes.filter((it) => it.isList);
-      }
-    }
-    for (const name of names) {
-      if (!typeNames.has(`${modelName}${name}AggregateInput`)) {
-        continue;
-      }
-      inputType2.fields.push({
-        inputTypes: [
-          {
-            isList: false,
-            location: "inputObjectTypes",
-            type: `${modelName}${name}AggregateInput`
-          }
-        ],
-        isNullable: true,
-        isRequired: false,
-        name: `_${name.toLowerCase()}`
-      });
-    }
-  }
-  eventEmitter.emitSync("InputType", {
-    ...args,
-    classDecoratorName: "ArgsType",
-    fileType: "args",
-    inputType: inputType2
-  });
-}
-
-// src/event-names.ts
-var BeforeGenerateField = "BeforeGenerateField";
-
-// src/handlers/combine-scalar-filters.ts
-function combineScalarFilters(eventEmitter) {
-  eventEmitter.on("BeforeInputType", beforeInputType);
-  eventEmitter.on(BeforeGenerateField, beforeGenerateField);
-  eventEmitter.on("PostBegin", postBegin);
-}
-function beforeInputType(args) {
-  const { inputType: inputType2, removeTypes } = args;
-  if (isContainBogus(inputType2.name) && isScalarFilter(inputType2)) {
-    removeTypes.add(inputType2.name);
-    inputType2.name = replaceBogus(inputType2.name);
-  }
-}
-function beforeGenerateField(field) {
-  for (const fieldInput of field.inputTypes) {
-    if (fieldInput.location !== "inputObjectTypes") {
-      continue;
-    }
-    const fieldInputType = 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(inputType2) {
-  if (!inputType2.name.endsWith("Filter")) {
-    return false;
-  }
-  let result = false;
-  const equals = inputType2.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, (it) => it.name);
-  const replaceBogusFilters = (filterName, filterNameCandidates) => {
-    for (const filterNameCandidate of filterNameCandidates) {
-      const candidate = inputTypeByName[filterNameCandidate];
-      if (candidate) {
-        const it = cloneDeep({ ...candidate, name: filterName });
-        inputTypes.push(it);
-        inputTypeByName[filterName] = it;
-        break;
-      }
-    }
-  };
-  for (const type of types) {
-    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, (it) => {
-    return isContainBogus(it.name);
-  });
-}
-
-// src/handlers/create-aggregate-input.ts
-function createAggregateInput(args) {
-  const { eventEmitter, outputType: outputType2 } = args;
-  const className = `${outputType2.name}Input`;
-  const inputType2 = {
-    constraints: { maxNumFields: null, minNumFields: null },
-    fields: outputType2.fields.map((x) => ({
-      inputTypes: [
-        {
-          isList: false,
-          location: "scalar",
-          type: "true"
-        }
-      ],
-      isNullable: x.isNullable ?? true,
-      isRequired: false,
-      name: x.name
-    })),
-    name: className
-  };
-  eventEmitter.emitSync("InputType", {
-    ...args,
-    classDecoratorName: "InputType",
-    fileType: "input",
-    inputType: inputType2
-  });
-}
-
-// src/handlers/decimal-helpers.ts
-function generateDecimalHelpers(args) {
-  const { output, project } = args;
-  const rootDirectory = project.getDirectory(output) ?? project.createDirectory(output);
-  const sourceFile = rootDirectory.createSourceFile("decimal-helpers.ts", void 0, {
-    overwrite: true
-  });
-  const helpersCode = `/**
- * Decimal Helpers for Prisma GraphQL
- *
- * This module provides utilities for transforming Decimal values
- * between GraphQL and Prisma, compatible with Prisma 7+.
- *
- * These functions replace the prisma-graphql-type-decimal package
- * which is incompatible with Prisma 7's new client structure.
- */
-
-import Decimal from 'decimal.js';
-
-/**
- * Reconstruct a Decimal from a serialized object.
- * Prisma serializes Decimals as objects with d, e, s properties.
- */
-function createDecimalFromObject(object: { d: number[]; e: number; s: number }): Decimal {
-  return Object.create(Decimal.prototype, {
-    d: { value: object.d },
-    e: { value: object.e },
-    s: { value: object.s },
-  });
-}
-
-/**
- * Transform input values to Decimal instances.
- * Used as a class-transformer Transform decorator argument.
- *
- * @param params - The transform parameters from class-transformer
- * @returns The transformed Decimal or array of Decimals
- */
-export function transformToDecimal({ value }: { value: unknown }): Decimal | Decimal[] | null | undefined {
-  if (value == null) return value as null | undefined;
-
-  if (Array.isArray(value)) {
-    return value.map((v) => {
-      if (v instanceof Decimal) return v;
-      if (typeof v === 'object' && v !== null && 'd' in v && 'e' in v && 's' in v) {
-        return createDecimalFromObject(v as { d: number[]; e: number; s: number });
-      }
-      return new Decimal(v as string | number);
-    });
-  }
-
-  if (value instanceof Decimal) return value;
-  if (typeof value === 'object' && value !== null && 'd' in value && 'e' in value && 's' in value) {
-    return createDecimalFromObject(value as { d: number[]; e: number; s: number });
-  }
-  return new Decimal(value as string | number);
-}
-
-/**
- * Re-export Decimal class for convenience
- */
-export { Decimal };
-`;
-  sourceFile.addStatements(helpersCode);
-}
-function emitSingle(emitter) {
-  emitter.on("ClassProperty", classProperty);
-}
-function classProperty(property, eventArguments) {
-  const { isList, location, propertyType } = eventArguments;
-  if (["inputObjectTypes", "outputObjectTypes"].includes(location) && !isList) {
-    const [safeTypes, instanceofTypes] = partition(
-      propertyType,
-      (t) => t === "null" || t.startsWith("Prisma.")
-    );
-    const mappedInstanceofTypes = instanceofTypes.map((t) => `InstanceType<typeof ${t}>`);
-    property.type = [...mappedInstanceofTypes, ...safeTypes].join(" | ");
-  }
-}
-var ImportDeclarationMap = class extends Map {
-  add(name, value, isTypeOnly) {
-    if (!this.has(name)) {
-      const structure = typeof value === "string" ? { isTypeOnly, moduleSpecifier: value, namedImports: [{ name }] } : value;
-      this.set(name, structure);
-    }
-  }
-  /**
-   * Add a type-only import for ESM circular dependency resolution
-   */
-  addType(name, moduleSpecifier) {
-    const typeOnlyKey = `type:${name}`;
-    if (!this.has(typeOnlyKey) && !this.has(name)) {
-      this.set(typeOnlyKey, {
-        isTypeOnly: true,
-        moduleSpecifier,
-        namedImports: [{ name }]
-      });
-    }
-  }
-  create(args) {
-    const { defaultImport, from, isTypeOnly, namedImport, namespaceImport } = args;
-    let { name } = args;
-    const value = {
-      defaultImport: void 0,
-      isTypeOnly,
-      moduleSpecifier: from,
-      namedImports: [],
-      namespaceImport: void 0
-    };
-    if (namedImport === true && namespaceImport !== void 0) {
-      value.namedImports = [{ name: namespaceImport }];
-      name = namespaceImport;
-    } else if (defaultImport === void 0) {
-      if (namespaceImport === void 0) {
-        value.namedImports = [{ name }];
-      } else {
-        value.namespaceImport = namespaceImport;
-        name = namespaceImport;
-      }
-    } else {
-      value.defaultImport = defaultImport === true ? name : defaultImport;
-      name = value.defaultImport;
-    }
-    const key = isTypeOnly === true ? `type:${name}` : name;
-    if (this.has(key)) {
-      return;
-    }
-    this.set(key, value);
-  }
-  *toStatements() {
-    const iterator = this.values();
-    let result = iterator.next();
-    while (result.value !== void 0) {
-      yield {
-        ...result.value,
-        kind: StructureKind.ImportDeclaration
-      };
-      result = iterator.next();
-    }
-  }
-};
-
-// src/handlers/generate-files.ts
-async function generateFiles(args) {
-  const { config, eventEmitter, output, project } = 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 statements = project.getSourceFiles().flatMap((s) => {
-      if (s === sourceFile) {
-        return [];
-      }
-      const classDeclaration = s.getClass(() => true);
-      const stmts = s.getStructure().statements;
-      if (Array.isArray(stmts)) {
-        for (const statement of stmts) {
-          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 !== void 0,
-                `Cannot get full name of decorator of class ${String(statement.name)}`
-              );
-              decorator.name = fullName;
-            }
-          }
-        }
-      }
-      project.removeSourceFile(s);
-      return stmts;
-    });
-    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("./") || statement.moduleSpecifier.startsWith("..")) {
-            continue;
-          }
-          for (const namedImport of statement.namedImports) {
-            const name = namedImport.alias ?? namedImport.name;
-            imports.add(name, statement.moduleSpecifier);
-          }
-          if (statement.defaultImport) {
-            imports.create({
-              defaultImport: statement.defaultImport,
-              from: statement.moduleSpecifier,
-              name: statement.defaultImport
-            });
-          }
-          if (statement.namespaceImport) {
-            imports.create({
-              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.create(customImport);
-    }
-    sourceFile.set({
-      kind: StructureKind.SourceFile,
-      statements: [...imports.toStatements(), ...enums, ...classes]
-    });
-  }
-  const sourceFiles = project.getSourceFiles();
-  const sourceFileCount = sourceFiles.length;
-  const globalConsole2 = globalThis.console;
-  const logMessage = (msg) => {
-    globalConsole2.log(msg);
-  };
-  logMessage(
-    `nestjs-prisma-graphql: saving ${String(sourceFileCount)} source files to ${output}`
-  );
-  if (sourceFileCount === 0) {
-    throw new Error(
-      "nestjs-prisma-graphql: project has 0 source files \u2014 nothing to write"
-    );
-  }
-  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 {
-    const BATCH_SIZE = 100;
-    if (sourceFileCount > BATCH_SIZE) {
-      logMessage(
-        `nestjs-prisma-graphql: using batched save for large schema (${String(sourceFileCount)} files)`
-      );
-      for (let i = 0; i < sourceFileCount; i += BATCH_SIZE) {
-        const batch = sourceFiles.slice(i, i + BATCH_SIZE);
-        logMessage(
-          `nestjs-prisma-graphql: saving batch ${String(Math.floor(i / BATCH_SIZE) + 1)}/${String(Math.ceil(sourceFileCount / BATCH_SIZE))} (${String(batch.length)} files)`
-        );
-        await Promise.all(batch.map(async (sf) => await sf.save()));
-      }
-    } else {
-      await project.save();
-    }
-  }
-}
-
-// src/helpers/file-type-by-location.ts
-function fileTypeByLocation(fieldLocation) {
-  switch (fieldLocation) {
-    case "inputObjectTypes": {
-      return "input";
-    }
-    case "outputObjectTypes": {
-      return "output";
-    }
-    case "enumTypes": {
-      return "enum";
-    }
-    case "fieldRefTypes":
-    case "scalar":
-    default: {
-      return "object";
-    }
-  }
-}
-function relativePath(from, to) {
-  let fromPath = from;
-  let toPath = to;
-  if (!fromPath.startsWith("/")) {
-    fromPath = `/${fromPath}`;
-  }
-  if (!toPath.startsWith("/")) {
-    toPath = `/${toPath}`;
-  }
-  let result = getRelativePath(fromPath, toPath);
-  if (!result.startsWith(".")) {
-    result = `./${result}`;
-  }
-  if (result.endsWith(".ts")) {
-    result = result.slice(0, -3);
-  }
-  return result;
-}
-
-// src/helpers/get-graphql-import.ts
-function getGraphqlImport(args) {
-  const {
-    config,
-    fileType,
-    getSourceFile,
-    isId,
-    location,
-    noTypeId,
-    sourceFile,
-    typeName
-  } = args;
-  if (location === "scalar") {
-    if (isId && !noTypeId) {
-      return { name: "ID", specifier: "@nestjs/graphql" };
-    }
-    const graphqlType = config.graphqlScalars[typeName];
-    if (graphqlType) {
-      return { name: graphqlType.name, specifier: graphqlType.specifier };
-    }
-    switch (typeName) {
-      case "Float":
-      case "Int": {
-        return { name: typeName, specifier: "@nestjs/graphql" };
-      }
-      case "DateTime": {
-        return { name: "Date", specifier: void 0 };
-      }
-      case "true":
-      case "Boolean": {
-        return { name: "Boolean", specifier: void 0 };
-      }
-      case "Decimal": {
-        return {
-          name: "GraphQLDecimal",
-          specifier: "graphql-scalars"
-        };
-      }
-      case "Json": {
-        return { name: "GraphQLJSON", specifier: "graphql-type-json" };
-      }
-    }
-    return { name: "String", specifier: void 0 };
-  }
-  let sourceFileType = fileTypeByLocation(location);
-  if (sourceFileType === "output" && fileType === "model") {
-    sourceFileType = "model";
-  }
-  let specifier = relativePath(
-    sourceFile.getFilePath(),
-    getSourceFile({
-      name: typeName,
-      type: sourceFileType
-    }).getFilePath()
-  );
-  if (config.esmCompatible && !specifier.startsWith("@") && !specifier.endsWith(".js")) {
-    specifier += ".js";
-  }
-  return { name: typeName, specifier };
-}
-function getGraphqlInputType(inputTypes, pattern) {
-  let result;
-  inputTypes = inputTypes.filter((t) => !["null", "Null"].includes(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 !== null && pattern !== void 0 && pattern.length > 0) {
-    if (pattern.startsWith("matcher:") || pattern.startsWith("match:")) {
-      const { 1: patternValue } = pattern.split(":", 2);
-      const isMatch = outmatch2(patternValue, { separator: false });
-      result = inputTypes.find((x) => isMatch(x.type));
-      if (result !== void 0) {
-        return result;
-      }
-    }
-    result = inputTypes.find((x) => x.type.includes(pattern));
-    if (result !== void 0) {
-      return result;
-    }
-  }
-  result = inputTypes.find((x) => x.location === "inputObjectTypes");
-  if (result !== void 0) {
-    return result;
-  }
-  if ((countTypes.enumTypes ?? 0) > 0 && (countTypes.scalar ?? 0) > 0 && inputTypes.some((x) => x.type === "Json" && x.location === "scalar")) {
-    result = inputTypes.find((x) => x.type === "Json" && x.location === "scalar");
-    if (result !== void 0) {
-      return result;
-    }
-  }
-  if (((countTypes.scalar ?? 0) >= 1 || (countTypes.enumTypes ?? 0) >= 1) && countTypes.fieldRefTypes === 1) {
-    result = inputTypes.find(
-      (x) => (x.location === "scalar" || x.location === "enumTypes") && x.isList
-    );
-    if (result !== void 0) {
-      return result;
-    }
-    result = inputTypes.find((x) => x.location === "scalar" || x.location === "enumTypes");
-    if (result !== void 0) {
-      return result;
-    }
-  }
-  throw new TypeError(
-    `Cannot get matching input type from ${inputTypes.length > 0 ? inputTypes.map((x) => x.type).join(", ") : "zero length inputTypes"}`
-  );
-}
-
-// src/helpers/get-property-type.ts
-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 ["Prisma.Decimal"];
-    }
-    case "Json": {
-      return ["any"];
-    }
-    case "Null": {
-      return ["null"];
-    }
-    case "Bytes": {
-      return ["Uint8Array"];
-    }
-    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"];
-}
-
-// src/helpers/get-where-unique-at-least-keys.ts
-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 !== null && name !== void 0 && name.length > 0 ? name : fields.join("_");
-}
-
-// src/helpers/is-where-unique-input-type.ts
-function isWhereUniqueInputType(name) {
-  return name.endsWith("WhereUniqueInput");
-}
-function propertyStructure(args) {
-  const {
-    hasExclamationToken,
-    hasQuestionToken,
-    isList,
-    isNullable,
-    name,
-    propertyType
-  } = args;
-  const typeString = propertyType.map((typeItem) => isList ? `Array<${typeItem}>` : typeItem).join(" | ");
-  return {
-    decorators: [],
-    hasExclamationToken: hasExclamationToken ?? !isNullable,
-    hasQuestionToken: hasQuestionToken ?? isNullable,
-    kind: StructureKind.Property,
-    leadingTrivia: "\n",
-    name,
-    type: typeString
-  };
-}
-
-// src/handlers/input-type.ts
-function inputType(args) {
-  const {
-    classDecoratorName,
-    classTransformerTypeModels,
-    config,
-    eventEmitter,
-    fieldSettings,
-    fileType,
-    getModelName: getModelName2,
-    getSourceFile,
-    inputType: inputTypeArg,
-    models,
-    output,
-    removeTypes,
-    typeNames
-  } = args;
-  typeNames.add(inputTypeArg.name);
-  const importDeclarations = new ImportDeclarationMap();
-  const sourceFile = getSourceFile({
-    name: inputTypeArg.name,
-    type: fileType
-  });
-  const classStructure = {
-    decorators: [
-      {
-        arguments: [],
-        name: classDecoratorName
-      }
-    ],
-    isExported: true,
-    kind: StructureKind.Class,
-    name: inputTypeArg.name,
-    properties: []
-  };
-  const modelName = getModelName2(inputTypeArg.name) ?? "";
-  const model = models.get(modelName);
-  const modelFieldSettings = model && fieldSettings.get(model.name);
-  const moduleSpecifier = "@nestjs/graphql";
-  const lazyTypes = /* @__PURE__ */ new Set();
-  importDeclarations.set("Field", {
-    moduleSpecifier,
-    namedImports: [{ name: "Field" }]
-  }).set(classDecoratorName, {
-    moduleSpecifier,
-    namedImports: [{ name: classDecoratorName }]
-  });
-  if (config.esmCompatible) {
-    let typeRegistryPath = relativePath(
-      sourceFile.getFilePath(),
-      `${output}/type-registry.ts`
-    );
-    if (!typeRegistryPath.endsWith(".js")) {
-      typeRegistryPath += ".js";
-    }
-    importDeclarations.add("registerType", typeRegistryPath);
-    importDeclarations.add("getType", typeRegistryPath);
-  }
-  const useInputType = config.useInputType.find(
-    (x) => inputTypeArg.name.includes(x.typeName)
-  );
-  const isWhereUnique = isWhereUniqueInputType(inputTypeArg.name);
-  for (const field of inputTypeArg.fields) {
-    field.inputTypes = field.inputTypes.filter((t) => !removeTypes.has(t.type));
-    eventEmitter.emitSync(BeforeGenerateField, field, args);
-    const { inputTypes, isRequired, name } = field;
-    if (inputTypes.length === 0) {
-      continue;
-    }
-    const usePattern = useInputType?.ALL ?? useInputType?.[name];
-    const graphqlInputType = getGraphqlInputType(inputTypes, usePattern);
-    const { isList, location, type } = graphqlInputType;
-    const typeName = type;
-    const settings = modelFieldSettings?.get(name);
-    const propertySettings = settings?.getPropertyType({
-      input: true,
-      name: inputTypeArg.name
-    });
-    const modelField = model?.fields.find((f) => f.name === name);
-    const isCustomsApplicable = typeName === modelField?.type;
-    const atLeastKeys = model && getWhereUniqueAtLeastKeys(model);
-    const whereUniqueInputTypeValue = isWhereUniqueInputType(typeName) && atLeastKeys && `Prisma.AtLeast<${typeName}, ${atLeastKeys.map((n) => `'${n}'`).join(" | ")}>`;
-    const propertyType = castArray(
-      propertySettings?.name ?? whereUniqueInputTypeValue ?? getPropertyType({
-        location,
-        type: typeName
-      })
-    );
-    const hasExclamationToken = Boolean(
-      isWhereUnique && config.unsafeCompatibleWhereUniqueInput && atLeastKeys?.includes(name)
-    );
-    const property = propertyStructure({
-      hasExclamationToken: hasExclamationToken || void 0,
-      hasQuestionToken: hasExclamationToken ? false : void 0,
-      isList,
-      isNullable: !isRequired,
-      name,
-      propertyType
-    });
-    if (classStructure.properties) {
-      classStructure.properties.push(property);
-    }
-    if (propertySettings) {
-      importDeclarations.create({ ...propertySettings });
-    } else if (propertyType.some(
-      (p) => typeof p === "string" && p.includes("Prisma.Decimal")
-    )) {
-      importDeclarations.add("Prisma", config.prismaClientImport);
-    } else if (propertyType.some((p) => typeof p === "string" && p.startsWith("Prisma."))) {
-      importDeclarations.add("Prisma", config.prismaClientImport);
-    }
-    let graphqlType;
-    let useGetType = false;
-    const shouldHideField = settings?.shouldHideField({
-      input: true,
-      name: inputTypeArg.name
-    }) ?? config.decorate.some(
-      (d) => d.name === "HideField" && d.from === moduleSpecifier && d.isMatchField(name) && d.isMatchType(inputTypeArg.name)
-    );
-    const fieldType = settings?.getFieldType({
-      input: true,
-      name: inputTypeArg.name
-    });
-    if (fieldType && isCustomsApplicable && !shouldHideField) {
-      graphqlType = fieldType.name;
-      importDeclarations.create({ ...fieldType });
-    } else {
-      const graphqlImport = getGraphqlImport({
+import { mapKeys } from 'lodash-es';
+import { createRequire } from 'node:module';
+import { Project, QuoteKind } from 'ts-morph';
+import { ok } from './helpers/type-safe-assert.js';
+const createRequireTyped = createRequire;
+// ESLint doesn't understand import.meta.url type - cast to string explicitly
+const requireCjs = createRequireTyped(String(import.meta.url));
+const AwaitEventEmitter = requireCjs('await-event-emitter');
+const AwaitEventEmitterClass = AwaitEventEmitter.default;
+import { argsType } from './handlers/args-type.js';
+import { combineScalarFilters } from './handlers/combine-scalar-filters.js';
+import { createAggregateInput } from './handlers/create-aggregate-input.js';
+import { generateDecimalHelpers } from './handlers/decimal-helpers.js';
+import { emitSingle } from './handlers/emit-single.js';
+import { generateBarrelExports } from './handlers/generate-barrel-exports.js';
+import { generateFiles } from './handlers/generate-files.js';
+import { inputType } from './handlers/input-type.js';
+import { modelData } from './handlers/model-data.js';
+import { modelOutputType } from './handlers/model-output-type.js';
+import { noAtomicOperations } from './handlers/no-atomic-operations.js';
+import { outputType } from './handlers/output-type.js';
+import { patchTypeRegistry } from './handlers/patch-type-registry.js';
+import { postProcessImports } from './handlers/post-process-imports.js';
+import { purgeOutput } from './handlers/purge-output.js';
+import { ReExport, reExport } from './handlers/re-export.js';
+import { generateRegisterAllTypes } from './handlers/register-all-types.js';
+import { registerEnum } from './handlers/register-enum.js';
+import { requireSingleFieldsInWhereUniqueInput } from './handlers/require-single-fields-in-whereunique-input.js';
+import { generateTypeRegistry } from './handlers/type-registry.js';
+import { warning } from './handlers/warning.js';
+import { createConfig } from './helpers/create-config.js';
+import { buildDependencyGraph, detectCircularDependencies, } from './helpers/detect-circular-deps.js';
+import { factoryGetSourceFile } from './helpers/factory-get-source-file.js';
+import { createGetModelName } from './helpers/get-model-name.js';
+export 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 eventEmitter = new AwaitEventEmitterClass();
+    eventEmitter.on('Warning', warning);
+    if (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);
+    }
+    if (config.emitBlocks.models) {
+        eventEmitter.on('ModelOutputType', modelOutputType);
+    }
+    if (config.emitBlocks.outputs) {
+        eventEmitter.on('AggregateOutput', createAggregateInput);
+    }
+    if (config.emitBlocks.inputs) {
+        eventEmitter.on('InputType', inputType);
+    }
+    if (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 !== true) {
+        project.addSourceFilesAtPaths([
+            `${generatorOutputValue}/**/*.ts`,
+            `!${generatorOutputValue}/**/*.d.ts`,
+        ]);
+    }
+    if (config.combineScalarFilters) {
+        combineScalarFilters(eventEmitter);
+    }
+    if (config.noAtomicOperations) {
+        noAtomicOperations(eventEmitter);
+    }
+    if (config.reExport !== ReExport.None) {
+        reExport(eventEmitter);
+    }
+    if (config.emitSingle) {
+        emitSingle(eventEmitter);
+    }
+    if (config.purgeOutput) {
+        purgeOutput(eventEmitter);
+    }
+    if (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 } = JSON.parse(JSON.stringify(dmmf));
+    const removeTypes = new Set();
+    // Build circular dependency detection for ESM compatibility
+    const datamodelTypes = datamodel.types ?? [];
+    const allModels = [...datamodel.models, ...datamodelTypes];
+    const dependencyGraph = buildDependencyGraph(allModels);
+    const circularDependencies = detectCircularDependencies(dependencyGraph);
+    const eventArguments = {
+        circularDependencies,
+        classTransformerTypeModels: new Set(),
         config,
+        enums: mapKeys(datamodel.enums, x => x.name),
+        eventEmitter,
+        fieldSettings,
+        getModelName,
         getSourceFile,
-        location,
-        sourceFile,
-        typeName
-      });
-      graphqlType = graphqlImport.name;
-      if (location === "enumTypes") {
-        const parts = String(propertyType[0]).split(" ");
-        parts.at(-1);
-      }
-      const shouldUseLazyType = config.esmCompatible && location === "inputObjectTypes";
-      if (graphqlImport.name === inputTypeArg.name && shouldUseLazyType) {
-        lazyTypes.add(graphqlImport.name);
-        useGetType = true;
-      } else if (graphqlImport.specifier !== null && graphqlImport.specifier !== void 0 && !importDeclarations.has(graphqlImport.name) && graphqlImport.name !== inputTypeArg.name) {
-        if (shouldUseLazyType) {
-          importDeclarations.addType(graphqlImport.name, graphqlImport.specifier);
-          lazyTypes.add(graphqlImport.name);
-        } else {
-          importDeclarations.set(graphqlImport.name, {
-            moduleSpecifier: graphqlImport.specifier,
-            namedImports: [{ name: graphqlImport.name }]
-          });
-        }
-      }
-      if (lazyTypes.has(graphqlImport.name)) {
-        useGetType = true;
-      }
-    }
-    ok(
-      property.decorators !== void 0 && property.decorators !== null,
-      "property.decorators is undefined"
-    );
-    if (shouldHideField) {
-      importDeclarations.add("HideField", moduleSpecifier);
-      property.decorators.push({ arguments: [], name: "HideField" });
-    } else {
-      let typeExpression;
-      if (useGetType) {
-        typeExpression = isList ? `() => [getType('${graphqlType}')]` : `() => getType('${graphqlType}')`;
-      } else {
-        typeExpression = isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`;
-      }
-      property.decorators.push({
-        arguments: [
-          typeExpression,
-          JSON52.stringify({
-            ...settings?.fieldArguments(),
-            nullable: !isRequired
-          })
-        ],
-        name: "Field"
-      });
-      if (graphqlType === "GraphQLDecimal") {
-        let decimalHelpersPath = relativePath(
-          sourceFile.getFilePath(),
-          `${output}/decimal-helpers.ts`
-        );
-        if (config.esmCompatible && !decimalHelpersPath.endsWith(".js")) {
-          decimalHelpersPath += ".js";
-        }
-        importDeclarations.add("transformToDecimal", decimalHelpersPath);
-        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(getModelName2(graphqlType) ?? "") || modelField?.kind === "object" && models.get(modelField.type)?.fields.some(
-        (f) => f.kind === "object" && classTransformerTypeModels.has(f.type)
-      ) === true)) {
-        importDeclarations.add("Type", "class-transformer");
-        if (useGetType) {
-          property.decorators.push({
-            arguments: [`getType('${graphqlType}')`],
-            name: "Type"
-          });
-        } else {
-          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(
-              options.from !== void 0 && options.from !== null && options.from !== "",
-              "Missed 'from' part in configuration or field setting"
-            );
-            importDeclarations.create(options);
-          }
-        }
-      }
-      for (const decorate of config.decorate) {
-        if (decorate.isMatchField(name) && decorate.isMatchType(inputTypeArg.name)) {
-          property.decorators.push({
-            arguments: decorate.arguments?.map((x) => pupa(x, { propertyType })),
-            name: decorate.name
-          });
-          importDeclarations.create(decorate);
-        }
-      }
-    }
-    eventEmitter.emitSync("ClassProperty", property, {
-      isList,
-      location,
-      propertyType
-    });
-  }
-  const statements = [
-    ...importDeclarations.toStatements(),
-    classStructure
-  ];
-  if (config.esmCompatible) {
-    statements.push(`
-registerType('${inputTypeArg.name}', ${inputTypeArg.name});`);
-  }
-  sourceFile.set({
-    statements
-  });
-}
-var ObjectSettings = class 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 void 0;
-    }
-    if (fieldType.match) {
-      return fieldType.match(name) ? fieldType : void 0;
-    }
-    if (input && !fieldType.input) {
-      return void 0;
-    }
-    if (output && !fieldType.output) {
-      return void 0;
-    }
-    return fieldType;
-  }
-  getPropertyType({
-    input,
-    name,
-    output
-  }) {
-    const propertyType = this.find((s) => s.kind === "PropertyType");
-    if (!propertyType) {
-      return void 0;
-    }
-    if (propertyType.match) {
-      return propertyType.match(name) ? propertyType : void 0;
-    }
-    if (input && !propertyType.input) {
-      return void 0;
-    }
-    if (output && !propertyType.output) {
-      return void 0;
-    }
-    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;
-      merge(objectTypeOptions, omit(objectType.arguments, "name"));
-      if (name !== null && name !== void 0 && name !== "") {
-        resultArguments.unshift(name);
-      }
-    }
-    return resultArguments.map((x) => JSON52.stringify(x));
-  }
-  fieldArguments() {
-    const fieldItem = this.find((item) => item.kind === "Field");
-    if (fieldItem) {
-      return fieldItem.arguments;
-    }
-    return void 0;
-  }
-};
-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) {
-    const newFieldElement = {
-      arguments: {},
-      from: "",
-      input: false,
-      kind: "Field",
-      model: false,
-      name: "",
-      output: false
-    };
-    fieldElement = newFieldElement;
-  }
-  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") || void 0,
-    settings: result
-  };
-}
-function createSettingElement({
-  config,
-  fieldElement,
-  line,
-  match
-}) {
-  const result = {
-    documentLine: "",
-    element: void 0
-  };
-  if (line.startsWith("@deprecated")) {
-    const DEPRECATED_PREFIX_LENGTH = 11;
-    const updatedFieldElement = {
-      ...fieldElement,
-      arguments: {
-        ...fieldElement.arguments,
-        deprecationReason: trim(line.slice(DEPRECATED_PREFIX_LENGTH))
-      }
-    };
-    result.element = updatedFieldElement;
-    return result;
-  }
-  if (line.startsWith("@complexity")) {
-    const COMPLEXITY_PREFIX_LENGTH = 11;
-    const MIN_COMPLEXITY = 1;
-    let n = Number.parseInt(trim(line.slice(COMPLEXITY_PREFIX_LENGTH)), 10);
-    if (Number.isNaN(n) || n < MIN_COMPLEXITY) {
-      n = MIN_COMPLEXITY;
-    }
-    const updatedFieldElement = {
-      ...fieldElement,
-      arguments: {
-        ...fieldElement.arguments,
-        complexity: n
-      }
+        modelFields,
+        modelNames,
+        models,
+        output: generatorOutputValue,
+        project,
+        removeTypes,
+        schema,
+        typeNames: new Set(),
     };
-    result.element = updatedFieldElement;
-    return result;
-  }
-  const name = match?.groups?.name;
-  if (!(match && name !== void 0 && 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 !== void 0 && match.groups.args !== "") {
-    const options2 = customType(match.groups.args);
-    const namespaceConfig2 = options2.namespace !== void 0 && options2.namespace !== "" ? config.fields[options2.namespace] : void 0;
-    merge(element, namespaceConfig2, options2, {
-      kind: name
-    });
-    return result;
-  }
-  if (name === "ObjectType" && match.groups?.args !== void 0 && match.groups.args !== "") {
-    element.kind = "ObjectType";
-    const options2 = customType(match.groups.args);
-    if (typeof options2[0] === "string" && options2[0] !== "") {
-      options2.name = options2[0];
-    }
-    if (isObject(options2[1])) {
-      merge(options2, options2[1]);
-    }
-    element.arguments = {
-      isAbstract: options2.isAbstract,
-      name: options2.name
-    };
-    return result;
-  }
-  if (name === "Directive" && match.groups?.args !== void 0 && match.groups.args !== "") {
-    const options2 = customType(match.groups.args);
-    merge(element, { from: "@nestjs/graphql", model: true }, options2, {
-      arguments: Array.isArray(options2.arguments) ? options2.arguments.map((s) => JSON52.stringify(s)) : options2.arguments,
-      kind: "Decorator",
-      name,
-      namespace: false
-    });
-    return result;
-  }
-  const namespace = getNamespace(name);
-  element.namespaceImport = namespace;
-  const args = match.groups?.args ?? "";
-  const options = {
-    arguments: args.split(",").map((s) => trim(s)).filter(Boolean),
-    name
-  };
-  const namespaceConfig = namespace !== void 0 && namespace !== "" ? config.fields[namespace] : void 0;
-  merge(element, namespaceConfig, 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;
-  const optionsWithName = options;
-  if (optionsWithName.name !== void 0 && optionsWithName.name !== "" && optionsWithName.name.includes(".")) {
-    result.namespaceImport = namespace;
-  }
-  if (typeof options.match === "string" || Array.isArray(options.match)) {
-    result.match = outmatch2(options.match, { separator: false });
-  }
-  return result;
-}
-function hideFieldDecorator(match) {
-  const result = {
-    arguments: [],
-    defaultImport: void 0,
-    from: "@nestjs/graphql",
-    match: void 0,
-    name: "HideField",
-    namespaceImport: void 0
-  };
-  const args = match.groups?.args;
-  if (args === void 0 || args === "") {
-    result.output = true;
-    return result;
-  }
-  if (args.includes("{") && args.includes("}")) {
-    const options = parseArgs(args);
-    result.output = Boolean(options.output);
-    result.input = Boolean(options.input);
-    if (typeof options.match === "string" || Array.isArray(options.match)) {
-      result.match = outmatch2(options.match, { separator: false });
-    }
-  } else {
-    if (/output:\s*true/.test(args)) {
-      result.output = true;
-    }
-    if (/input:\s*true/.test(args)) {
-      result.input = true;
-    }
-  }
-  return result;
-}
-function parseArgs(string) {
-  try {
-    return JSON52.parse(string);
-  } catch {
-    try {
-      return JSON52.parse(`[${string}]`);
-    } catch {
-      throw new Error(`Failed to parse: ${string}`);
-    }
-  }
-}
-function getNamespace(name) {
-  if (name === void 0 || name === null) {
-    return void 0;
-  }
-  if (typeof name !== "string") {
-    return void 0;
-  }
-  let result = name;
-  if (result === "") {
-    return void 0;
-  }
-  if (result.includes(".")) {
-    const parts = result.split(".");
-    result = parts[0] ?? "";
-  }
-  if (result === "") {
-    return void 0;
-  }
-  return result;
-}
-
-// src/handlers/model-data.ts
-function modelData(model, args) {
-  const {
-    classTransformerTypeModels,
-    config,
-    fieldSettings,
-    modelFields,
-    modelNames,
-    models
-  } = args;
-  modelNames.push(model.name);
-  models.set(model.name, model);
-  const modelFieldsValue = /* @__PURE__ */ new Map();
-  modelFields.set(model.name, modelFieldsValue);
-  const fieldSettingsValue = /* @__PURE__ */ new Map();
-  fieldSettings.set(model.name, fieldSettingsValue);
-  for (const field of model.fields) {
-    if (field.documentation !== null && field.documentation !== void 0 && field.documentation.length > 0) {
-      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);
-  }
-}
-
-// src/helpers/create-comment.ts
-function createComment(documentation, settings) {
-  const documentationLines = documentation.split("\n");
-  const commentLines = ["/**"];
-  for (const line of documentationLines) {
-    commentLines.push(` * ${line}`);
-  }
-  const fieldArgs = settings?.fieldArguments();
-  let deprecationReason;
-  if (fieldArgs === void 0) {
-    deprecationReason = void 0;
-  } else {
-    deprecationReason = fieldArgs.deprecationReason;
-  }
-  if (deprecationReason !== void 0 && deprecationReason !== null && deprecationReason.length > 0) {
-    commentLines.push(` * @deprecated ${deprecationReason}`);
-  }
-  commentLines.push(" */\n");
-  return commentLines.join("\n");
-}
-
-// src/helpers/detect-circular-deps.ts
-function buildDependencyGraph(models) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const model of models) {
-    graph.set(model.name, /* @__PURE__ */ new Set());
-  }
-  for (const model of models) {
-    const dependencies = graph.get(model.name);
-    if (!dependencies) {
-      continue;
-    }
-    for (const field of model.fields) {
-      if (field.kind === "object" && field.type !== model.name) {
-        if (graph.has(field.type)) {
-          dependencies.add(field.type);
-        }
-      }
-    }
-  }
-  return graph;
-}
-function detectCircularDependencies(graph) {
-  const circularPairs = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const recursionStack = /* @__PURE__ */ new Set();
-  const path = [];
-  function dfs(node) {
-    visited.add(node);
-    recursionStack.add(node);
-    path.push(node);
-    const dependencies = graph.get(node) ?? /* @__PURE__ */ new Set();
-    for (const dep of dependencies) {
-      if (!visited.has(dep)) {
-        dfs(dep);
-      } else if (recursionStack.has(dep)) {
-        const cycleStartIndex = path.indexOf(dep);
-        if (cycleStartIndex !== -1) {
-          const cyclePath = path.slice(cycleStartIndex);
-          for (let i = 0; i < cyclePath.length; i++) {
-            const a = cyclePath[i];
-            const b = cyclePath[(i + 1) % cyclePath.length];
-            const pair = a < b ? `${a}:${b}` : `${b}:${a}`;
-            circularPairs.add(pair);
-          }
-        }
-      }
-    }
-    path.pop();
-    recursionStack.delete(node);
-  }
-  for (const node of graph.keys()) {
-    if (!visited.has(node)) {
-      dfs(node);
-    }
-  }
-  return circularPairs;
-}
-function hasCircularDependency(circularDeps, modelA, modelB) {
-  const pair = modelA < modelB ? `${modelA}:${modelB}` : `${modelB}:${modelA}`;
-  return circularDeps.has(pair);
-}
-
-// src/helpers/get-output-type-name.ts
-function getOutputTypeName(name) {
-  return name.replace(/(?:OutputType|Output)$/, "");
-}
-
-// src/handlers/model-output-type.ts
-var nestjsGraphql = "@nestjs/graphql";
-function modelOutputType(outputType2, args) {
-  const {
-    circularDependencies,
-    config,
-    eventEmitter,
-    fieldSettings,
-    getSourceFile,
-    modelFields,
-    models,
-    output
-  } = args;
-  if (isManyAndReturnOutputType(outputType2.name)) {
-    return;
-  }
-  const model = models.get(outputType2.name);
-  ok(model, `Cannot find model by name ${outputType2.name}`);
-  const sourceFile = getSourceFile({
-    name: outputType2.name,
-    type: "model"
-  });
-  const sourceFileStructure = sourceFile.getStructure();
-  const exportDeclaration = getExportDeclaration(
-    model.name,
-    sourceFileStructure.statements
-  );
-  const importDeclarations = new ImportDeclarationMap();
-  const classStructure = {
-    decorators: [
-      {
-        arguments: [],
-        name: "ObjectType"
-      }
-    ],
-    isExported: true,
-    kind: StructureKind.Class,
-    name: outputType2.name,
-    properties: []
-  };
-  sourceFileStructure.statements.push(classStructure);
-  ok(classStructure.decorators, "classStructure.decorators is undefined");
-  const decorator = classStructure.decorators.find((d) => d.name === "ObjectType");
-  ok(decorator, "ObjectType decorator not found");
-  let modelSettings;
-  if (model.documentation !== null && model.documentation !== void 0 && model.documentation.length > 0) {
-    const objectTypeOptions = {};
-    const { documentation, settings } = createObjectSettings({
-      config,
-      text: model.documentation
-    });
-    if (documentation !== void 0 && documentation.length > 0) {
-      classStructure.leadingTrivia ??= createComment(documentation);
-      objectTypeOptions.description = documentation;
-    }
-    decorator.arguments = settings.getObjectTypeArguments(objectTypeOptions);
-    modelSettings = settings;
-  }
-  importDeclarations.add("Field", nestjsGraphql);
-  importDeclarations.add("ObjectType", nestjsGraphql);
-  const lazyTypes = /* @__PURE__ */ new Set();
-  if (config.esmCompatible) {
-    let typeRegistryPath = relativePath(
-      sourceFile.getFilePath(),
-      `${output}/type-registry.ts`
-    );
-    if (!typeRegistryPath.endsWith(".js")) {
-      typeRegistryPath += ".js";
-    }
-    importDeclarations.add("registerType", typeRegistryPath);
-    importDeclarations.add("getType", typeRegistryPath);
-  }
-  for (const field of outputType2.fields) {
-    if (config.omitModelsCount && field.name === "_count") {
-      continue;
-    }
-    let fileType = "model";
-    const { isList, location, namespace, type } = field.outputType;
-    let outputTypeName = 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: outputType2.name,
-      output: true
-    });
-    const propertySettings = settings?.getPropertyType({
-      name: outputType2.name,
-      output: true
-    });
-    const propertyType = castArray(
-      propertySettings?.name ?? getPropertyType({
-        location,
-        type: outputTypeName
-      })
-    );
-    propertyType.splice(1, propertyType.length);
-    if (field.isNullable === true && !isList) {
-      propertyType.push("null");
-    }
-    let graphqlType;
-    let useGetType = false;
-    if (fieldType === void 0) {
-      const graphqlImport = getGraphqlImport({
-        config,
-        fileType,
-        getSourceFile,
-        isId: modelField?.isId,
-        location,
-        noTypeId: config.noTypeId,
-        sourceFile,
-        typeName: outputTypeName
-      });
-      graphqlType = graphqlImport.name;
-      if (graphqlImport.name !== outputType2.name && graphqlImport.specifier !== null && graphqlImport.specifier !== void 0 && graphqlImport.specifier.length > 0) {
-        const isCircular = config.esmCompatible && location === "outputObjectTypes" && namespace === "model" && hasCircularDependency(circularDependencies, outputType2.name, outputTypeName);
-        if (isCircular) {
-          importDeclarations.add(graphqlImport.name, graphqlImport.specifier);
-          lazyTypes.add(graphqlImport.name);
-          useGetType = true;
-        } else {
-          importDeclarations.add(graphqlImport.name, graphqlImport.specifier);
-        }
-      }
-    } else {
-      graphqlType = fieldType.name;
-      importDeclarations.create({ ...fieldType });
-    }
-    const property = propertyStructure({
-      hasExclamationToken: true,
-      hasQuestionToken: location === "outputObjectTypes",
-      isList,
-      isNullable: field.isNullable,
-      name: field.name,
-      propertyType
-    });
-    if (typeof property.leadingTrivia === "string" && modelField?.documentation !== null && modelField?.documentation !== void 0 && modelField.documentation.length > 0) {
-      property.leadingTrivia += createComment(modelField.documentation, settings);
-    }
-    if (classStructure.properties !== void 0) {
-      classStructure.properties.push(property);
-    }
-    if (propertySettings !== void 0) {
-      importDeclarations.create({ ...propertySettings });
-    } else if (propertyType.some((p) => p.includes("Prisma.Decimal"))) {
-      importDeclarations.add("Prisma", config.prismaClientImport);
-    }
-    ok(property.decorators !== void 0, "property.decorators is undefined");
-    const shouldHideField = settings?.shouldHideField({ name: outputType2.name, output: true }) === 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({ arguments: [], name: "HideField" });
-    } else {
-      let typeExpression;
-      if (useGetType) {
-        typeExpression = isList ? `() => [getType('${graphqlType}')]` : `() => getType('${graphqlType}')`;
-      } else {
-        typeExpression = isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`;
-      }
-      property.decorators.push({
-        arguments: [
-          typeExpression,
-          JSON52.stringify({
-            ...settings?.fieldArguments(),
-            defaultValue: ["number", "string", "boolean"].includes(
-              typeof modelField?.default
-            ) ? modelField?.default : void 0,
-            description: modelField?.documentation !== null && modelField?.documentation !== void 0 && modelField.documentation !== "" ? modelField.documentation : void 0,
-            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(
-            setting.from && setting.from.length > 0,
-            "Missed 'from' part in configuration or field setting"
-          );
-          importDeclarations.create(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.create(decorate);
-        }
-      }
-    }
-    eventEmitter.emitSync("ClassProperty", property, {
-      isList,
-      location,
-      propertyType
-    });
-  }
-  for (const setting of modelSettings ?? []) {
-    if (shouldBeDecorated(setting)) {
-      classStructure.decorators.push({
-        arguments: setting.arguments,
-        name: setting.name
-      });
-      importDeclarations.create(setting);
-    }
-  }
-  const statements = [
-    ...importDeclarations.toStatements(),
-    classStructure
-  ];
-  if (config.esmCompatible) {
-    statements.push(`
-registerType('${outputType2.name}', ${outputType2.name});`);
-  }
-  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
-    });
-  }
-}
-function shouldBeDecorated(setting) {
-  return setting.kind === "Decorator" && (setting.output || setting.model) && !(setting.output && setting.model);
-}
-function getExportDeclaration(name, statements) {
-  return statements.find((structure) => {
-    return structure.kind === StructureKind.ExportDeclaration && structure.namedExports.some(
-      (o) => (o.alias ?? o.name) === name
-    );
-  });
-}
-
-// src/handlers/no-atomic-operations.ts
-function noAtomicOperations(eventEmitter) {
-  eventEmitter.on("BeforeInputType", beforeInputType2);
-  eventEmitter.on("BeforeGenerateFiles", beforeGenerateFiles);
-}
-function beforeInputType2(args) {
-  const { getModelName: getModelName2, inputType: inputType2 } = args;
-  for (const field of inputType2.fields) {
-    const fieldName = field.name;
-    field.inputTypes = field.inputTypes.filter((it) => {
-      const inputTypeName = it.type;
-      const modelName = getModelName2(inputTypeName);
-      const isModelNameValid = modelName !== null && modelName !== void 0 && modelName.length > 0;
-      if (isAtomicOperation(inputTypeName) || isModelNameValid && isListInput(inputTypeName, modelName, fieldName)) {
-        return false;
-      }
-      return true;
-    });
-  }
-}
-function beforeGenerateFiles(args) {
-  const { project } = args;
-  for (const sourceFile of project.getSourceFiles()) {
-    const className = sourceFile.getClass(() => true)?.getName();
-    const isClassNameValid = className !== void 0 && className !== null && className.length > 0;
-    if (isClassNameValid && 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`;
-}
-
-// src/helpers/get-enum-name.ts
-function getEnumName(referenceName) {
-  return referenceName.slice(3, -2);
-}
-
-// src/handlers/output-type.ts
-var nestjsGraphql2 = "@nestjs/graphql";
-function outputType(outputTypeArg, args) {
-  const { config, eventEmitter, fieldSettings, getModelName: getModelName2, getSourceFile, models } = args;
-  const importDeclarations = new ImportDeclarationMap();
-  const fileType = "output";
-  const modelName = getModelName2(outputTypeArg.name);
-  const model = modelName === void 0 ? void 0 : models.get(modelName);
-  const isAggregateOutput = model !== void 0 && /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(outputTypeArg.name) && outputTypeArg.name.startsWith(model.name);
-  const isCountOutput = model?.name !== void 0 && model.name !== "" && outputTypeArg.name === `${model.name}CountOutputType`;
-  if (config.emitBlocks.outputs || isCountOutput) ; else {
-    return;
-  }
-  outputTypeArg.name = getOutputTypeName(outputTypeArg.name);
-  if (isAggregateOutput) {
-    eventEmitter.emitSync("AggregateOutput", { ...args, outputType: outputTypeArg });
-  }
-  const sourceFile = getSourceFile({
-    name: outputTypeArg.name,
-    type: fileType
-  });
-  const classStructure = {
-    decorators: [
-      {
-        arguments: [],
-        name: "ObjectType"
-      }
-    ],
-    isExported: true,
-    kind: StructureKind.Class,
-    name: outputTypeArg.name,
-    properties: []
-  };
-  importDeclarations.add("Field", nestjsGraphql2);
-  importDeclarations.add("ObjectType", nestjsGraphql2);
-  for (const field of outputTypeArg.fields) {
-    const { isList, location, type } = field.outputType;
-    const outputTypeName = getOutputTypeName(type);
-    let settings;
-    if (isCountOutput) {
-      settings = void 0;
-    } else if (model === void 0) {
-      settings = void 0;
-    } else {
-      settings = fieldSettings.get(model.name)?.get(field.name);
-    }
-    const propertySettings = settings?.getPropertyType({
-      name: outputTypeArg.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 : void 0,
-      isList,
-      isNullable: field.isNullable,
-      name: field.name,
-      propertyType
-    });
-    classStructure.properties?.push(property);
-    if (propertySettings !== void 0) {
-      importDeclarations.create({ ...propertySettings });
-    } else if (propertyType.some((p) => p.includes("Prisma.Decimal"))) {
-      importDeclarations.add("Prisma", config.prismaClientImport);
-    }
-    let graphqlType;
-    const shouldHideField = settings?.shouldHideField({
-      name: outputTypeArg.name,
-      output: true
-    }) === true || config.decorate.some(
-      (d) => d.name === "HideField" && d.from === "@nestjs/graphql" && d.isMatchField(field.name) && d.isMatchType(outputTypeName)
-    );
-    const fieldType = settings?.getFieldType({
-      name: outputTypeArg.name,
-      output: true
-    });
-    if (fieldType !== void 0 && isCustomsApplicable && !shouldHideField) {
-      graphqlType = fieldType.name;
-      importDeclarations.create({ ...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 !== null && graphqlImport.specifier !== void 0 && graphqlImport.specifier.length > 0 && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputTypeArg.name && !shouldHideField || shouldHideField && referenceName === graphqlImport.name)) {
-        importDeclarations.set(graphqlImport.name, {
-          moduleSpecifier: graphqlImport.specifier,
-          namedImports: [{ name: graphqlImport.name }]
-        });
-      }
-    }
-    ok(property.decorators !== void 0, "property.decorators is undefined");
-    if (shouldHideField) {
-      importDeclarations.add("HideField", nestjsGraphql2);
-      property.decorators.push({ arguments: [], name: "HideField" });
-    } else {
-      property.decorators.push({
-        arguments: [
-          isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`,
-          JSON52.stringify({
-            ...settings?.fieldArguments(),
-            nullable: Boolean(field.isNullable)
-          })
-        ],
-        name: "Field"
-      });
-      if (isCustomsApplicable) {
-        for (const options of settings ?? []) {
-          const shouldApplyDecorator = options.kind === "Decorator" && options.output && (options.match?.(field.name) ?? true);
-          if (shouldApplyDecorator) {
-            property.decorators.push({
-              arguments: options.arguments,
-              name: options.name
-            });
-            ok(
-              options.from !== null && options.from !== void 0 && options.from.length > 0,
-              "Missed 'from' part in configuration or field setting"
-            );
-            importDeclarations.create(options);
-          }
+    if (connectCallback) {
+        await connectCallback(eventEmitter, eventArguments);
+    }
+    await eventEmitter.emit('Begin', eventArguments);
+    // Generate type registry file for ESM compatibility
+    // Must be after 'Begin' event since purgeOutput deletes all files on Begin
+    if (config.esmCompatible) {
+        generateTypeRegistry(eventArguments);
+    }
+    // Generate decimal helpers for Prisma 7+ compatibility
+    // This replaces the dependency on prisma-graphql-type-decimal
+    generateDecimalHelpers(eventArguments);
+    for (const model of datamodel.models) {
+        await eventEmitter.emit('Model', model, eventArguments);
+    }
+    // Types behaves like model
+    for (const model of datamodelTypes) {
+        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 outputTypeItem of outputObjectTypes.model) {
+        await eventEmitter.emit('ModelOutputType', outputTypeItem, eventArguments);
+    }
+    const queryOutputTypes = [];
+    for (const outputTypeItem of outputObjectTypes.prisma) {
+        if (['Query', 'Mutation'].includes(outputTypeItem.name)) {
+            queryOutputTypes.push(outputTypeItem);
+            continue;
         }
-      }
+        await eventEmitter.emit('OutputType', outputTypeItem, eventArguments);
     }
-    eventEmitter.emitSync("ClassProperty", property, {
-      isList,
-      location,
-      propertyType
-    });
-  }
-  sourceFile.set({
-    statements: [...importDeclarations.toStatements(), classStructure]
-  });
-}
-var rmdirTyped = rmdirSync$1;
-var rmdirSync = (path) => {
-  rmdirTyped(path);
-};
-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());
-  const directoryList = directories ?? [];
-  for (const directory of directoryList) {
-    try {
-      rmdirSync(directory);
-    } catch {
-    }
-  }
-}
-var ReExport = /* @__PURE__ */ ((ReExport2) => {
-  ReExport2["None"] = "None";
-  ReExport2["Directories"] = "Directories";
-  ReExport2["Single"] = "Single";
-  ReExport2["All"] = "All";
-  return ReExport2;
-})(ReExport || {});
-function reExport(emitter) {
-  emitter.on("BeforeGenerateFiles", beforeGenerateFiles2);
-}
-function beforeGenerateFiles2(args) {
-  const { config, output, project } = args;
-  const rootDirectory = project.getDirectoryOrThrow(output);
-  if (["Directories" /* Directories */, "All" /* All */].includes(config.reExport)) {
-    const directories = [...rootDirectory.getDescendantDirectories()];
-    const indexFiles = [];
-    for (const directory of directories) {
-      const sourceFiles = directory.getSourceFiles().filter((sourceFile) => sourceFile.getBaseName() !== "index.ts");
-      if (sourceFiles.length > 0) {
-        const exportDeclarations = sourceFiles.map(
-          (sourceFile) => getExportDeclaration2(directory, sourceFile)
-        );
-        indexFiles.push({
-          path: `${directory.getPath()}/index.ts`,
-          statements: exportDeclarations
-        });
-      } else {
-        const subdirs = directory.getDirectories();
-        if (subdirs.length > 0) {
-          const namespaceExportDeclarations = subdirs.map(
-            (sourceDirectory) => getNamespaceExportDeclaration(directory, sourceDirectory)
-          );
-          indexFiles.push({
-            path: `${directory.getPath()}/index.ts`,
-            statements: namespaceExportDeclarations
-          });
+    const inputTypes = (inputObjectTypes.prisma ?? []).concat(inputObjectTypes.model ?? []);
+    for (const inputTypeItem of inputTypes) {
+        const event = {
+            ...eventArguments,
+            classDecoratorName: 'InputType',
+            fileType: 'input',
+            inputType: inputTypeItem,
+        };
+        if (inputTypeItem.fields.length === 0) {
+            removeTypes.add(inputTypeItem.name);
+            continue;
         }
-      }
-    }
-    for (const { path, statements } of indexFiles) {
-      project.createSourceFile(path, { statements }, { overwrite: true });
-    }
-  }
-  if (config.reExport === "Single" /* Single */) {
-    const sourceFiles = project.getSourceFiles().filter((sourceFile) => sourceFile.getBaseName() !== "index.ts");
-    const exportDeclarations = sourceFiles.map(
-      (sourceFile) => getExportDeclaration2(rootDirectory, sourceFile)
-    );
-    rootDirectory.createSourceFile(
-      "index.ts",
-      { statements: exportDeclarations },
-      { overwrite: true }
-    );
-  }
-  if (config.reExport === "All" /* All */) {
-    const exportDeclarations = [];
-    const directories = rootDirectory.getDirectories();
-    for (const directory of directories) {
-      if (directory.getBaseName() === "node_modules") {
-        continue;
-      }
-      const indexFile = directory.getSourceFile("index.ts");
-      if (indexFile) {
-        const dirName = directory.getBaseName();
-        exportDeclarations.push({
-          kind: StructureKind.ExportDeclaration,
-          moduleSpecifier: `./${dirName}/index.js`
-        });
-      }
-    }
-    if (exportDeclarations.length > 0) {
-      rootDirectory.createSourceFile(
-        "index.ts",
-        { statements: exportDeclarations },
-        { overwrite: true }
-      );
-    }
-  }
-}
-function getExportDeclaration2(directory, sourceFile) {
-  let moduleSpecifier = directory.getRelativePathAsModuleSpecifierTo(sourceFile);
-  if (!moduleSpecifier.endsWith(".js") && !moduleSpecifier.endsWith(".ts")) {
-    moduleSpecifier += ".js";
-  } else if (moduleSpecifier.endsWith(".ts")) {
-    moduleSpecifier = `${moduleSpecifier.slice(0, -3)}.js`;
-  }
-  return {
-    kind: StructureKind.ExportDeclaration,
-    moduleSpecifier
-  };
-}
-function getNamespaceExportDeclaration(directory, sourceDirectory) {
-  let moduleSpecifier = directory.getRelativePathAsModuleSpecifierTo(sourceDirectory);
-  if (!moduleSpecifier.endsWith("/index.js")) {
-    moduleSpecifier += "/index.js";
-  }
-  return {
-    kind: StructureKind.ExportDeclaration,
-    moduleSpecifier
-  };
-}
-
-// src/handlers/register-all-types.ts
-function generateRegisterAllTypes(args) {
-  const { config, output, project } = args;
-  if (!config.esmCompatible) {
-    return;
-  }
-  const rootDirectory = project.getDirectory(output) ?? project.createDirectory(output);
-  const sourceFile = rootDirectory.createSourceFile("register-all-types.ts", void 0, {
-    overwrite: true
-  });
-  const importPaths = [];
-  const typeNames = [];
-  const allSourceFiles = project.getSourceFiles(`${output}/**/*.ts`);
-  for (const file of allSourceFiles) {
-    const filePath = file.getFilePath();
-    if (filePath.endsWith("type-registry.ts") || filePath.endsWith("register-all-types.ts") || filePath.endsWith("index.ts")) {
-      continue;
+        await eventEmitter.emit('BeforeInputType', event);
+        await eventEmitter.emit('InputType', event);
     }
-    const fileText = file.getText();
-    const registerMatch = /registerType\(['"]([^'"]+)['"]/.exec(fileText);
-    if (registerMatch) {
-      let relPath = relativePath(sourceFile.getFilePath(), filePath);
-      if (!relPath.endsWith(".js")) {
-        relPath += ".js";
-      }
-      importPaths.push(relPath);
-      typeNames.push(registerMatch[1]);
-    }
-  }
-  importPaths.sort();
-  typeNames.sort();
-  const fileContent = `/**
- * ESM Type Registration Module
- *
- * This file registers all generated types with the type registry to solve
- * ESM circular dependency issues. In ESM, unlike CommonJS, circular imports
- * can result in undefined values because modules are evaluated in a different order.
- *
- * IMPORTANT: Import this file at the very top of your application entry point,
- * BEFORE any other code that uses the generated types.
- *
- * Example usage in main.ts:
- *
- *   // This MUST be the first import
- *   import './@generated/register-all-types.js';
- *
- *   // Now you can safely import and use generated types
- *   import { NestFactory } from '@nestjs/core';
- *   import { AppModule } from './app.module.js';
- *
- * Why this is needed:
- * - ESM uses "live bindings" where imports reference the actual export
- * - With circular deps (User -> Post -> User), one module isn't ready when imported
- * - CJS would give a partial object that fills in later; ESM gives undefined
- * - This registry pattern defers type resolution until runtime when all modules are loaded
- */
-
-import { markRegistrationComplete } from './type-registry.js';
-
-// Import all generated type files to trigger their registerType() calls
-// These are side-effect imports that populate the type registry
-${importPaths.map((p) => `import '${p}';`).join("\n")}
-
-// Mark registration as complete to enable warning messages
-markRegistrationComplete();
-
-// Export type names for validation (optional)
-export const registeredTypes = [
-${typeNames.map((n) => `  '${n}',`).join("\n")}
-] as const;
-
-export type RegisteredTypeName = typeof registeredTypes[number];
-`;
-  sourceFile.addStatements(fileContent);
-}
-
-// src/handlers/prisma-enum-doc.ts
-function extractEnumValueDocs(values) {
-  return Object.fromEntries(
-    values.map((value) => {
-      const { name } = value;
-      const { documentation } = value;
-      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)
-  );
-}
-
-// src/handlers/register-enum.ts
-function registerEnum(enumType, args) {
-  const { config, enums, getSourceFile } = args;
-  const enumTypeAsRecord = enumType;
-  const rawName = enumTypeAsRecord.name;
-  const enumName = typeof rawName === "string" ? rawName : String(rawName);
-  const enumValue = enums[enumName];
-  if (!config.emitBlocks.prismaEnums && enumValue === void 0) {
-    return;
-  }
-  const dataModelEnum = enumValue;
-  const enumTypesData = dataModelEnum?.values ?? [];
-  const sourceFile = getSourceFile({
-    name: enumName,
-    type: "enum"
-  });
-  const importDeclarations = new ImportDeclarationMap();
-  importDeclarations.set("registerEnumType", {
-    moduleSpecifier: "@nestjs/graphql",
-    namedImports: [{ name: "registerEnumType" }]
-  });
-  const valuesMap = extractEnumValueDocs(enumTypesData);
-  const filteredValuesMap = Object.fromEntries(
-    Object.entries(valuesMap).filter(([, v]) => Object.keys(v).length > 0)
-  );
-  const hasValuesMap = Object.keys(filteredValuesMap).length > 0;
-  const formattedValuesMap = hasValuesMap ? JSON.stringify(filteredValuesMap, null, 2).replace(/"([^"]+)":/g, "$1:") : "";
-  const valuesMapEntry = hasValuesMap ? `, valuesMap: ${formattedValuesMap}` : "";
-  const enumTypeRecord = enumType;
-  const rawValues = enumTypeRecord.values;
-  const enumValues = Array.isArray(rawValues) ? rawValues.map((v) => String(v)) : [];
-  const enumStructure = {
-    isExported: true,
-    kind: StructureKind.Enum,
-    members: enumValues.map((v) => ({
-      initializer: JSON.stringify(v),
-      name: v
-    })),
-    name: enumName
-  };
-  const enumTypeName = enumName;
-  sourceFile.set({
-    statements: [
-      ...importDeclarations.toStatements(),
-      enumStructure,
-      "\n",
-      `registerEnumType(${enumTypeName}, { name: '${enumTypeName}', description: ${JSON.stringify(
-        dataModelEnum?.documentation
-      )}${valuesMapEntry} })`
-    ]
-  });
-}
-
-// src/handlers/require-single-fields-in-whereunique-input.ts
-function requireSingleFieldsInWhereUniqueInput(eventEmitter) {
-  eventEmitter.on("BeforeInputType", beforeInputType3);
-}
-function beforeInputType3(args) {
-  const { inputType: inputType2 } = args;
-  if (!isWhereUniqueInputType(inputType2.name) || inputType2.fields.length !== 1) {
-    return;
-  }
-  for (const field of inputType2.fields) {
-    field.isRequired = true;
-    field.isNullable = false;
-  }
-}
-
-// src/handlers/type-registry.ts
-function generateTypeRegistry(args) {
-  const { config, output, project } = args;
-  if (!config.esmCompatible) {
-    return;
-  }
-  const rootDirectory = project.getDirectory(output) ?? project.createDirectory(output);
-  const sourceFile = rootDirectory.createSourceFile("type-registry.ts", void 0, {
-    overwrite: true
-  });
-  const registryCode = `/**
- * Type Registry for ESM Circular Dependency Resolution
- *
- * In ESM, circular dependencies behave differently than CommonJS:
- * - CJS: Modules get a partial/incomplete export object that gets filled in
- * - ESM: Imports are "live bindings" but can be undefined if not yet initialized
- *
- * This registry solves this by:
- * 1. Deferring type resolution until runtime (after all modules are loaded)
- * 2. Providing a forwardRef pattern for GraphQL field type declarations
- * 3. Validating all types are registered before they're needed
- */
-
-const registry = new Map<string, unknown>();
-const pendingResolutions = new Map<string, Array<(type: unknown) => void>>();
-let registrationComplete = false;
-
-/**
- * Register a type with the registry.
- * This should be called at module load time after the class is defined.
- */
-export function registerType(name: string, type: unknown): void {
-  if (type === undefined) {
-    console.warn(\`[nestjs-prisma-graphql] Warning: Registering undefined type for "\${name}". This may indicate a circular dependency issue.\`);
-  }
-  registry.set(name, type);
-
-  // Resolve any pending forwardRef callbacks
-  const pending = pendingResolutions.get(name);
-  if (pending) {
-    for (const callback of pending) {
-      callback(type);
-    }
-    pendingResolutions.delete(name);
-  }
-}
-
-/**
- * Get a type from the registry.
- * Returns the type if registered, undefined otherwise.
- *
- * For use in \\@Field(() => getType('TypeName')) decorators.
- */
-export function getType<T = unknown>(name: string): T {
-  const type = registry.get(name);
-  if (type === undefined && registrationComplete) {
-    console.warn(\`[nestjs-prisma-graphql] Warning: Type "\${name}" not found in registry. Ensure register-all-types is imported before using generated types.\`);
-  }
-  return type as T;
-}
-
-/**
- * Create a forward reference to a type that may not be registered yet.
- * This is useful for handling circular dependencies where type A references type B
- * and type B references type A.
- *
- * Usage: \\@Field(() => forwardRef('Post'))
- */
-export function forwardRef<T = unknown>(name: string): () => T {
-  return () => {
-    const type = registry.get(name);
-    if (type === undefined) {
-      throw new Error(
-        \`[nestjs-prisma-graphql] Type "\${name}" not registered. \\n\` +
-        \`This usually means:\\n\` +
-        \`  1. The register-all-types.ts file was not imported early enough\\n\` +
-        \`  2. There's a circular dependency that couldn't be resolved\\n\` +
-        \`  3. The type file failed to load\\n\\n\` +
-        \`Make sure to import 'register-all-types' at the top of your main.ts or app.module.ts\`
-      );
-    }
-    return type as T;
-  };
-}
-
-/**
- * Lazily resolve a type, returning a thunk that can be called later.
- * This is the safest pattern for circular references in ESM.
- *
- * Usage: \\@Field(lazyType('Post'))
- */
-export function lazyType<T = unknown>(name: string): () => T {
-  return () => getType<T>(name);
-}
-
-/**
- * Mark registration as complete. Called after all types are imported.
- * This enables warning messages for missing types.
- */
-export function markRegistrationComplete(): void {
-  registrationComplete = true;
-
-  // Warn about any unresolved forward refs
-  if (pendingResolutions.size > 0) {
-    const missing = Array.from(pendingResolutions.keys()).join(', ');
-    console.warn(\`[nestjs-prisma-graphql] Warning: Unresolved forward references: \${missing}\`);
-  }
-}
-
-/**
- * Get all registered type names (useful for debugging)
- */
-export function getRegisteredTypes(): string[] {
-  return Array.from(registry.keys());
-}
-
-/**
- * Check if a type is registered
- */
-export function isTypeRegistered(name: string): boolean {
-  return registry.has(name);
-}
-
-/**
- * Validate that all expected types are registered.
- * Throws an error if any types are missing.
- */
-export function validateRegistry(expectedTypes: string[]): void {
-  const missing = expectedTypes.filter(name => !registry.has(name));
-  if (missing.length > 0) {
-    throw new Error(
-      \`[nestjs-prisma-graphql] Missing type registrations: \${missing.join(', ')}\\n\` +
-      \`Ensure register-all-types.ts is imported before using these types.\`
-    );
-  }
-}
-`;
-  sourceFile.addStatements(registryCode);
-}
-
-// src/handlers/warning.ts
-var globalConsole = globalThis.console;
-var log = (msg) => {
-  globalConsole.log(msg);
-};
-function warning(message) {
-  if (Array.isArray(message)) {
-    log("nestjs-prisma-graphql:");
-    log(message.join("\n"));
-  } else {
-    log(`nestjs-prisma-graphql: ${message}`);
-  }
-}
-
-// src/helpers/create-emit-blocks.ts
-var allEmmittedBlocks = [
-  "prismaEnums",
-  "schemaEnums",
-  "models",
-  "inputs",
-  "args",
-  "outputs"
-];
-var blocksDependencyMap = {
-  args: ["args", "inputs", "prismaEnums"],
-  enums: ["schemaEnums", "prismaEnums"],
-  inputs: ["inputs", "prismaEnums"],
-  models: ["models", "schemaEnums"],
-  outputs: ["outputs"]
-};
-function createEmitBlocks(data) {
-  if (!data) {
-    const entries = allEmmittedBlocks.map((block) => [block, true]);
-    const allBlocks = Object.fromEntries(entries);
-    return allBlocks;
-  }
-  const initialBlocks = {};
-  let currentBlocks = initialBlocks;
-  for (const block of data) {
-    if (!Object.keys(blocksDependencyMap).includes(block)) {
-      continue;
-    }
-    const blockEntries = blocksDependencyMap[block].map(
-      (emittedBlock) => [emittedBlock, true]
-    );
-    const newBlocks = Object.fromEntries(blockEntries);
-    currentBlocks = {
-      ...currentBlocks,
-      ...newBlocks
-    };
-  }
-  return currentBlocks;
-}
-
-// src/helpers/create-config.ts
-function createConfig(data) {
-  const config = merge({}, unflatten(data, { delimiter: "_" }));
-  const $warnings = [];
-  const defaultPattern = `{model}/{name}.{type}.ts`;
-  const outputFilePatternValue = config.outputFilePattern;
-  const configOutputFilePattern = typeof outputFilePatternValue === "string" ? outputFilePatternValue : defaultPattern;
-  const sanitizedStep1 = configOutputFilePattern.replaceAll("..", "/").replaceAll(/\/+/g, "/");
-  const outputFilePattern = trim(sanitizedStep1, "/");
-  if (outputFilePattern !== configOutputFilePattern) {
-    $warnings.push(
-      `Due to invalid filepath 'outputFilePattern' changed to '${outputFilePattern}'`
-    );
-  }
-  if (config.reExportAll !== void 0 && config.reExportAll !== null && config.reExportAll !== false) {
-    $warnings.push(`Option 'reExportAll' is deprecated, use 'reExport' instead`);
-    if (toBoolean(config.reExportAll)) {
-      config.reExport = "All";
-    }
-  }
-  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 decorateConfig = config.decorate !== void 0 && config.decorate !== null ? config.decorate : {};
-  const configDecorate = Object.values(decorateConfig);
-  for (const element of configDecorate) {
-    if (element === void 0 || element === null) {
-      continue;
-    }
-    ok(
-      element.from !== void 0 && element.from !== "" && element.name !== void 0 && element.name !== "",
-      `Missed 'from' or 'name' part in configuration for decorate`
-    );
-    decorate.push({
-      arguments: element.arguments !== void 0 && element.arguments !== "" ? JSON52.parse(element.arguments) : void 0,
-      defaultImport: toBoolean(element.defaultImport) ? true : element.defaultImport,
-      from: element.from,
-      isMatchField: outmatch2(element.field, { separator: false }),
-      isMatchType: outmatch2(element.type, { separator: false }),
-      name: element.name,
-      namedImport: toBoolean(element.namedImport),
-      namespaceImport: element.namespaceImport
-    });
-  }
-  const customImport = [];
-  const customImportConfig = config.customImport !== void 0 && config.customImport !== null ? config.customImport : {};
-  const configCustomImport = Object.values(customImportConfig);
-  for (const element of configCustomImport) {
-    if (element === void 0 || element === null) {
-      continue;
-    }
-    ok(
-      element.from !== void 0 && element.from !== "" && element.name !== void 0 && 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),
-    esmCompatible: toBoolean(config.esmCompatible),
-    fields,
-    graphqlScalars: config.graphqlScalars ?? {},
-    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)] ?? "None" /* None */,
-    requireSingleFieldsInWhereUniqueInput: toBoolean(
-      config.requireSingleFieldsInWhereUniqueInput
-    ),
-    tsConfigFilePath: createTsConfigFilePathValue(config.tsConfigFilePath),
-    unsafeCompatibleWhereUniqueInput: toBoolean(config.unsafeCompatibleWhereUniqueInput),
-    useInputType: createUseInputType(
-      config.useInputType
-    )
-  };
-}
-var existsSyncTyped = existsSync;
-var tsConfigFileExistsRaw = memoize((filePath) => {
-  const exists = existsSyncTyped(filePath);
-  return exists;
-});
-var tsConfigFileExists = tsConfigFileExistsRaw;
-function createTsConfigFilePathValue(value) {
-  if (typeof value === "string" && value !== "") {
-    return value;
-  }
-  const fileExists = tsConfigFileExists("tsconfig.json");
-  if (fileExists) {
-    return "tsconfig.json";
-  }
-  return void 0;
-}
-function createPrismaImport(value) {
-  if (typeof value === "string" && value !== "") {
-    return value;
-  }
-  return "@prisma/client";
-}
-function createUseInputType(data) {
-  if (data === void 0 || data === null) {
-    return [];
-  }
-  const result = [];
-  for (const [typeName, useInputs] of Object.entries(data)) {
-    const entry = {
-      ALL: void 0,
-      typeName
-    };
-    if (useInputs.ALL !== void 0 && 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: getModelName2, name, template, type } = args;
-  const rawPath = pupa(template, {
-    get model() {
-      const result = getModelName2(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);
+    for (const outputTypeItem of queryOutputTypes) {
+        for (const field of outputTypeItem.fields) {
+            await eventEmitter.emit('ArgsType', field, eventArguments);
         }
-      }
-      return result;
-    },
-    plural: {
-      get type() {
-        return pluralize(type);
-      }
-    },
-    type
-  });
-  return rawPath.split("/").map((segment) => filenamify(segment, { replacement: "-" })).join("/");
-}
-
-// src/helpers/factory-get-source-file.ts
-function factoryGetSourceFile(args) {
-  const { getModelName: getModelName2, output, outputFilePattern, project } = args;
-  return function getSourceFile(getSourceFileArgs) {
-    const { name, type } = getSourceFileArgs;
-    let filePath = generateFileName({
-      getModelName: getModelName2,
-      name,
-      template: outputFilePattern,
-      type
-    });
-    filePath = `${output}/${filePath}`;
-    return project.getSourceFile(filePath) ?? project.createSourceFile(filePath, void 0, { overwrite: true });
-  };
-}
-var 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);
-var endsWithKeywords = [
-  "Aggregate",
-  "GroupBy",
-  "CreateOne",
-  "CreateMany",
-  "DeleteMany",
-  "DeleteOne",
-  "FindMany",
-  "FindOne",
-  "FindUnique",
-  "UpdateMany",
-  "UpdateOne",
-  "UpsertOne"
-];
-var 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 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 (test !== void 0 && modelNames.includes(test)) {
-      return test;
     }
-  }
-  for (const keyword of endsWithKeywords) {
-    const test = name.split(keyword).at(-1);
-    if (test !== void 0 && modelNames.includes(test)) {
-      return test;
-    }
-  }
-  for (const [start, end2] of middleKeywords) {
-    let test = name.slice(start.length).slice(0, -end2.length);
-    if (modelNames.includes(test) && name.startsWith(start) && name.endsWith(end2)) {
-      return test;
-    }
-    test = name.slice(0, -(start + end2).length);
-    if (modelNames.includes(test) && name.endsWith(start + end2)) {
-      return test;
-    }
-  }
-  if (name.endsWith("CompoundUniqueInput")) {
-    const test = name.slice(0, -19);
-    const models = modelNames.filter((x) => test.startsWith(x)).sort((a, b) => b.length - a.length);
-    return models[0];
-  }
-  if (name.endsWith("Count")) {
-    const test = name.slice(0, -5);
-    if (modelNames.includes(test)) {
-      return test;
-    }
-  }
-  return void 0;
-}
-
-// src/generate.ts
-var createRequireTyped = createRequire;
-var requireCjs = createRequireTyped(String(import.meta.url));
-var AwaitEventEmitter = requireCjs(
-  "await-event-emitter"
-);
-var AwaitEventEmitterClass = AwaitEventEmitter.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 eventEmitter = new AwaitEventEmitterClass();
-  eventEmitter.on("Warning", warning);
-  if (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);
-  }
-  if (config.emitBlocks.models) {
-    eventEmitter.on("ModelOutputType", modelOutputType);
-  }
-  if (config.emitBlocks.outputs) {
-    eventEmitter.on("AggregateOutput", createAggregateInput);
-  }
-  if (config.emitBlocks.inputs) {
-    eventEmitter.on("InputType", inputType);
-  }
-  if (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 !== true) {
-    project.addSourceFilesAtPaths([
-      `${generatorOutputValue}/**/*.ts`,
-      `!${generatorOutputValue}/**/*.d.ts`
-    ]);
-  }
-  if (config.combineScalarFilters) {
-    combineScalarFilters(eventEmitter);
-  }
-  if (config.noAtomicOperations) {
-    noAtomicOperations(eventEmitter);
-  }
-  if (config.reExport !== "None" /* None */) {
-    reExport(eventEmitter);
-  }
-  if (config.emitSingle) {
-    emitSingle(eventEmitter);
-  }
-  if (config.purgeOutput) {
-    purgeOutput(eventEmitter);
-  }
-  if (config.requireSingleFieldsInWhereUniqueInput) {
-    requireSingleFieldsInWhereUniqueInput(eventEmitter);
-  }
-  const models = /* @__PURE__ */ new Map();
-  const modelNames = [];
-  const modelFields = /* @__PURE__ */ new Map();
-  const fieldSettings = /* @__PURE__ */ new Map();
-  const getModelName2 = createGetModelName(modelNames);
-  const getSourceFile = factoryGetSourceFile({
-    getModelName: getModelName2,
-    output: generatorOutputValue,
-    outputFilePattern: config.outputFilePattern,
-    project
-  });
-  const { datamodel, schema } = JSON.parse(JSON.stringify(dmmf));
-  const removeTypes = /* @__PURE__ */ new Set();
-  const datamodelTypes = datamodel.types ?? [];
-  const allModels = [...datamodel.models, ...datamodelTypes];
-  const dependencyGraph = buildDependencyGraph(allModels);
-  const circularDependencies = detectCircularDependencies(dependencyGraph);
-  const eventArguments = {
-    circularDependencies,
-    classTransformerTypeModels: /* @__PURE__ */ new Set(),
-    config,
-    enums: mapKeys(datamodel.enums, (x) => x.name),
-    eventEmitter,
-    fieldSettings,
-    getModelName: getModelName2,
-    getSourceFile,
-    modelFields,
-    modelNames,
-    models,
-    output: generatorOutputValue,
-    project,
-    removeTypes,
-    schema,
-    typeNames: /* @__PURE__ */ new Set()
-  };
-  if (connectCallback) {
-    await connectCallback(eventEmitter, eventArguments);
-  }
-  await eventEmitter.emit("Begin", eventArguments);
-  if (config.esmCompatible) {
-    generateTypeRegistry(eventArguments);
-  }
-  generateDecimalHelpers(eventArguments);
-  for (const model of datamodel.models) {
-    await eventEmitter.emit("Model", model, eventArguments);
-  }
-  for (const model of datamodelTypes) {
-    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 outputTypeItem of outputObjectTypes.model) {
-    await eventEmitter.emit("ModelOutputType", outputTypeItem, eventArguments);
-  }
-  const queryOutputTypes = [];
-  for (const outputTypeItem of outputObjectTypes.prisma) {
-    if (["Query", "Mutation"].includes(outputTypeItem.name)) {
-      queryOutputTypes.push(outputTypeItem);
-      continue;
-    }
-    await eventEmitter.emit("OutputType", outputTypeItem, eventArguments);
-  }
-  const inputTypes = (inputObjectTypes.prisma ?? []).concat(inputObjectTypes.model ?? []);
-  for (const inputTypeItem of inputTypes) {
-    const event = {
-      ...eventArguments,
-      classDecoratorName: "InputType",
-      fileType: "input",
-      inputType: inputTypeItem
-    };
-    if (inputTypeItem.fields.length === 0) {
-      removeTypes.add(inputTypeItem.name);
-      continue;
+    // Pre-save processing steps for ESM compatibility
+    // Must run BEFORE GenerateFiles so created files are included in the save
+    if (config.esmCompatible) {
+        // 1. Generate barrel exports (index.ts files) if reExport="None"
+        generateBarrelExports(eventArguments);
+        // 2. Add .js extensions and convert type imports for ESM
+        postProcessImports(eventArguments);
+        // 3. Patch type-registry and add @ts-nocheck
+        patchTypeRegistry(eventArguments);
+        // 4. Generate register-all-types file
+        // Must be last so it can scan all final files with registerType()
+        generateRegisterAllTypes(eventArguments);
     }
-    await eventEmitter.emit("BeforeInputType", event);
-    await eventEmitter.emit("InputType", event);
-  }
-  for (const outputTypeItem of queryOutputTypes) {
-    for (const field of outputTypeItem.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);
     }
-  }
-  if (config.esmCompatible) {
-    generateRegisterAllTypes(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);
-  }
 }
-
-export { generate };
-//# sourceMappingURL=generate.js.map
 //# sourceMappingURL=generate.js.map