@pegasusheavy/nestjs-prisma-graphql 1.2.3 → 1.4.1

package/dist/index.js

@@ -1,10 +1,10 @@
-import { existsSync, readdirSync, rmdirSync } from 'fs';
+import { existsSync, readdirSync, rmdirSync as rmdirSync$1 } from 'fs';
 import { createRequire } from 'module';
 import { arch, platform } from 'os';
 import generatorHelper from '@prisma/generator-helper';
-import { ok } from 'assert';
 import { memoize, mapKeys, merge, trim, castArray, uniqWith, isEqual, countBy, startCase, camelCase, keyBy, remove, partition, kebabCase, isObject, omit, cloneDeep } from 'lodash-es';
 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';
@@ -14,6 +14,12 @@ import filenamify from 'filenamify';
 import pluralize from 'pluralize';
 
 // src/index.ts
+function ok(value, message) {
+  ok$1(
+    value,
+    message
+  );
+}
 
 // src/helpers/is-many-and-return.ts
 function isManyAndReturnOutputType(name) {
@@ -32,8 +38,10 @@ function argsType(field, args) {
   if (["queryRaw", "executeRaw"].includes(field.name)) {
     return;
   }
-  if (isManyAndReturnOutputType(field.name)) return;
-  const { eventEmitter, typeNames, getModelName: getModelName2 } = args;
+  if (isManyAndReturnOutputType(field.name)) {
+    return;
+  }
+  const { eventEmitter, getModelName: getModelName2, typeNames } = args;
   let className = pascalCase(`${field.name}Args`);
   const modelName = getModelName2(className) ?? "";
   switch (className) {
@@ -48,8 +56,8 @@ function argsType(field, args) {
   }
   const inputType2 = {
     constraints: { maxNumFields: null, minNumFields: null },
-    name: className,
-    fields: [...field.args]
+    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"];
@@ -64,24 +72,24 @@ function argsType(field, args) {
         continue;
       }
       inputType2.fields.push({
-        name: `_${name.toLowerCase()}`,
-        isRequired: false,
-        isNullable: true,
         inputTypes: [
           {
+            isList: false,
             location: "inputObjectTypes",
-            type: `${modelName}${name}AggregateInput`,
-            isList: false
+            type: `${modelName}${name}AggregateInput`
           }
-        ]
+        ],
+        isNullable: true,
+        isRequired: false,
+        name: `_${name.toLowerCase()}`
       });
     }
   }
   eventEmitter.emitSync("InputType", {
     ...args,
-    inputType: inputType2,
+    classDecoratorName: "ArgsType",
     fileType: "args",
-    classDecoratorName: "ArgsType"
+    inputType: inputType2
   });
 }
 
@@ -106,7 +114,7 @@ function beforeGenerateField(field) {
     if (fieldInput.location !== "inputObjectTypes") {
       continue;
     }
-    const fieldInputType = String(fieldInput.type);
+    const fieldInputType = fieldInput.type;
     if (isContainBogus(fieldInputType)) {
       fieldInput.type = replaceBogus(fieldInputType);
     }
@@ -197,32 +205,98 @@ function createAggregateInput(args) {
   const className = `${outputType2.name}Input`;
   const inputType2 = {
     constraints: { maxNumFields: null, minNumFields: null },
-    name: className,
     fields: outputType2.fields.map((x) => ({
-      name: x.name,
-      isNullable: x.isNullable ?? true,
-      isRequired: false,
       inputTypes: [
         {
           isList: false,
-          type: "true",
-          location: "scalar"
+          location: "scalar",
+          type: "true"
         }
-      ]
-    }))
+      ],
+      isNullable: x.isNullable ?? true,
+      isRequired: false,
+      name: x.name
+    })),
+    name: className
   };
   eventEmitter.emitSync("InputType", {
     ...args,
-    inputType: inputType2,
+    classDecoratorName: "InputType",
     fileType: "input",
-    classDecoratorName: "InputType"
+    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 { location, isList, propertyType } = eventArguments;
+  const { isList, location, propertyType } = eventArguments;
   if (["inputObjectTypes", "outputObjectTypes"].includes(location) && !isList) {
     const [safeTypes, instanceofTypes] = partition(
       propertyType,
@@ -235,7 +309,7 @@ function classProperty(property, eventArguments) {
 var ImportDeclarationMap = class extends Map {
   add(name, value, isTypeOnly) {
     if (!this.has(name)) {
-      const structure = typeof value === "string" ? { moduleSpecifier: value, namedImports: [{ name }], isTypeOnly } : value;
+      const structure = typeof value === "string" ? { isTypeOnly, moduleSpecifier: value, namedImports: [{ name }] } : value;
       this.set(name, structure);
     }
   }
@@ -246,43 +320,46 @@ var ImportDeclarationMap = class extends Map {
     const typeOnlyKey = `type:${name}`;
     if (!this.has(typeOnlyKey) && !this.has(name)) {
       this.set(typeOnlyKey, {
+        isTypeOnly: true,
         moduleSpecifier,
-        namedImports: [{ name }],
-        isTypeOnly: true
+        namedImports: [{ name }]
       });
     }
   }
   create(args) {
-    const { from, defaultImport, namespaceImport, namedImport, isTypeOnly } = args;
-    let name = args.name;
+    const { defaultImport, from, isTypeOnly, namedImport, namespaceImport } = args;
+    let { name } = args;
     const value = {
+      defaultImport: void 0,
+      isTypeOnly,
       moduleSpecifier: from,
       namedImports: [],
-      defaultImport: void 0,
-      namespaceImport: void 0,
-      isTypeOnly
+      namespaceImport: void 0
     };
-    if (namedImport === true && namespaceImport) {
+    if (namedImport === true && namespaceImport !== void 0) {
       value.namedImports = [{ name: namespaceImport }];
       name = namespaceImport;
-    } else if (defaultImport) {
+    } 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;
-    } else if (namespaceImport) {
-      value.namespaceImport = namespaceImport;
-      name = namespaceImport;
-    } else {
-      value.namedImports = [{ name }];
     }
-    const key = isTypeOnly ? `type:${name}` : name;
-    if (!this.has(key)) {
-      this.set(key, value);
+    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) {
+    while (result.value !== void 0) {
       yield {
         ...result.value,
         kind: StructureKind.ImportDeclaration
@@ -313,8 +390,8 @@ async function generateFiles(args) {
             for (const decorator of property.decorators ?? []) {
               const fullName = classDeclaration?.getProperty(property.name)?.getDecorator(decorator.name)?.getFullName();
               ok(
-                fullName,
-                `Cannot get full name of decorator of class ${statement.name}`
+                fullName !== void 0,
+                `Cannot get full name of decorator of class ${String(statement.name)}`
               );
               decorator.name = fullName;
             }
@@ -377,8 +454,13 @@ async function generateFiles(args) {
       statements: [...imports.toStatements(), ...enums, ...classes]
     });
   }
-  const sourceFileCount = project.getSourceFiles().length;
-  console.log(
+  const sourceFiles = project.getSourceFiles();
+  const sourceFileCount = sourceFiles.length;
+  const globalConsole3 = globalThis.console;
+  const logMessage = (msg) => {
+    globalConsole3.log(msg);
+  };
+  logMessage(
     `nestjs-prisma-graphql: saving ${String(sourceFileCount)} source files to ${output}`
   );
   if (sourceFileCount === 0) {
@@ -401,7 +483,21 @@ async function generateFiles(args) {
       eventEmitter.emitSync("Warning", errors);
     }
   } else {
-    await project.save();
+    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();
+    }
   }
 }
 
@@ -417,17 +513,23 @@ function fileTypeByLocation(fieldLocation) {
     case "enumTypes": {
       return "enum";
     }
+    case "fieldRefTypes":
+    case "scalar":
+    default: {
+      return "object";
+    }
   }
-  return "object";
 }
 function relativePath(from, to) {
-  if (!from.startsWith("/")) {
-    from = `/${from}`;
+  let fromPath = from;
+  let toPath = to;
+  if (!fromPath.startsWith("/")) {
+    fromPath = `/${fromPath}`;
   }
-  if (!to.startsWith("/")) {
-    to = `/${to}`;
+  if (!toPath.startsWith("/")) {
+    toPath = `/${toPath}`;
   }
-  let result = getRelativePath(from, to);
+  let result = getRelativePath(fromPath, toPath);
   if (!result.startsWith(".")) {
     result = `./${result}`;
   }
@@ -496,7 +598,7 @@ function getGraphqlImport(args) {
 }
 function getGraphqlInputType(inputTypes, pattern) {
   let result;
-  inputTypes = inputTypes.filter((t) => !["null", "Null"].includes(String(t.type)));
+  inputTypes = inputTypes.filter((t) => !["null", "Null"].includes(t.type));
   inputTypes = uniqWith(inputTypes, isEqual);
   if (inputTypes.length === 1) {
     return inputTypes[0];
@@ -509,46 +611,44 @@ function getGraphqlInputType(inputTypes, pattern) {
       return result;
     }
   }
-  if (pattern) {
+  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(String(x.type)));
-      if (result) {
+      result = inputTypes.find((x) => isMatch(x.type));
+      if (result !== void 0) {
         return result;
       }
     }
-    result = inputTypes.find((x) => String(x.type).includes(pattern));
-    if (result) {
+    result = inputTypes.find((x) => x.type.includes(pattern));
+    if (result !== void 0) {
       return result;
     }
   }
   result = inputTypes.find((x) => x.location === "inputObjectTypes");
-  if (result) {
+  if (result !== void 0) {
     return result;
   }
-  if (countTypes.enumTypes && countTypes.scalar && inputTypes.some((x) => x.type === "Json" && x.location === "scalar")) {
+  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) {
+    if (result !== void 0) {
       return result;
     }
   }
-  if ((countTypes.scalar >= 1 || countTypes.enumTypes >= 1) && countTypes.fieldRefTypes === 1) {
+  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) {
+    if (result !== void 0) {
       return result;
     }
-    result = inputTypes.find(
-      (x) => x.location === "scalar" || x.location === "enumTypes"
-    );
-    if (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.map((x) => x.type).join(", ") || "zero length inputTypes"}`
+    `Cannot get matching input type from ${inputTypes.length > 0 ? inputTypes.map((x) => x.type).join(", ") : "zero length inputTypes"}`
   );
 }
 
@@ -589,7 +689,7 @@ function getPropertyType(args) {
     return [type];
   }
   if (location === "enumTypes") {
-    const enumType = "`${" + type + "}`";
+    const enumType = `\`\${${type}}\``;
     return [enumType];
   }
   if (location === "scalar") {
@@ -610,8 +710,8 @@ function getWhereUniqueAtLeastKeys(model) {
   return names;
 }
 function createFieldName(args) {
-  const { name, fields } = args;
-  return name || fields.join("_");
+  const { fields, name } = args;
+  return name !== null && name !== void 0 && name.length > 0 ? name : fields.join("_");
 }
 
 // src/helpers/is-where-unique-input-type.ts
@@ -620,29 +720,28 @@ function isWhereUniqueInputType(name) {
 }
 function propertyStructure(args) {
   const {
+    hasExclamationToken,
+    hasQuestionToken,
+    isList,
     isNullable,
-    propertyType,
     name,
-    isList,
-    hasQuestionToken,
-    hasExclamationToken
+    propertyType
   } = args;
-  const type = propertyType.map((type2) => isList ? `Array<${type2}>` : type2).join(" | ");
+  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,
-    hasQuestionToken: hasQuestionToken ?? isNullable,
-    hasExclamationToken: hasExclamationToken ?? !isNullable,
-    decorators: [],
-    leadingTrivia: "\n"
+    type: typeString
   };
 }
 
 // src/handlers/input-type.ts
 function inputType(args) {
   const {
-    circularDependencies,
     classDecoratorName,
     classTransformerTypeModels,
     config,
@@ -651,41 +750,41 @@ function inputType(args) {
     fileType,
     getModelName: getModelName2,
     getSourceFile,
-    inputType: inputType2,
+    inputType: inputTypeArg,
     models,
     output,
     removeTypes,
     typeNames
   } = args;
-  typeNames.add(inputType2.name);
+  typeNames.add(inputTypeArg.name);
   const importDeclarations = new ImportDeclarationMap();
   const sourceFile = getSourceFile({
-    name: inputType2.name,
+    name: inputTypeArg.name,
     type: fileType
   });
   const classStructure = {
-    kind: StructureKind.Class,
-    isExported: true,
-    name: inputType2.name,
     decorators: [
       {
-        name: classDecoratorName,
-        arguments: []
+        arguments: [],
+        name: classDecoratorName
       }
     ],
+    isExported: true,
+    kind: StructureKind.Class,
+    name: inputTypeArg.name,
     properties: []
   };
-  const modelName = getModelName2(inputType2.name) ?? "";
+  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", {
-    namedImports: [{ name: "Field" }],
-    moduleSpecifier
+    moduleSpecifier,
+    namedImports: [{ name: "Field" }]
   }).set(classDecoratorName, {
-    namedImports: [{ name: classDecoratorName }],
-    moduleSpecifier
+    moduleSpecifier,
+    namedImports: [{ name: classDecoratorName }]
   });
   if (config.esmCompatible) {
     const typeRegistryPath = relativePath(
@@ -696,11 +795,11 @@ function inputType(args) {
     importDeclarations.add("getType", typeRegistryPath);
   }
   const useInputType = config.useInputType.find(
-    (x) => inputType2.name.includes(x.typeName)
+    (x) => inputTypeArg.name.includes(x.typeName)
   );
-  const isWhereUnique = isWhereUniqueInputType(inputType2.name);
-  for (const field of inputType2.fields) {
-    field.inputTypes = field.inputTypes.filter((t) => !removeTypes.has(String(t.type)));
+  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) {
@@ -709,52 +808,56 @@ function inputType(args) {
     const usePattern = useInputType?.ALL ?? useInputType?.[name];
     const graphqlInputType = getGraphqlInputType(inputTypes, usePattern);
     const { isList, location, type } = graphqlInputType;
-    const typeName = String(type);
+    const typeName = type;
     const settings = modelFieldSettings?.get(name);
     const propertySettings = settings?.getPropertyType({
-      name: inputType2.name,
-      input: true
+      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({
+      propertySettings?.name ?? whereUniqueInputTypeValue ?? getPropertyType({
         location,
         type: typeName
-      }))
+      })
     );
     const hasExclamationToken = Boolean(
       isWhereUnique && config.unsafeCompatibleWhereUniqueInput && atLeastKeys?.includes(name)
     );
     const property = propertyStructure({
-      name,
-      isNullable: !isRequired,
       hasExclamationToken: hasExclamationToken || void 0,
       hasQuestionToken: hasExclamationToken ? false : void 0,
-      propertyType,
-      isList
+      isList,
+      isNullable: !isRequired,
+      name,
+      propertyType
     });
-    classStructure.properties.push(property);
+    if (classStructure.properties) {
+      classStructure.properties.push(property);
+    }
     if (propertySettings) {
       importDeclarations.create({ ...propertySettings });
-    } else if (propertyType.some((p) => p.includes("Prisma.Decimal"))) {
+    } else if (propertyType.some(
+      (p) => typeof p === "string" && p.includes("Prisma.Decimal")
+    )) {
       importDeclarations.add("Prisma", config.prismaClientImport);
-    } else if (propertyType.some((p) => p.startsWith("Prisma."))) {
+    } 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({
-      name: inputType2.name,
-      input: true
-    }) || config.decorate.some(
-      (d) => d.name === "HideField" && d.from === moduleSpecifier && d.isMatchField(name) && d.isMatchType(inputType2.name)
+      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({
-      name: inputType2.name,
-      input: true
+      input: true,
+      name: inputTypeArg.name
     });
     if (fieldType && isCustomsApplicable && !shouldHideField) {
       graphqlType = fieldType.name;
@@ -762,29 +865,28 @@ function inputType(args) {
     } else {
       const graphqlImport = getGraphqlImport({
         config,
-        sourceFile,
+        getSourceFile,
         location,
-        typeName,
-        getSourceFile
+        sourceFile,
+        typeName
       });
       graphqlType = graphqlImport.name;
-      let referenceName = propertyType[0];
       if (location === "enumTypes") {
-        const parts = referenceName.split(" ");
-        referenceName = parts.at(-1) ?? parts[0];
+        const parts = String(propertyType[0]).split(" ");
+        parts.at(-1);
       }
       const shouldUseLazyType = config.esmCompatible && location === "inputObjectTypes";
-      if (graphqlImport.name === inputType2.name && shouldUseLazyType) {
+      if (graphqlImport.name === inputTypeArg.name && shouldUseLazyType) {
         lazyTypes.add(graphqlImport.name);
         useGetType = true;
-      } else if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && graphqlImport.name !== inputType2.name) {
+      } 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, {
-            namedImports: [{ name: graphqlImport.name }],
-            moduleSpecifier: graphqlImport.specifier
+            moduleSpecifier: graphqlImport.specifier,
+            namedImports: [{ name: graphqlImport.name }]
           });
         }
       }
@@ -792,10 +894,13 @@ function inputType(args) {
         useGetType = true;
       }
     }
-    ok(property.decorators, "property.decorators is undefined");
+    ok(
+      property.decorators !== void 0 && property.decorators !== null,
+      "property.decorators is undefined"
+    );
     if (shouldHideField) {
       importDeclarations.add("HideField", moduleSpecifier);
-      property.decorators.push({ name: "HideField", arguments: [] });
+      property.decorators.push({ arguments: [], name: "HideField" });
     } else {
       let typeExpression;
       if (useGetType) {
@@ -804,14 +909,14 @@ function inputType(args) {
         typeExpression = isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`;
       }
       property.decorators.push({
-        name: "Field",
         arguments: [
           typeExpression,
           JSON52.stringify({
             ...settings?.fieldArguments(),
             nullable: !isRequired
           })
-        ]
+        ],
+        name: "Field"
       });
       if (graphqlType === "GraphQLDecimal") {
         const decimalHelpersPath = relativePath(
@@ -823,12 +928,12 @@ function inputType(args) {
         importDeclarations.add("Type", "class-transformer");
         property.decorators.push(
           {
-            name: "Type",
-            arguments: ["() => Object"]
+            arguments: ["() => Object"],
+            name: "Type"
           },
           {
-            name: "Transform",
-            arguments: ["transformToDecimal"]
+            arguments: ["transformToDecimal"],
+            name: "Transform"
           }
         );
       } else if (location === "inputObjectTypes" && (modelField?.type === "Decimal" || [
@@ -845,44 +950,47 @@ function inputType(args) {
         "updateMany",
         "upsert",
         "where"
-      ].includes(name) || classTransformerTypeModels.has(getModelName2(graphqlType) ?? "") || modelField?.kind === "object" && models.get(modelField.type) && models.get(modelField.type)?.fields.some(
+      ].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({
-            name: "Type",
-            arguments: [`getType('${graphqlType}')`]
+            arguments: [`getType('${graphqlType}')`],
+            name: "Type"
           });
         } else {
-          property.decorators.push({ name: "Type", arguments: [`() => ${graphqlType}`] });
+          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({
-              name: options.name,
-              arguments: options.arguments
+              arguments: options.arguments,
+              name: options.name
             });
-            ok(options.from, "Missed 'from' part in configuration or field setting");
+            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(inputType2.name)) {
+        if (decorate.isMatchField(name) && decorate.isMatchType(inputTypeArg.name)) {
           property.decorators.push({
-            name: decorate.name,
-            arguments: decorate.arguments?.map((x) => pupa(x, { propertyType }))
+            arguments: decorate.arguments?.map((x) => pupa(x, { propertyType })),
+            name: decorate.name
           });
           importDeclarations.create(decorate);
         }
       }
     }
     eventEmitter.emitSync("ClassProperty", property, {
-      location,
       isList,
+      location,
       propertyType
     });
   }
@@ -892,7 +1000,7 @@ function inputType(args) {
   ];
   if (config.esmCompatible) {
     statements.push(`
-registerType('${inputType2.name}', ${inputType2.name});`);
+registerType('${inputTypeArg.name}', ${inputTypeArg.name});`);
   }
   sourceFile.set({
     statements
@@ -900,8 +1008,8 @@ registerType('${inputType2.name}', ${inputType2.name});`);
 }
 var ObjectSettings = class extends Array {
   shouldHideField({
-    name,
     input = false,
+    name,
     output = false
   }) {
     const hideField = this.find((s) => s.name === "HideField");
@@ -910,8 +1018,8 @@ var ObjectSettings = class extends Array {
     );
   }
   getFieldType({
-    name,
     input,
+    name,
     output
   }) {
     const fieldType = this.find((s) => s.kind === "FieldType");
@@ -930,8 +1038,8 @@ var ObjectSettings = class extends Array {
     return fieldType;
   }
   getPropertyType({
-    name,
     input,
+    name,
     output
   }) {
     const propertyType = this.find((s) => s.kind === "PropertyType");
@@ -954,19 +1062,20 @@ var ObjectSettings = class extends Array {
     const resultArguments = [objectTypeOptions];
     const objectType = this.find((s) => s.kind === "ObjectType");
     if (objectType && isObject(objectType.arguments)) {
-      const name = objectType.arguments.name;
+      const { name } = objectType.arguments;
       merge(objectTypeOptions, omit(objectType.arguments, "name"));
-      if (name) {
+      if (name !== null && name !== void 0 && name !== "") {
         resultArguments.unshift(name);
       }
     }
     return resultArguments.map((x) => JSON52.stringify(x));
   }
   fieldArguments() {
-    const item = this.find((item2) => item2.kind === "Field");
-    if (item) {
-      return item.arguments;
+    const fieldItem = this.find((item) => item.kind === "Field");
+    if (fieldItem) {
+      return fieldItem.arguments;
     }
+    return void 0;
   }
 };
 function createObjectSettings(args) {
@@ -976,18 +1085,23 @@ function createObjectSettings(args) {
   const documentationLines = [];
   let fieldElement = result.find((item) => item.kind === "Field");
   if (!fieldElement) {
-    fieldElement = {
-      name: "",
+    const newFieldElement = {
+      arguments: {},
+      from: "",
+      input: false,
       kind: "Field",
-      arguments: {}
+      model: false,
+      name: "",
+      output: false
     };
+    fieldElement = newFieldElement;
   }
   for (const line of textLines) {
     const match = /^@(?<name>\w+(\.(\w+))?)\((?<args>.*)\)/.exec(line);
-    const { element, documentLine } = createSettingElement({
-      line,
+    const { documentLine, element } = createSettingElement({
       config,
       fieldElement,
+      line,
       match
     });
     if (element) {
@@ -998,14 +1112,14 @@ function createObjectSettings(args) {
     }
   }
   return {
-    settings: result,
-    documentation: documentationLines.filter(Boolean).join("\n") || void 0
+    documentation: documentationLines.filter(Boolean).join("\n") || void 0,
+    settings: result
   };
 }
 function createSettingElement({
-  line,
   config,
   fieldElement,
+  line,
   match
 }) {
   const result = {
@@ -1013,75 +1127,95 @@ function createSettingElement({
     element: void 0
   };
   if (line.startsWith("@deprecated")) {
-    fieldElement.arguments["deprecationReason"] = trim(line.slice(11));
-    result.element = fieldElement;
+    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")) {
-    let n = Number.parseInt(trim(line.slice(11)));
-    if (n !== n || n < 1) n = 1;
-    fieldElement.arguments["complexity"] = n;
-    result.element = fieldElement;
+    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
+      }
+    };
+    result.element = updatedFieldElement;
     return result;
   }
   const name = match?.groups?.name;
-  if (!(match && name)) {
+  if (!(match && name !== void 0 && name !== "")) {
     result.documentLine = line;
     return result;
   }
   const element = {
-    kind: "Decorator",
-    name: "",
     arguments: [],
+    from: "",
     input: false,
-    output: false,
+    kind: "Decorator",
     model: false,
-    from: ""
+    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) {
+  if (["FieldType", "PropertyType"].includes(name) && match.groups?.args !== void 0 && match.groups.args !== "") {
     const options2 = customType(match.groups.args);
-    merge(element, options2.namespace && config.fields[options2.namespace], options2, {
+    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) {
+  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]) {
+    if (typeof options2[0] === "string" && options2[0] !== "") {
       options2.name = options2[0];
     }
     if (isObject(options2[1])) {
       merge(options2, options2[1]);
     }
     element.arguments = {
-      name: options2.name,
-      isAbstract: options2.isAbstract
+      isAbstract: options2.isAbstract,
+      name: options2.name
     };
     return result;
   }
-  if (name === "Directive" && match.groups?.args) {
+  if (name === "Directive" && match.groups?.args !== void 0 && match.groups.args !== "") {
     const options2 = customType(match.groups.args);
-    merge(element, { model: true, from: "@nestjs/graphql" }, options2, {
-      name,
-      namespace: false,
+    merge(element, { from: "@nestjs/graphql", model: true }, options2, {
+      arguments: Array.isArray(options2.arguments) ? options2.arguments.map((s) => JSON52.stringify(s)) : options2.arguments,
       kind: "Decorator",
-      arguments: Array.isArray(options2.arguments) ? options2.arguments.map((s) => JSON52.stringify(s)) : options2.arguments
+      name,
+      namespace: false
     });
     return result;
   }
   const namespace = getNamespace(name);
   element.namespaceImport = namespace;
+  const args = match.groups?.args ?? "";
   const options = {
-    name,
-    arguments: (match.groups?.args || "").split(",").map((s) => trim(s)).filter(Boolean)
+    arguments: args.split(",").map((s) => trim(s)).filter(Boolean),
+    name
   };
-  merge(element, namespace && config.fields[namespace], options);
+  const namespaceConfig = namespace !== void 0 && namespace !== "" ? config.fields[namespace] : void 0;
+  merge(element, namespaceConfig, options);
   return result;
 }
 function customType(args) {
@@ -1093,7 +1227,8 @@ function customType(args) {
   Object.assign(result, options);
   const namespace = getNamespace(options.name);
   result.namespace = namespace;
-  if (options.name?.includes(".")) {
+  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)) {
@@ -1103,29 +1238,30 @@ function customType(args) {
 }
 function hideFieldDecorator(match) {
   const result = {
-    name: "HideField",
     arguments: [],
-    from: "@nestjs/graphql",
     defaultImport: void 0,
-    namespaceImport: void 0,
-    match: void 0
+    from: "@nestjs/graphql",
+    match: void 0,
+    name: "HideField",
+    namespaceImport: void 0
   };
-  if (!match.groups?.args) {
+  const args = match.groups?.args;
+  if (args === void 0 || args === "") {
     result.output = true;
     return result;
   }
-  if (match.groups.args.includes("{") && match.groups.args.includes("}")) {
-    const options = parseArgs(match.groups.args);
+  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(match.groups.args)) {
+    if (/output:\s*true/.test(args)) {
       result.output = true;
     }
-    if (/input:\s*true/.test(match.groups.args)) {
+    if (/input:\s*true/.test(args)) {
       result.input = true;
     }
   }
@@ -1143,12 +1279,22 @@ function parseArgs(string) {
   }
 }
 function getNamespace(name) {
-  if (name === void 0) {
+  if (name === void 0 || name === null) {
+    return void 0;
+  }
+  if (typeof name !== "string") {
+    return void 0;
+  }
+  let result = name;
+  if (result === "") {
     return void 0;
   }
-  let result = String(name);
   if (result.includes(".")) {
-    [result] = result.split(".");
+    const parts = result.split(".");
+    result = parts[0] ?? "";
+  }
+  if (result === "") {
+    return void 0;
   }
   return result;
 }
@@ -1156,12 +1302,12 @@ function getNamespace(name) {
 // src/handlers/model-data.ts
 function modelData(model, args) {
   const {
+    classTransformerTypeModels,
     config,
-    modelNames,
-    models,
-    modelFields,
     fieldSettings,
-    classTransformerTypeModels
+    modelFields,
+    modelNames,
+    models
   } = args;
   modelNames.push(model.name);
   models.set(model.name, model);
@@ -1170,10 +1316,10 @@ function modelData(model, args) {
   const fieldSettingsValue = /* @__PURE__ */ new Map();
   fieldSettings.set(model.name, fieldSettingsValue);
   for (const field of model.fields) {
-    if (field.documentation) {
+    if (field.documentation !== null && field.documentation !== void 0 && field.documentation.length > 0) {
       const { documentation, settings } = createObjectSettings({
-        text: field.documentation,
-        config
+        config,
+        text: field.documentation
       });
       field.documentation = documentation;
       fieldSettingsValue.set(field.name, settings);
@@ -1192,8 +1338,14 @@ function createComment(documentation, settings) {
   for (const line of documentationLines) {
     commentLines.push(` * ${line}`);
   }
-  const deprecationReason = settings?.fieldArguments()?.deprecationReason;
-  if (deprecationReason) {
+  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");
@@ -1208,6 +1360,9 @@ function buildDependencyGraph(models) {
   }
   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)) {
@@ -1227,7 +1382,7 @@ function detectCircularDependencies(graph) {
     visited.add(node);
     recursionStack.add(node);
     path.push(node);
-    const dependencies = graph.get(node) || /* @__PURE__ */ new Set();
+    const dependencies = graph.get(node) ?? /* @__PURE__ */ new Set();
     for (const dep of dependencies) {
       if (!visited.has(dep)) {
         dfs(dep);
@@ -1277,7 +1432,9 @@ function modelOutputType(outputType2, args) {
     models,
     output
   } = args;
-  if (isManyAndReturnOutputType(outputType2.name)) return;
+  if (isManyAndReturnOutputType(outputType2.name)) {
+    return;
+  }
   const model = models.get(outputType2.name);
   ok(model, `Cannot find model by name ${outputType2.name}`);
   const sourceFile = getSourceFile({
@@ -1307,16 +1464,14 @@ function modelOutputType(outputType2, args) {
   const decorator = classStructure.decorators.find((d) => d.name === "ObjectType");
   ok(decorator, "ObjectType decorator not found");
   let modelSettings;
-  if (model.documentation) {
+  if (model.documentation !== null && model.documentation !== void 0 && model.documentation.length > 0) {
     const objectTypeOptions = {};
     const { documentation, settings } = createObjectSettings({
       config,
       text: model.documentation
     });
-    if (documentation) {
-      if (!classStructure.leadingTrivia) {
-        classStructure.leadingTrivia = createComment(documentation);
-      }
+    if (documentation !== void 0 && documentation.length > 0) {
+      classStructure.leadingTrivia ??= createComment(documentation);
       objectTypeOptions.description = documentation;
     }
     decorator.arguments = settings.getObjectTypeArguments(objectTypeOptions);
@@ -1334,10 +1489,12 @@ function modelOutputType(outputType2, args) {
     importDeclarations.add("getType", typeRegistryPath);
   }
   for (const field of outputType2.fields) {
-    if (config.omitModelsCount && field.name === "_count") continue;
+    if (config.omitModelsCount && field.name === "_count") {
+      continue;
+    }
     let fileType = "model";
     const { isList, location, namespace, type } = field.outputType;
-    let outputTypeName = String(type);
+    let outputTypeName = type;
     if (namespace !== "model") {
       fileType = "output";
       outputTypeName = getOutputTypeName(outputTypeName);
@@ -1359,15 +1516,12 @@ function modelOutputType(outputType2, args) {
       })
     );
     propertyType.splice(1, propertyType.length);
-    if (field.isNullable && !isList) {
+    if (field.isNullable === true && !isList) {
       propertyType.push("null");
     }
     let graphqlType;
     let useGetType = false;
-    if (fieldType) {
-      graphqlType = fieldType.name;
-      importDeclarations.create({ ...fieldType });
-    } else {
+    if (fieldType === void 0) {
       const graphqlImport = getGraphqlImport({
         config,
         fileType,
@@ -1379,7 +1533,7 @@ function modelOutputType(outputType2, args) {
         typeName: outputTypeName
       });
       graphqlType = graphqlImport.name;
-      if (graphqlImport.name !== outputType2.name && graphqlImport.specifier) {
+      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.addType(graphqlImport.name, graphqlImport.specifier);
@@ -1389,6 +1543,9 @@ function modelOutputType(outputType2, args) {
           importDeclarations.add(graphqlImport.name, graphqlImport.specifier);
         }
       }
+    } else {
+      graphqlType = fieldType.name;
+      importDeclarations.create({ ...fieldType });
     }
     const property = propertyStructure({
       hasExclamationToken: true,
@@ -1398,17 +1555,19 @@ function modelOutputType(outputType2, args) {
       name: field.name,
       propertyType
     });
-    if (typeof property.leadingTrivia === "string" && modelField?.documentation) {
+    if (typeof property.leadingTrivia === "string" && modelField?.documentation !== null && modelField?.documentation !== void 0 && modelField.documentation.length > 0) {
       property.leadingTrivia += createComment(modelField.documentation, settings);
     }
-    classStructure.properties?.push(property);
-    if (propertySettings) {
+    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, "property.decorators is undefined");
-    const shouldHideField = settings?.shouldHideField({ name: outputType2.name, output: true }) || config.decorate.some(
+    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) {
@@ -1429,7 +1588,7 @@ function modelOutputType(outputType2, args) {
             defaultValue: ["number", "string", "boolean"].includes(
               typeof modelField?.default
             ) ? modelField?.default : void 0,
-            description: modelField?.documentation,
+            description: modelField?.documentation !== null && modelField?.documentation !== void 0 && modelField.documentation !== "" ? modelField.documentation : void 0,
             nullable: Boolean(field.isNullable)
           })
         ],
@@ -1441,7 +1600,10 @@ function modelOutputType(outputType2, args) {
             arguments: setting.arguments,
             name: setting.name
           });
-          ok(setting.from, "Missed 'from' part in configuration or field setting");
+          ok(
+            setting.from && setting.from.length > 0,
+            "Missed 'from' part in configuration or field setting"
+          );
           importDeclarations.create(setting);
         }
       }
@@ -1509,13 +1671,14 @@ function noAtomicOperations(eventEmitter) {
   eventEmitter.on("BeforeGenerateFiles", beforeGenerateFiles);
 }
 function beforeInputType2(args) {
-  const { inputType: inputType2, getModelName: getModelName2 } = 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 = String(it.type);
+      const inputTypeName = it.type;
       const modelName = getModelName2(inputTypeName);
-      if (isAtomicOperation(inputTypeName) || modelName && isListInput(inputTypeName, modelName, fieldName)) {
+      const isModelNameValid = modelName !== null && modelName !== void 0 && modelName.length > 0;
+      if (isAtomicOperation(inputTypeName) || isModelNameValid && isListInput(inputTypeName, modelName, fieldName)) {
         return false;
       }
       return true;
@@ -1526,7 +1689,8 @@ function beforeGenerateFiles(args) {
   const { project } = args;
   for (const sourceFile of project.getSourceFiles()) {
     const className = sourceFile.getClass(() => true)?.getName();
-    if (className && isAtomicOperation(className)) {
+    const isClassNameValid = className !== void 0 && className !== null && className.length > 0;
+    if (isClassNameValid && isAtomicOperation(className)) {
       project.removeSourceFile(sourceFile);
     }
   }
@@ -1552,11 +1716,13 @@ 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 = models.get(modelName);
-  const isAggregateOutput = model && /(?:Count|Avg|Sum|Min|Max)AggregateOutputType$/.test(outputTypeArg.name) && String(outputTypeArg.name).startsWith(model.name);
-  const isCountOutput = model?.name && outputTypeArg.name === `${model.name}CountOutputType`;
-  if (!config.emitBlocks.outputs && !isCountOutput) return;
+  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 });
@@ -1581,8 +1747,15 @@ function outputType(outputTypeArg, args) {
   importDeclarations.add("ObjectType", nestjsGraphql2);
   for (const field of outputTypeArg.fields) {
     const { isList, location, type } = field.outputType;
-    const outputTypeName = getOutputTypeName(String(type));
-    const settings = isCountOutput ? void 0 : model && fieldSettings.get(model.name)?.get(field.name);
+    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
@@ -1603,7 +1776,7 @@ function outputType(outputTypeArg, args) {
       propertyType
     });
     classStructure.properties?.push(property);
-    if (propertySettings) {
+    if (propertySettings !== void 0) {
       importDeclarations.create({ ...propertySettings });
     } else if (propertyType.some((p) => p.includes("Prisma.Decimal"))) {
       importDeclarations.add("Prisma", config.prismaClientImport);
@@ -1612,14 +1785,14 @@ function outputType(outputTypeArg, args) {
     const shouldHideField = settings?.shouldHideField({
       name: outputTypeArg.name,
       output: true
-    }) || config.decorate.some(
+    }) === 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 && isCustomsApplicable && !shouldHideField) {
+    if (fieldType !== void 0 && isCustomsApplicable && !shouldHideField) {
       graphqlType = fieldType.name;
       importDeclarations.create({ ...fieldType });
     } else {
@@ -1634,14 +1807,14 @@ function outputType(outputTypeArg, args) {
       });
       const referenceName = location === "enumTypes" ? getEnumName(propertyType[0]) : propertyType[0];
       graphqlType = graphqlImport.name;
-      if (graphqlImport.specifier && !importDeclarations.has(graphqlImport.name) && (graphqlImport.name !== outputTypeArg.name && !shouldHideField || shouldHideField && referenceName === 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, "property.decorators is undefined");
+    ok(property.decorators !== void 0, "property.decorators is undefined");
     if (shouldHideField) {
       importDeclarations.add("HideField", nestjsGraphql2);
       property.decorators.push({ arguments: [], name: "HideField" });
@@ -1658,12 +1831,16 @@ function outputType(outputTypeArg, args) {
       });
       if (isCustomsApplicable) {
         for (const options of settings ?? []) {
-          if ((options.kind === "Decorator" && options.output && options.match?.(field.name)) ?? true) {
+          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, "Missed 'from' part in configuration or field setting");
+            ok(
+              options.from !== null && options.from !== void 0 && options.from.length > 0,
+              "Missed 'from' part in configuration or field setting"
+            );
             importDeclarations.create(options);
           }
         }
@@ -1679,11 +1856,15 @@ function outputType(outputTypeArg, args) {
     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({ project, output }) {
+function begin({ output, project }) {
   const sourceFiles = project.getDirectory(output)?.getDescendantSourceFiles();
   if (sourceFiles) {
     for (const sourceFile of sourceFiles) {
@@ -1691,9 +1872,10 @@ function begin({ project, output }) {
     }
   }
 }
-function end({ project, output }) {
+function end({ output, project }) {
   const directories = project.getDirectory(output)?.getDescendantDirectories().filter((directory) => directory.getSourceFiles().length === 0).map((directory) => directory.getPath());
-  for (const directory of directories ?? []) {
+  const directoryList = directories ?? [];
+  for (const directory of directoryList) {
     try {
       rmdirSync(directory);
     } catch {
@@ -1711,7 +1893,7 @@ function reExport(emitter) {
   emitter.on("BeforeGenerateFiles", beforeGenerateFiles2);
 }
 function beforeGenerateFiles2(args) {
-  const { project, output, config } = args;
+  const { config, output, project } = args;
   const rootDirectory = project.getDirectoryOrThrow(output);
   if (["Directories" /* Directories */, "All" /* All */].includes(config.reExport)) {
     const directories = [...rootDirectory.getDescendantDirectories()];
@@ -1758,7 +1940,9 @@ function beforeGenerateFiles2(args) {
     const exportDeclarations = [];
     const directories = rootDirectory.getDirectories();
     for (const directory of directories) {
-      if (directory.getBaseName() === "node_modules") continue;
+      if (directory.getBaseName() === "node_modules") {
+        continue;
+      }
       const indexFile = directory.getSourceFile("index.ts");
       if (indexFile) {
         const dirName = directory.getBaseName();
@@ -1780,9 +1964,9 @@ function beforeGenerateFiles2(args) {
 function getExportDeclaration2(directory, sourceFile) {
   let moduleSpecifier = directory.getRelativePathAsModuleSpecifierTo(sourceFile);
   if (!moduleSpecifier.endsWith(".js") && !moduleSpecifier.endsWith(".ts")) {
-    moduleSpecifier = moduleSpecifier + ".js";
+    moduleSpecifier += ".js";
   } else if (moduleSpecifier.endsWith(".ts")) {
-    moduleSpecifier = moduleSpecifier.slice(0, -3) + ".js";
+    moduleSpecifier = `${moduleSpecifier.slice(0, -3)}.js`;
   }
   return {
     kind: StructureKind.ExportDeclaration,
@@ -1792,7 +1976,7 @@ function getExportDeclaration2(directory, sourceFile) {
 function getNamespaceExportDeclaration(directory, sourceDirectory) {
   let moduleSpecifier = directory.getRelativePathAsModuleSpecifierTo(sourceDirectory);
   if (!moduleSpecifier.endsWith("/index.js")) {
-    moduleSpecifier = moduleSpecifier + "/index.js";
+    moduleSpecifier += "/index.js";
   }
   return {
     kind: StructureKind.ExportDeclaration,
@@ -1800,74 +1984,16 @@ function getNamespaceExportDeclaration(directory, sourceDirectory) {
   };
 }
 
-// src/handlers/prisma-enum-doc.ts
-function extractEnumValueDocs(values) {
-  return Object.fromEntries(
-    values.map((value) => {
-      const { name } = value;
-      const documentation = value.documentation;
-      if (typeof documentation !== "string") return null;
-      if (documentation.startsWith("@deprecated")) {
-        return [name, { deprecationReason: documentation.slice(11).trim() }];
-      }
-      return [name, { description: documentation }];
-    }).filter((entry) => entry !== null)
-  );
-}
-
-// src/handlers/register-enum.ts
-function registerEnum(enumType, args) {
-  const { config, enums, getSourceFile } = args;
-  if (!config.emitBlocks.prismaEnums && !enums[enumType.name]) return;
-  const dataModelEnum = enums[enumType.name];
-  const enumTypesData = dataModelEnum?.values ?? [];
-  const sourceFile = getSourceFile({
-    name: enumType.name,
-    type: "enum"
-  });
-  const importDeclarations = new ImportDeclarationMap();
-  importDeclarations.set("registerEnumType", {
-    moduleSpecifier: "@nestjs/graphql",
-    namedImports: [{ name: "registerEnumType" }]
-  });
-  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 enumStructure = {
-    kind: StructureKind.Enum,
-    isExported: true,
-    name: enumType.name,
-    members: enumType.values.map((v) => ({
-      name: v,
-      initializer: JSON.stringify(v)
-    }))
-  };
-  sourceFile.set({
-    statements: [
-      ...importDeclarations.toStatements(),
-      enumStructure,
-      "\n",
-      `registerEnumType(${enumType.name}, { name: '${enumType.name}', description: ${JSON.stringify(
-        dataModelEnum?.documentation
-      )}${valuesMapEntry} })`
-    ]
-  });
-}
+// 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 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`);
@@ -1877,7 +2003,7 @@ function generateRegisterAllTypes(args) {
       continue;
     }
     const fileText = file.getText();
-    const registerMatch = fileText.match(/registerType\(['"]([^'"]+)['"]/);
+    const registerMatch = /registerType\(['"]([^'"]+)['"]/.exec(fileText);
     if (registerMatch) {
       const relPath = relativePath(sourceFile.getFilePath(), filePath);
       importPaths.push(relPath);
@@ -1931,6 +2057,76 @@ 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);
@@ -1945,17 +2141,17 @@ function beforeInputType3(args) {
     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 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
  *
@@ -2086,81 +2282,17 @@ export function validateRegistry(expectedTypes: string[]): void {
   sourceFile.addStatements(registryCode);
 }
 
-// src/handlers/decimal-helpers.ts
-function generateDecimalHelpers(args) {
-  const { config, 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);
-}
-
 // src/handlers/warning.ts
+var globalConsole = globalThis.console;
+var log = (msg) => {
+  globalConsole.log(msg);
+};
 function warning(message) {
   if (Array.isArray(message)) {
-    console.log("nestjs-prisma-graphql:");
-    console.log(message.join("\n"));
+    log("nestjs-prisma-graphql:");
+    log(message.join("\n"));
   } else {
-    console.log("nestjs-prisma-graphql:", message);
+    log(`nestjs-prisma-graphql: ${message}`);
   }
 }
 
@@ -2174,44 +2306,51 @@ var allEmmittedBlocks = [
   "outputs"
 ];
 var blocksDependencyMap = {
+  args: ["args", "inputs", "prismaEnums"],
   enums: ["schemaEnums", "prismaEnums"],
-  models: ["models", "schemaEnums"],
   inputs: ["inputs", "prismaEnums"],
-  outputs: ["outputs"],
-  args: ["args", "inputs", "prismaEnums"]
+  models: ["models", "schemaEnums"],
+  outputs: ["outputs"]
 };
 function createEmitBlocks(data) {
   if (!data) {
-    return Object.fromEntries(allEmmittedBlocks.map((block) => [block, true]));
+    const entries = allEmmittedBlocks.map((block) => [block, true]);
+    const allBlocks = Object.fromEntries(entries);
+    return allBlocks;
   }
-  let blocksToEmit = {};
+  const initialBlocks = {};
+  let currentBlocks = initialBlocks;
   for (const block of data) {
-    if (!Object.keys(blocksDependencyMap).includes(block)) continue;
-    blocksToEmit = {
-      ...blocksToEmit,
-      ...Object.fromEntries(
-        blocksDependencyMap[block].map((block2) => [block2, true])
-      )
+    if (!Object.keys(blocksDependencyMap).includes(block)) {
+      continue;
+    }
+    const blockEntries = blocksDependencyMap[block].map(
+      (emittedBlock) => [emittedBlock, true]
+    );
+    const newBlocks = Object.fromEntries(blockEntries);
+    currentBlocks = {
+      ...currentBlocks,
+      ...newBlocks
     };
   }
-  return blocksToEmit;
+  return currentBlocks;
 }
 
 // src/helpers/create-config.ts
 function createConfig(data) {
   const config = merge({}, unflatten(data, { delimiter: "_" }));
   const $warnings = [];
-  const configOutputFilePattern = String(
-    config.outputFilePattern || `{model}/{name}.{type}.ts`
-  );
-  let outputFilePattern = configOutputFilePattern.replaceAll("..", "/").replaceAll(/\/+/g, "/");
-  outputFilePattern = trim(outputFilePattern, "/");
+  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) {
+  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";
@@ -2223,105 +2362,118 @@ function createConfig(data) {
     ).filter(({ 1: value }) => typeof value === "object").map(([name, value]) => {
       const fieldSetting = {
         arguments: [],
-        output: toBoolean(value.output),
+        defaultImport: toBoolean(value.defaultImport) ? true : value.defaultImport,
+        from: value.from,
         input: toBoolean(value.input),
         model: toBoolean(value.model),
-        from: value.from,
-        defaultImport: toBoolean(value.defaultImport) ? true : value.defaultImport,
-        namespaceImport: value.namespaceImport
+        namespaceImport: value.namespaceImport,
+        output: toBoolean(value.output)
       };
       return [name, fieldSetting];
     })
   );
   const decorate = [];
-  const configDecorate = Object.values(
-    config.decorate || {}
-  );
+  const decorateConfig = config.decorate !== void 0 && config.decorate !== null ? config.decorate : {};
+  const configDecorate = Object.values(decorateConfig);
   for (const element of configDecorate) {
-    if (!element) continue;
+    if (element === void 0 || element === null) {
+      continue;
+    }
     ok(
-      element.from && element.name,
+      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 }),
-      from: element.from,
       name: element.name,
       namedImport: toBoolean(element.namedImport),
-      defaultImport: toBoolean(element.defaultImport) ? true : element.defaultImport,
-      namespaceImport: element.namespaceImport,
-      arguments: element.arguments ? JSON52.parse(element.arguments) : void 0
+      namespaceImport: element.namespaceImport
     });
   }
   const customImport = [];
-  const configCustomImport = Object.values(
-    config.customImport || {}
-  );
+  const customImportConfig = config.customImport !== void 0 && config.customImport !== null ? config.customImport : {};
+  const configCustomImport = Object.values(customImportConfig);
   for (const element of configCustomImport) {
-    if (!element) continue;
+    if (element === void 0 || element === null) {
+      continue;
+    }
     ok(
-      element.from && element.name,
+      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),
-      defaultImport: toBoolean(element.defaultImport) ? true : element.defaultImport,
       namespaceImport: element.namespaceImport
     });
   }
   return {
-    outputFilePattern,
-    tsConfigFilePath: createTsConfigFilePathValue(config.tsConfigFilePath),
-    prismaClientImport: createPrismaImport(config.prismaClientImport),
+    $warnings,
     combineScalarFilters: toBoolean(config.combineScalarFilters),
-    noAtomicOperations: toBoolean(config.noAtomicOperations),
-    reExport: ReExport[String(config.reExport)] || "None" /* None */,
-    emitSingle: toBoolean(config.emitSingle),
-    emitCompiled: toBoolean(config.emitCompiled),
+    customImport,
+    decorate,
     emitBlocks: createEmitBlocks(config.emitBlocks),
-    omitModelsCount: toBoolean(config.omitModelsCount),
-    $warnings,
+    emitCompiled: toBoolean(config.emitCompiled),
+    emitSingle: toBoolean(config.emitSingle),
+    esmCompatible: toBoolean(config.esmCompatible),
     fields,
-    purgeOutput: toBoolean(config.purgeOutput),
-    useInputType: createUseInputType(config.useInputType),
+    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
     ),
-    unsafeCompatibleWhereUniqueInput: toBoolean(
-      config.unsafeCompatibleWhereUniqueInput
-    ),
-    graphqlScalars: config.graphqlScalars || {},
-    decorate,
-    customImport,
-    esmCompatible: toBoolean(config.esmCompatible)
+    tsConfigFilePath: createTsConfigFilePathValue(config.tsConfigFilePath),
+    unsafeCompatibleWhereUniqueInput: toBoolean(config.unsafeCompatibleWhereUniqueInput),
+    useInputType: createUseInputType(
+      config.useInputType
+    )
   };
 }
-var tsConfigFileExists = memoize((filePath) => {
-  return existsSync(filePath);
+var existsSyncTyped = existsSync;
+var tsConfigFileExistsRaw = memoize((filePath) => {
+  const exists = existsSyncTyped(filePath);
+  return exists;
 });
+var tsConfigFileExists = tsConfigFileExistsRaw;
 function createTsConfigFilePathValue(value) {
-  if (typeof value === "string") return value;
-  if (tsConfigFileExists("tsconfig.json")) return "tsconfig.json";
+  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") return value;
+  if (typeof value === "string" && value !== "") {
+    return value;
+  }
   return "@prisma/client";
 }
 function createUseInputType(data) {
-  if (!data) {
+  if (data === void 0 || data === null) {
     return [];
   }
   const result = [];
   for (const [typeName, useInputs] of Object.entries(data)) {
     const entry = {
-      typeName,
-      ALL: void 0
+      ALL: void 0,
+      typeName
     };
-    if (useInputs.ALL) {
+    if (useInputs.ALL !== void 0 && useInputs.ALL !== "") {
       entry.ALL = useInputs.ALL;
       delete useInputs.ALL;
     }
@@ -2339,7 +2491,7 @@ function generateFileName(args) {
   const { getModelName: getModelName2, name, template, type } = args;
   const rawPath = pupa(template, {
     get model() {
-      const result = getModelName2(name) || "prisma";
+      const result = getModelName2(name) ?? "prisma";
       return kebabCase(result);
     },
     get name() {
@@ -2364,61 +2516,19 @@ function generateFileName(args) {
 
 // src/helpers/factory-get-source-file.ts
 function factoryGetSourceFile(args) {
-  const { outputFilePattern, output, getModelName: getModelName2, project } = args;
-  return function getSourceFile(args2) {
-    const { name, type } = args2;
+  const { getModelName: getModelName2, output, outputFilePattern, project } = args;
+  return function getSourceFile(getSourceFileArgs) {
+    const { name, type } = getSourceFileArgs;
     let filePath = generateFileName({
       getModelName: getModelName2,
       name,
-      type,
-      template: outputFilePattern
+      template: outputFilePattern,
+      type
     });
     filePath = `${output}/${filePath}`;
-    return project.getSourceFile(filePath) || project.createSourceFile(filePath, void 0, { overwrite: true });
+    return project.getSourceFile(filePath) ?? project.createSourceFile(filePath, void 0, { overwrite: true });
   };
 }
-function createGetModelName(modelNames) {
-  return memoize(tryGetName);
-  function tryGetName(name) {
-    return getModelName({ modelNames, name });
-  }
-}
-function getModelName(args) {
-  const { modelNames, name } = args;
-  for (const keyword of splitKeywords) {
-    const [test] = name.split(keyword, 1);
-    if (modelNames.includes(test)) {
-      return test;
-    }
-  }
-  for (const keyword of endsWithKeywords) {
-    const [test] = name.split(keyword).slice(-1);
-    if (modelNames.includes(test)) {
-      return test;
-    }
-  }
-  for (const [start, 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.slice(-19) === "CompoundUniqueInput") {
-    const test = name.slice(0, -19);
-    const models = modelNames.filter((x) => test.startsWith(x)).sort((a, b) => b.length - a.length);
-    return models[0];
-  }
-  if (name.slice(-5) === "Count") {
-    const test = name.slice(0, -5);
-    if (modelNames.includes(test)) {
-      return test;
-    }
-  }
-}
 var splitKeywords = [
   "CreateInput",
   "CreateMany",
@@ -2498,28 +2608,85 @@ var middleKeywords = [
   ["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 requireCjs = createRequire(import.meta.url);
-var AwaitEventEmitter = requireCjs("await-event-emitter").default;
+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 generatorOutputValue = generator.output?.value ?? "";
+  ok(generatorOutputValue !== "", "Missing generator configuration: output");
   const config = createConfig(generator.config);
-  const eventEmitter = new AwaitEventEmitter();
+  const eventEmitter = new AwaitEventEmitterClass();
   eventEmitter.on("Warning", warning);
-  config.emitBlocks.models && eventEmitter.on("Model", modelData);
+  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);
   }
-  config.emitBlocks.models && eventEmitter.on("ModelOutputType", modelOutputType);
-  config.emitBlocks.outputs && eventEmitter.on("AggregateOutput", createAggregateInput);
-  config.emitBlocks.inputs && eventEmitter.on("InputType", inputType);
-  config.emitBlocks.args && eventEmitter.on("ArgsType", argsType);
+  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);
@@ -2532,18 +2699,30 @@ async function generate(args) {
     skipLoadingLibFiles: !config.emitCompiled,
     tsConfigFilePath: config.tsConfigFilePath
   });
-  if (!skipAddOutputSourceFiles) {
+  if (skipAddOutputSourceFiles !== true) {
     project.addSourceFilesAtPaths([
       `${generatorOutputValue}/**/*.ts`,
       `!${generatorOutputValue}/**/*.d.ts`
     ]);
   }
-  config.combineScalarFilters && combineScalarFilters(eventEmitter);
-  config.noAtomicOperations && noAtomicOperations(eventEmitter);
-  config.reExport !== "None" /* None */ && reExport(eventEmitter);
-  config.emitSingle && emitSingle(eventEmitter);
-  config.purgeOutput && purgeOutput(eventEmitter);
-  config.requireSingleFieldsInWhereUniqueInput && requireSingleFieldsInWhereUniqueInput(eventEmitter);
+  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();
@@ -2557,7 +2736,8 @@ async function generate(args) {
   });
   const { datamodel, schema } = JSON.parse(JSON.stringify(dmmf));
   const removeTypes = /* @__PURE__ */ new Set();
-  const allModels = [...datamodel.models, ...datamodel.types ?? []];
+  const datamodelTypes = datamodel.types ?? [];
+  const allModels = [...datamodel.models, ...datamodelTypes];
   const dependencyGraph = buildDependencyGraph(allModels);
   const circularDependencies = detectCircularDependencies(dependencyGraph);
   const eventArguments = {
@@ -2589,7 +2769,7 @@ async function generate(args) {
   for (const model of datamodel.models) {
     await eventEmitter.emit("Model", model, eventArguments);
   }
-  for (const model of datamodel.types ?? []) {
+  for (const model of datamodelTypes) {
     await eventEmitter.emit("Model", model, eventArguments);
   }
   const { enumTypes, inputObjectTypes, outputObjectTypes } = schema;
@@ -2634,28 +2814,46 @@ async function generate(args) {
   await eventEmitter.emit("BeforeGenerateFiles", eventArguments);
   await eventEmitter.emit("GenerateFiles", eventArguments);
   await eventEmitter.emit("End", eventArguments);
-  for (const name of Object.keys(eventEmitter._events)) {
+  for (const name of Object.keys(
+    eventEmitter._events
+  )) {
     eventEmitter.off(name);
   }
 }
 
 // src/index.ts
-var requireCjs2 = createRequire(import.meta.url);
-requireCjs2("graceful-fs").gracefulify(requireCjs2("fs"));
-process.on("unhandledRejection", (reason) => {
-  console.log("nestjs-prisma-graphql: unhandled rejection:", reason);
+var createRequireTyped2 = createRequire;
+var requireCjs2 = createRequireTyped2(String(import.meta.url));
+var gracefulFsRaw = requireCjs2("graceful-fs");
+var gracefulFs = gracefulFsRaw;
+var nodeFsRaw = requireCjs2("fs");
+var nodeFs = nodeFsRaw;
+gracefulFs.gracefulify(nodeFs);
+var globalConsole2 = globalThis.console;
+var logError = (msg) => {
+  globalConsole2.log(msg);
+};
+var processTyped = process;
+processTyped.on("unhandledRejection", (reason) => {
+  logError(`nestjs-prisma-graphql: unhandled rejection: ${String(reason)}`);
   if (reason instanceof Error && typeof reason.stack === "string") {
-    console.log(reason.stack);
+    logError(reason.stack);
   }
 });
-process.on("uncaughtException", (error) => {
-  console.log("nestjs-prisma-graphql: uncaught exception:", error.message);
-  if (typeof error.stack === "string") {
-    console.log(error.stack);
+processTyped.on("uncaughtException", (error) => {
+  const err = error;
+  logError(`nestjs-prisma-graphql: uncaught exception: ${err.message}`);
+  if (typeof err.stack === "string") {
+    logError(err.stack);
   }
 });
 var { generatorHandler } = generatorHelper;
-function isGeneratorDisabled(options, env = process.env) {
+var getProcessEnv = () => {
+  const globalProcess = process;
+  const processLike = globalProcess;
+  return processLike.env;
+};
+function isGeneratorDisabled(options, env = getProcessEnv()) {
   const envVarsToCheck = [
     "DISABLE_NESTJS_PRISMA_GRAPHQL",
     "CI_SKIP_PRISMA_GRAPHQL",
@@ -2676,8 +2874,12 @@ function isGeneratorDisabled(options, env = process.env) {
 }
 function countFilesRecursive(dir) {
   let count = 0;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (entry.isDirectory()) {
+  const readDirSyncTyped = readdirSync;
+  const rawEntries = readDirSyncTyped(dir, { withFileTypes: true });
+  const entries = rawEntries;
+  for (const entry of entries) {
+    const isDir = typeof entry.isDirectory === "function" ? entry.isDirectory() : false;
+    if (isDir) {
       count += countFilesRecursive(`${dir}/${entry.name}`);
     } else {
       count++;
@@ -2685,20 +2887,31 @@ function countFilesRecursive(dir) {
   }
   return count;
 }
+var globalConsole22 = globalThis.console;
+var log2 = (msg) => {
+  globalConsole22.log(msg);
+};
 generatorHandler({
   async onGenerate(options) {
     if (isGeneratorDisabled(options)) {
-      console.log(
+      log2(
         "nestjs-prisma-graphql: generation skipped (disabled via environment variable or config)"
       );
       return;
     }
     const outputPath = options.generator.output?.value ?? "<unknown>";
     const startTime = Date.now();
-    console.log(
+    const archTyped = arch;
+    const platformTyped = platform;
+    const archValue = String(archTyped());
+    const platformValue = String(platformTyped());
+    const globalProcess2Raw = process;
+    const processWithVersion = globalProcess2Raw;
+    const nodeVersion = processWithVersion.version;
+    log2(
       [
         "nestjs-prisma-graphql: starting generation",
-        `(arch=${arch()}, platform=${platform()}, node=${process.version}, output=${outputPath})`
+        `(arch=${archValue}, platform=${platformValue}, node=${nodeVersion}, output=${outputPath})`
       ].join(" ")
     );
     try {
@@ -2707,30 +2920,30 @@ generatorHandler({
       const elapsed2 = Date.now() - startTime;
       const message = error instanceof Error ? error.message : String(error);
       const stack = error instanceof Error ? error.stack : void 0;
-      console.log(
+      log2(
         `nestjs-prisma-graphql: generation FAILED after ${String(elapsed2)}ms: ${message}`
       );
       if (typeof stack === "string") {
-        console.log(stack);
+        log2(stack);
       }
       throw error;
     }
     const elapsed = Date.now() - startTime;
-    if (typeof outputPath === "string" && outputPath !== "<unknown>" && existsSync(outputPath)) {
+    const existsSyncTyped2 = existsSync;
+    const pathExists = typeof outputPath === "string" && outputPath !== "<unknown>" && existsSyncTyped2(outputPath);
+    if (pathExists) {
       const fileCount = countFilesRecursive(outputPath);
-      console.log(
-        `nestjs-prisma-graphql: generated ${String(fileCount)} files in ${String(
-          elapsed
-        )}ms`
+      log2(
+        `nestjs-prisma-graphql: generated ${String(fileCount)} files in ${String(elapsed)}ms`
       );
       if (fileCount === 0) {
         const msg = "nestjs-prisma-graphql: generation produced 0 files \u2014 this likely indicates a silent failure";
-        console.log(msg);
+        log2(msg);
         throw new Error(msg);
       }
     } else {
       const msg = `nestjs-prisma-graphql: output directory not found after generation: ${outputPath}`;
-      console.log(msg);
+      log2(msg);
       throw new Error(msg);
     }
   },