@k0lyan/nestjs-prisma-graphql-generator 0.2.0 → 0.2.1

package/dist/generator/generate-grouped-fast.d.ts

@@ -0,0 +1,9 @@
+import type { DMMFDocument } from './dmmf/document';
+import type { GeneratedFile } from './dmmf/types';
+import type { GeneratorConfig } from '../cli/options-parser';
+/**
+ * Generate code with files grouped by model using direct string generation
+ * (faster than ts-morph AST manipulation)
+ */
+export declare function generateCodeGrouped(dmmf: DMMFDocument, config: GeneratorConfig): Promise<GeneratedFile[]>;
+//# sourceMappingURL=generate-grouped-fast.d.ts.map

package/dist/generator/generate-grouped-fast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-grouped-fast.d.ts","sourceRoot":"","sources":["../../src/generator/generate-grouped-fast.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAgC,MAAM,cAAc,CAAC;AAChF,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAmB7D;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,YAAY,EAClB,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,aAAa,EAAE,CAAC,CAwB1B"}

package/dist/generator/generate-grouped-fast.js

@@ -0,0 +1,689 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCodeGrouped = generateCodeGrouped;
+const types_1 = require("./dmmf/types");
+const transformer_1 = require("./dmmf/transformer");
+const pluralize_1 = __importDefault(require("pluralize"));
+/**
+ * Generate code with files grouped by model using direct string generation
+ * (faster than ts-morph AST manipulation)
+ */
+async function generateCodeGrouped(dmmf, config) {
+    const files = [];
+    // Pre-compute input type names set for all models
+    const inputTypeNames = new Set(dmmf.inputTypes.keys());
+    // Generate shared enums
+    files.push(...generateEnumsGrouped(dmmf));
+    // Generate common types
+    files.push(...generateCommonTypesGrouped());
+    // Generate helpers
+    files.push(generateHelpersGrouped());
+    // Generate per-model files
+    for (const model of dmmf.models) {
+        files.push(...generateModelGrouped(model, dmmf, config, inputTypeNames));
+    }
+    // Generate root index
+    files.push(generateRootIndexGrouped(dmmf, inputTypeNames));
+    return files;
+}
+/**
+ * Generate all files for a single model
+ */
+function generateModelGrouped(model, dmmf, config, inputTypeNames) {
+    const files = [];
+    const modelDir = model.name;
+    const available = {
+        hasWhereInput: inputTypeNames.has(`${model.name}WhereInput`),
+        hasWhereUniqueInput: inputTypeNames.has(`${model.name}WhereUniqueInput`),
+        hasOrderByInput: inputTypeNames.has(`${model.name}OrderByWithRelationInput`),
+        hasCreateInput: inputTypeNames.has(`${model.name}CreateInput`),
+        hasCreateManyInput: inputTypeNames.has(`${model.name}CreateManyInput`),
+        hasUpdateInput: inputTypeNames.has(`${model.name}UpdateInput`),
+        hasUpdateManyInput: inputTypeNames.has(`${model.name}UpdateManyMutationInput`),
+        hasScalarWhereWithAggregates: inputTypeNames.has(`${model.name}ScalarWhereWithAggregatesInput`),
+    };
+    // Skip models with no query capability
+    if (!available.hasWhereInput && !available.hasWhereUniqueInput) {
+        return files;
+    }
+    // Generate model.ts
+    files.push({
+        path: `${modelDir}/model.ts`,
+        content: generateModelObjectType(model, dmmf, config),
+    });
+    // Generate inputs.ts
+    const modelInputTypes = getInputTypesForModel(model.name, dmmf);
+    if (modelInputTypes.length > 0) {
+        files.push({
+            path: `${modelDir}/inputs.ts`,
+            content: generateModelInputs(model, modelInputTypes, dmmf),
+        });
+    }
+    // Generate args.ts
+    files.push({
+        path: `${modelDir}/args.ts`,
+        content: generateModelArgs(model, available),
+    });
+    // Generate resolver.ts
+    if (config.generateResolvers) {
+        files.push({
+            path: `${modelDir}/resolver.ts`,
+            content: generateModelResolver(model, available),
+        });
+    }
+    // Generate index.ts
+    files.push({
+        path: `${modelDir}/index.ts`,
+        content: generateModelIndex(config, modelInputTypes.length > 0),
+    });
+    return files;
+}
+function getInputTypesForModel(modelName, dmmf) {
+    const result = [];
+    for (const [name, inputType] of dmmf.inputTypes) {
+        if (name.startsWith(modelName)) {
+            result.push(inputType);
+        }
+    }
+    return result;
+}
+// ============ Model ObjectType ============
+function generateModelObjectType(model, dmmf, config) {
+    const lines = [];
+    const hasJson = model.fields.some(f => f.type === 'Json');
+    const hasBigInt = model.fields.some(f => f.type === 'BigInt');
+    const relationFields = model.fields.filter(f => (0, transformer_1.isRelationField)(f));
+    const relatedModels = [...new Set(relationFields.map(f => f.type))].filter(m => m !== model.name);
+    const enumFields = model.fields.filter(f => (0, transformer_1.isEnumField)(f));
+    const enumTypes = [...new Set(enumFields.map(f => f.type))];
+    // Imports
+    lines.push(`import { ObjectType, Field, ID, Int, Float } from '@nestjs/graphql';`);
+    if (hasJson)
+        lines.push(`import { GraphQLJSON } from 'graphql-type-json';`);
+    if (hasBigInt)
+        lines.push(`import { GraphQLBigInt } from 'graphql-scalars';`);
+    if (relatedModels.length > 0) {
+        lines.push(`// eslint-disable-next-line @typescript-eslint/no-unused-vars`);
+        lines.push(`import type { ${relatedModels.join(', ')} } from '../index';`);
+    }
+    if (enumTypes.length > 0) {
+        lines.push(`import { ${enumTypes.join(', ')} } from '../enums';`);
+    }
+    lines.push('');
+    // Class
+    const className = `${config.typePrefix ?? ''}${model.name}${config.typeSuffix ?? ''}`;
+    const descOption = model.documentation ? `, { description: '${escapeStr(model.documentation)}' }` : '';
+    lines.push(`@ObjectType()${descOption}`);
+    lines.push(`export class ${className} {`);
+    for (const field of model.fields) {
+        lines.push(generateModelField(field, dmmf));
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+function generateModelField(field, _dmmf) {
+    const { graphqlType, tsType } = getFieldTypes(field);
+    const isRelation = (0, transformer_1.isRelationField)(field);
+    const lines = [];
+    let typeArg;
+    if (isRelation) {
+        typeArg = field.isList
+            ? `() => [require('../${field.type}/model').${field.type}]`
+            : `() => require('../${field.type}/model').${field.type}`;
+    }
+    else {
+        typeArg = field.isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`;
+    }
+    const options = [];
+    if (!field.isRequired && !field.isList)
+        options.push('nullable: true');
+    if (field.documentation)
+        options.push(`description: '${escapeStr(field.documentation)}'`);
+    const optionsStr = options.length > 0 ? `, { ${options.join(', ')} }` : '';
+    lines.push(`  @Field(${typeArg}${optionsStr})`);
+    let propertyType = tsType;
+    if (field.isList)
+        propertyType = `${tsType}[]`;
+    if (!field.isRequired)
+        propertyType = `${propertyType} | null`;
+    const modifier = field.isRequired || field.isList ? '!' : '?';
+    lines.push(`  ${field.name}${modifier}: ${propertyType};`);
+    lines.push('');
+    return lines.join('\n');
+}
+function getFieldTypes(field) {
+    if (field.isId)
+        return { graphqlType: 'ID', tsType: 'string' };
+    if ((0, transformer_1.isScalarField)(field)) {
+        if (field.type === 'Json')
+            return { graphqlType: 'GraphQLJSON', tsType: 'any' };
+        return {
+            graphqlType: types_1.PRISMA_TO_GRAPHQL_SCALAR[field.type] ?? 'String',
+            tsType: types_1.PRISMA_TO_TS_TYPE[field.type] ?? 'string',
+        };
+    }
+    if ((0, transformer_1.isEnumField)(field))
+        return { graphqlType: field.type, tsType: field.type };
+    if ((0, transformer_1.isRelationField)(field))
+        return { graphqlType: field.type, tsType: field.type };
+    return { graphqlType: 'String', tsType: 'string' };
+}
+// ============ Inputs ============
+function generateModelInputs(model, inputTypes, dmmf) {
+    const lines = [];
+    const hasJson = inputTypes.some(it => it.fields.some(f => f.type === 'Json'));
+    const hasBigInt = inputTypes.some(it => it.fields.some(f => f.type === 'BigInt'));
+    // Collect enums
+    const enumTypes = new Set();
+    for (const it of inputTypes) {
+        for (const f of it.fields) {
+            if (dmmf.isEnum(f.type))
+                enumTypes.add(f.type);
+        }
+    }
+    // Imports
+    lines.push(`import { InputType, Field, Int, Float } from '@nestjs/graphql';`);
+    if (hasJson)
+        lines.push(`import { GraphQLJSON } from 'graphql-type-json';`);
+    if (hasBigInt)
+        lines.push(`import { GraphQLBigInt } from 'graphql-scalars';`);
+    if (enumTypes.size > 0)
+        lines.push(`import { ${[...enumTypes].join(', ')} } from '../enums';`);
+    lines.push('');
+    for (const inputType of inputTypes) {
+        lines.push(generateInputClass(inputType, dmmf, model.name));
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function generateInputClass(inputType, dmmf, modelName) {
+    const lines = [];
+    lines.push(`@InputType()`);
+    lines.push(`export class ${inputType.name} {`);
+    for (const field of inputType.fields) {
+        lines.push(generateInputField(field, dmmf, inputType.name, modelName));
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+function generateInputField(field, dmmf, currentTypeName, modelName) {
+    const { graphqlType, tsType, isInputObjectType } = getInputFieldTypes(field, dmmf);
+    const lines = [];
+    let typeArg;
+    if (isInputObjectType && graphqlType !== currentTypeName) {
+        if (graphqlType.startsWith(modelName)) {
+            typeArg = field.isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`;
+        }
+        else {
+            const otherModel = graphqlType.replace(/(?:Where|Create|Update|OrderBy|Scalar).*Input$/, '');
+            typeArg = field.isList
+                ? `() => [require('../${otherModel}/inputs').${graphqlType}]`
+                : `() => require('../${otherModel}/inputs').${graphqlType}`;
+        }
+    }
+    else {
+        typeArg = field.isList ? `() => [${graphqlType}]` : `() => ${graphqlType}`;
+    }
+    const optionsStr = !field.isRequired ? ', { nullable: true }' : '';
+    lines.push(`  @Field(${typeArg}${optionsStr})`);
+    let propertyType = tsType;
+    if (field.isList)
+        propertyType = `${tsType}[]`;
+    if (!field.isRequired)
+        propertyType = `${propertyType} | undefined`;
+    const modifier = field.isRequired ? '!' : '?';
+    lines.push(`  ${field.name}${modifier}: ${propertyType};`);
+    lines.push('');
+    return lines.join('\n');
+}
+function getInputFieldTypes(field, dmmf) {
+    if (types_1.PRISMA_TO_GRAPHQL_SCALAR[field.type]) {
+        if (field.type === 'Json')
+            return { graphqlType: 'GraphQLJSON', tsType: 'any', isInputObjectType: false };
+        return {
+            graphqlType: types_1.PRISMA_TO_GRAPHQL_SCALAR[field.type] ?? 'String',
+            tsType: types_1.PRISMA_TO_TS_TYPE[field.type] ?? 'string',
+            isInputObjectType: false,
+        };
+    }
+    if (dmmf.isEnum(field.type))
+        return { graphqlType: field.type, tsType: field.type, isInputObjectType: false };
+    return { graphqlType: field.type, tsType: 'any', isInputObjectType: true };
+}
+// ============ Args ============
+function generateModelArgs(model, available) {
+    const lines = [];
+    const m = model.name;
+    // Imports
+    lines.push(`import { ArgsType, Field, Int } from '@nestjs/graphql';`);
+    const inputImports = [];
+    if (available.hasWhereInput)
+        inputImports.push(`${m}WhereInput`);
+    if (available.hasWhereUniqueInput)
+        inputImports.push(`${m}WhereUniqueInput`);
+    if (available.hasOrderByInput)
+        inputImports.push(`${m}OrderByWithRelationInput`);
+    if (available.hasCreateInput)
+        inputImports.push(`${m}CreateInput`);
+    if (available.hasCreateManyInput)
+        inputImports.push(`${m}CreateManyInput`);
+    if (available.hasUpdateInput)
+        inputImports.push(`${m}UpdateInput`);
+    if (available.hasUpdateManyInput)
+        inputImports.push(`${m}UpdateManyMutationInput`);
+    if (available.hasScalarWhereWithAggregates)
+        inputImports.push(`${m}ScalarWhereWithAggregatesInput`);
+    if (inputImports.length > 0) {
+        lines.push(`import { ${inputImports.join(', ')} } from './inputs';`);
+    }
+    lines.push(`import { ${m}ScalarFieldEnum } from '../enums';`);
+    lines.push('');
+    // Generate args classes
+    if (available.hasWhereInput) {
+        lines.push(generateFindManyArgs(m, available));
+        lines.push(generateFindFirstArgs(m, available));
+        lines.push(generateDeleteManyArgs(m));
+        lines.push(generateAggregateArgs(m, available));
+        lines.push(generateGroupByArgs(m, available));
+    }
+    if (available.hasWhereUniqueInput) {
+        lines.push(generateFindUniqueArgs(m));
+        lines.push(generateDeleteArgs(m));
+    }
+    if (available.hasCreateInput)
+        lines.push(generateCreateArgs(m));
+    if (available.hasCreateManyInput)
+        lines.push(generateCreateManyArgs(m));
+    if (available.hasUpdateInput && available.hasWhereUniqueInput)
+        lines.push(generateUpdateArgs(m));
+    if (available.hasUpdateManyInput && available.hasWhereInput)
+        lines.push(generateUpdateManyArgs(m));
+    if (available.hasCreateInput && available.hasUpdateInput && available.hasWhereUniqueInput) {
+        lines.push(generateUpsertArgs(m));
+    }
+    return lines.join('\n');
+}
+function generateFindManyArgs(m, a) {
+    return `@ArgsType()
+export class FindMany${m}Args {
+  @Field(() => ${m}WhereInput, { nullable: true })
+  where?: ${m}WhereInput;
+${a.hasOrderByInput ? `
+  @Field(() => [${m}OrderByWithRelationInput], { nullable: true })
+  orderBy?: ${m}OrderByWithRelationInput[];
+` : ''}${a.hasWhereUniqueInput ? `
+  @Field(() => ${m}WhereUniqueInput, { nullable: true })
+  cursor?: ${m}WhereUniqueInput;
+` : ''}
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => [${m}ScalarFieldEnum], { nullable: true })
+  distinct?: ${m}ScalarFieldEnum[];
+}
+`;
+}
+function generateFindFirstArgs(m, a) {
+    return `@ArgsType()
+export class FindFirst${m}Args {
+  @Field(() => ${m}WhereInput, { nullable: true })
+  where?: ${m}WhereInput;
+${a.hasOrderByInput ? `
+  @Field(() => [${m}OrderByWithRelationInput], { nullable: true })
+  orderBy?: ${m}OrderByWithRelationInput[];
+` : ''}${a.hasWhereUniqueInput ? `
+  @Field(() => ${m}WhereUniqueInput, { nullable: true })
+  cursor?: ${m}WhereUniqueInput;
+` : ''}
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+
+  @Field(() => [${m}ScalarFieldEnum], { nullable: true })
+  distinct?: ${m}ScalarFieldEnum[];
+}
+`;
+}
+function generateFindUniqueArgs(m) {
+    return `@ArgsType()
+export class FindUnique${m}Args {
+  @Field(() => ${m}WhereUniqueInput)
+  where!: ${m}WhereUniqueInput;
+}
+`;
+}
+function generateCreateArgs(m) {
+    return `@ArgsType()
+export class Create${m}Args {
+  @Field(() => ${m}CreateInput)
+  data!: ${m}CreateInput;
+}
+`;
+}
+function generateCreateManyArgs(m) {
+    return `@ArgsType()
+export class CreateMany${m}Args {
+  @Field(() => [${m}CreateManyInput])
+  data!: ${m}CreateManyInput[];
+}
+`;
+}
+function generateUpdateArgs(m) {
+    return `@ArgsType()
+export class Update${m}Args {
+  @Field(() => ${m}UpdateInput)
+  data!: ${m}UpdateInput;
+
+  @Field(() => ${m}WhereUniqueInput)
+  where!: ${m}WhereUniqueInput;
+}
+`;
+}
+function generateUpdateManyArgs(m) {
+    return `@ArgsType()
+export class UpdateMany${m}Args {
+  @Field(() => ${m}UpdateManyMutationInput)
+  data!: ${m}UpdateManyMutationInput;
+
+  @Field(() => ${m}WhereInput, { nullable: true })
+  where?: ${m}WhereInput;
+}
+`;
+}
+function generateUpsertArgs(m) {
+    return `@ArgsType()
+export class Upsert${m}Args {
+  @Field(() => ${m}WhereUniqueInput)
+  where!: ${m}WhereUniqueInput;
+
+  @Field(() => ${m}CreateInput)
+  create!: ${m}CreateInput;
+
+  @Field(() => ${m}UpdateInput)
+  update!: ${m}UpdateInput;
+}
+`;
+}
+function generateDeleteArgs(m) {
+    return `@ArgsType()
+export class Delete${m}Args {
+  @Field(() => ${m}WhereUniqueInput)
+  where!: ${m}WhereUniqueInput;
+}
+`;
+}
+function generateDeleteManyArgs(m) {
+    return `@ArgsType()
+export class DeleteMany${m}Args {
+  @Field(() => ${m}WhereInput, { nullable: true })
+  where?: ${m}WhereInput;
+}
+`;
+}
+function generateAggregateArgs(m, a) {
+    return `@ArgsType()
+export class Aggregate${m}Args {
+  @Field(() => ${m}WhereInput, { nullable: true })
+  where?: ${m}WhereInput;
+${a.hasOrderByInput ? `
+  @Field(() => [${m}OrderByWithRelationInput], { nullable: true })
+  orderBy?: ${m}OrderByWithRelationInput[];
+` : ''}${a.hasWhereUniqueInput ? `
+  @Field(() => ${m}WhereUniqueInput, { nullable: true })
+  cursor?: ${m}WhereUniqueInput;
+` : ''}
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+}
+`;
+}
+function generateGroupByArgs(m, a) {
+    return `@ArgsType()
+export class GroupBy${m}Args {
+  @Field(() => ${m}WhereInput, { nullable: true })
+  where?: ${m}WhereInput;
+${a.hasOrderByInput ? `
+  @Field(() => [${m}OrderByWithRelationInput], { nullable: true })
+  orderBy?: ${m}OrderByWithRelationInput[];
+` : ''}
+  @Field(() => [${m}ScalarFieldEnum])
+  by!: ${m}ScalarFieldEnum[];
+${a.hasScalarWhereWithAggregates ? `
+  @Field(() => ${m}ScalarWhereWithAggregatesInput, { nullable: true })
+  having?: ${m}ScalarWhereWithAggregatesInput;
+` : ''}
+  @Field(() => Int, { nullable: true })
+  take?: number;
+
+  @Field(() => Int, { nullable: true })
+  skip?: number;
+}
+`;
+}
+// ============ Resolver ============
+function generateModelResolver(model, ops) {
+    const m = model.name;
+    const lowerName = (0, transformer_1.camelCase)(m);
+    const pluralName = (0, pluralize_1.default)(lowerName);
+    const isAlreadyPlural = pluralName === lowerName;
+    const findManyMethod = isAlreadyPlural ? `findMany${m}` : pluralName;
+    const findUniqueMethod = isAlreadyPlural ? `findUnique${m}` : lowerName;
+    const lines = [];
+    // Imports
+    const nestjsImports = ['Resolver', 'Query', 'Args', 'Info', 'Int'];
+    if (ops.hasCreateInput || ops.hasUpdateInput)
+        nestjsImports.push('Mutation');
+    lines.push(`import { ${nestjsImports.join(', ')} } from '@nestjs/graphql';`);
+    lines.push(`import { GraphQLResolveInfo } from 'graphql';`);
+    lines.push(`import { ${m} } from './model';`);
+    lines.push(`import { AffectedRows } from '../common/AffectedRows';`);
+    lines.push(`import { transformInfoIntoPrismaArgs, getPrismaFromContext } from '../helpers';`);
+    const argsImports = [];
+    if (ops.hasWhereInput)
+        argsImports.push(`FindMany${m}Args`, `FindFirst${m}Args`, `DeleteMany${m}Args`);
+    if (ops.hasWhereUniqueInput)
+        argsImports.push(`FindUnique${m}Args`, `Delete${m}Args`);
+    if (ops.hasCreateInput)
+        argsImports.push(`Create${m}Args`);
+    if (ops.hasCreateManyInput)
+        argsImports.push(`CreateMany${m}Args`);
+    if (ops.hasUpdateInput && ops.hasWhereUniqueInput)
+        argsImports.push(`Update${m}Args`);
+    if (ops.hasUpdateManyInput && ops.hasWhereInput)
+        argsImports.push(`UpdateMany${m}Args`);
+    if (ops.hasCreateInput && ops.hasUpdateInput && ops.hasWhereUniqueInput)
+        argsImports.push(`Upsert${m}Args`);
+    if (argsImports.length > 0) {
+        lines.push(`import { ${argsImports.join(', ')} } from './args';`);
+    }
+    lines.push('');
+    lines.push(`@Resolver(() => ${m})`);
+    lines.push(`export class ${m}Resolver {`);
+    // Queries
+    if (ops.hasWhereInput) {
+        lines.push(resolverMethod('Query', findManyMethod, `FindMany${m}Args`, `[${m}]`, `Promise<${m}[]>`, lowerName, 'findMany'));
+        lines.push(resolverMethod('Query', `findFirst${m}`, `FindFirst${m}Args`, m, `Promise<${m} | null>`, lowerName, 'findFirst', true));
+    }
+    if (ops.hasWhereUniqueInput) {
+        lines.push(resolverMethod('Query', findUniqueMethod, `FindUnique${m}Args`, m, `Promise<${m} | null>`, lowerName, 'findUnique', true));
+    }
+    // Mutations
+    if (ops.hasCreateInput) {
+        lines.push(resolverMethod('Mutation', `createOne${m}`, `Create${m}Args`, m, `Promise<${m}>`, lowerName, 'create'));
+    }
+    if (ops.hasCreateManyInput) {
+        lines.push(resolverMethod('Mutation', `createMany${m}`, `CreateMany${m}Args`, 'AffectedRows', 'Promise<AffectedRows>', lowerName, 'createMany'));
+    }
+    if (ops.hasUpdateInput && ops.hasWhereUniqueInput) {
+        lines.push(resolverMethod('Mutation', `updateOne${m}`, `Update${m}Args`, m, `Promise<${m} | null>`, lowerName, 'update', true));
+    }
+    if (ops.hasUpdateManyInput && ops.hasWhereInput) {
+        lines.push(resolverMethod('Mutation', `updateMany${m}`, `UpdateMany${m}Args`, 'AffectedRows', 'Promise<AffectedRows>', lowerName, 'updateMany'));
+    }
+    if (ops.hasCreateInput && ops.hasUpdateInput && ops.hasWhereUniqueInput) {
+        lines.push(resolverMethod('Mutation', `upsertOne${m}`, `Upsert${m}Args`, m, `Promise<${m}>`, lowerName, 'upsert'));
+    }
+    if (ops.hasWhereUniqueInput) {
+        lines.push(resolverMethod('Mutation', `deleteOne${m}`, `Delete${m}Args`, m, `Promise<${m} | null>`, lowerName, 'delete', true));
+    }
+    if (ops.hasWhereInput) {
+        lines.push(resolverMethod('Mutation', `deleteMany${m}`, `DeleteMany${m}Args`, 'AffectedRows', 'Promise<AffectedRows>', lowerName, 'deleteMany'));
+    }
+    lines.push('}');
+    return lines.join('\n');
+}
+function resolverMethod(type, methodName, argsType, graphqlReturn, tsReturn, prismaModel, prismaMethod, nullable = false) {
+    const nullableOpt = nullable ? ', { nullable: true }' : '';
+    return `
+  @${type}(() => ${graphqlReturn}${nullableOpt})
+  async ${methodName}(@Args() args: ${argsType}, @Info() info: GraphQLResolveInfo): ${tsReturn} {
+    const select = transformInfoIntoPrismaArgs(info);
+    const prisma = getPrismaFromContext(info);
+    return prisma.${prismaModel}.${prismaMethod}({ ...args, ...select });
+  }
+`;
+}
+// ============ Model Index ============
+function generateModelIndex(config, hasInputs) {
+    const lines = [];
+    lines.push(`export * from './model';`);
+    if (hasInputs)
+        lines.push(`export * from './inputs';`);
+    lines.push(`export * from './args';`);
+    if (config.generateResolvers)
+        lines.push(`export * from './resolver';`);
+    return lines.join('\n');
+}
+// ============ Enums ============
+function generateEnumsGrouped(dmmf) {
+    const files = [];
+    for (const enumDef of dmmf.enums) {
+        const values = enumDef.values.map(v => `  ${v.name} = '${v.name}',`).join('\n');
+        const desc = enumDef.documentation ? `'${escapeStr(enumDef.documentation)}'` : 'undefined';
+        files.push({
+            path: `enums/${enumDef.name}.ts`,
+            content: `import { registerEnumType } from '@nestjs/graphql';
+
+export enum ${enumDef.name} {
+${values}
+}
+
+registerEnumType(${enumDef.name}, {
+  name: '${enumDef.name}',
+  description: ${desc},
+});
+`,
+        });
+    }
+    // Index file
+    const exports = dmmf.enums.map(e => `export * from './${e.name}';`).join('\n');
+    files.push({ path: 'enums/index.ts', content: exports + '\n' });
+    return files;
+}
+// ============ Common Types ============
+function generateCommonTypesGrouped() {
+    return [
+        {
+            path: 'common/AffectedRows.ts',
+            content: `import { ObjectType, Field, Int } from '@nestjs/graphql';
+
+@ObjectType()
+export class AffectedRows {
+  @Field(() => Int)
+  count!: number;
+}
+`,
+        },
+        {
+            path: 'common/index.ts',
+            content: `export * from './AffectedRows';\n`,
+        },
+    ];
+}
+// ============ Helpers ============
+function generateHelpersGrouped() {
+    return {
+        path: 'helpers.ts',
+        content: `import { parseResolveInfo, ResolveTree, FieldsByTypeName } from 'graphql-parse-resolve-info';
+import type { GraphQLResolveInfo } from 'graphql';
+
+export function transformInfoIntoPrismaArgs(info: GraphQLResolveInfo): { select?: Record<string, any>; include?: Record<string, any> } {
+  const parsedInfo = parseResolveInfo(info) as ResolveTree | null;
+  if (!parsedInfo) return {};
+
+  const select = buildPrismaSelect(parsedInfo.fieldsByTypeName);
+  return Object.keys(select).length > 0 ? { select } : {};
+}
+
+function buildPrismaSelect(fieldsByTypeName: FieldsByTypeName): Record<string, any> {
+  const result: Record<string, any> = {};
+
+  for (const typeName in fieldsByTypeName) {
+    const fields = fieldsByTypeName[typeName];
+    for (const fieldName in fields) {
+      if (fieldName.startsWith('__') || fieldName.startsWith('_count') || fieldName.startsWith('_avg') || fieldName.startsWith('_sum') || fieldName.startsWith('_min') || fieldName.startsWith('_max')) continue;
+
+      const field = fields[fieldName];
+      const nestedFields = field.fieldsByTypeName;
+
+      if (Object.keys(nestedFields).length > 0) {
+        const nestedSelect = buildPrismaSelect(nestedFields);
+        result[fieldName] = Object.keys(nestedSelect).length > 0 ? { select: nestedSelect } : true;
+      } else {
+        result[fieldName] = true;
+      }
+    }
+  }
+
+  return result;
+}
+
+export function getPrismaFromContext(info: GraphQLResolveInfo): any {
+  const context = (info.rootValue as any)?.context ?? info.rootValue;
+  const prisma = context?.prisma ?? context?.db;
+  if (!prisma) throw new Error('Prisma client not found in context. Please provide prisma in your GraphQL context.');
+  return prisma;
+}
+
+export function mergePrismaSelects(...selects: Array<{ select?: Record<string, any>; include?: Record<string, any> }>): { select?: Record<string, any>; include?: Record<string, any> } {
+  const result: { select?: Record<string, any>; include?: Record<string, any> } = {};
+  for (const s of selects) {
+    if (s.select) result.select = { ...(result.select ?? {}), ...s.select };
+    if (s.include) result.include = { ...(result.include ?? {}), ...s.include };
+  }
+  return result;
+}
+`,
+    };
+}
+// ============ Root Index ============
+function generateRootIndexGrouped(dmmf, inputTypeNames) {
+    const lines = [];
+    lines.push(`export * from './enums';`);
+    lines.push(`export * from './common';`);
+    lines.push(`export * from './helpers';`);
+    for (const model of dmmf.models) {
+        const hasWhereInput = inputTypeNames.has(`${model.name}WhereInput`);
+        const hasWhereUniqueInput = inputTypeNames.has(`${model.name}WhereUniqueInput`);
+        if (hasWhereInput || hasWhereUniqueInput) {
+            lines.push(`export * from './${model.name}';`);
+        }
+    }
+    return { path: 'index.ts', content: lines.join('\n') + '\n' };
+}
+// ============ Utilities ============
+function escapeStr(text) {
+    return text.replace(/'/g, "\\'").replace(/\n/g, '\\n');
+}
+//# sourceMappingURL=generate-grouped-fast.js.map