prisma-generator-express 1.0.4 → 1.0.5

package/dist/utils/formatFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatFile.js","sourceRoot":"","sources":["../../src/utils/formatFile.ts"],"names":[],"mappings":";;;;;;AAAA,wDAA+B;AAExB,MAAM,UAAU,GAAG,CAAC,OAAe,EAAmB,EAAE;IAC7D,OAAO,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAC9B,kBAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;QACrD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,GAAG,CAAC,OAAO,CAAC,CAAA;QACd,CAAC;QAED,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,kBAAQ,CAAC,MAAM,CAAC,OAAO,EAAE;gBACzC,GAAG,OAAO;gBACV,MAAM,EAAE,YAAY;aACrB,CAAC,CAAA;YAEF,GAAG,CAAC,SAAS,CAAC,CAAA;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,GAAG,CAAC,KAAK,CAAC,CAAA;QACZ,CAAC;IACH,CAAC,CAAC,CACH,CAAA;AACH,CAAC,CAAA;AAnBY,QAAA,UAAU,cAmBtB"}

package/dist/utils/getGeneratorOptions.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGeneratorOptions = void 0;
+function getGeneratorOptions(options) {
+    var _a;
+    return {
+        isCustomPrismaClientOutputPath: Boolean(options.generator.config.customOutputPath),
+        outputPath: ((_a = options.generator.output) === null || _a === void 0 ? void 0 : _a.value) || './generated',
+        prismaClientOutputPath: (options.generator.config.clientPath ||
+            '@prisma/client'),
+    };
+}
+exports.getGeneratorOptions = getGeneratorOptions;
+//# sourceMappingURL=getGeneratorOptions.js.map

package/dist/utils/getGeneratorOptions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getGeneratorOptions.js","sourceRoot":"","sources":["../../src/utils/getGeneratorOptions.ts"],"names":[],"mappings":";;;AAGA,SAAgB,mBAAmB,CACjC,OAAyB;;IAEzB,OAAO;QACL,8BAA8B,EAAE,OAAO,CACrC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAC1C;QACD,UAAU,EAAE,CAAA,MAAA,OAAO,CAAC,SAAS,CAAC,MAAM,0CAAE,KAAK,KAAI,aAAa;QAC5D,sBAAsB,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,UAAU;YAC1D,gBAAgB,CAAW;KAC9B,CAAA;AACH,CAAC;AAXD,kDAWC"}

package/dist/utils/writeFileSafely.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileSafely = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const formatFile_1 = require("./formatFile");
+const writeFileSafely = async ({ model, operation, options, content, }) => {
+    var _a;
+    const fileName = operation === 'index' ? 'index' : `${model.name}${operation}`;
+    const filePath = path_1.default.join((_a = options.generator.output) === null || _a === void 0 ? void 0 : _a.value, `${model.name}/${fileName}.ts`);
+    console.log('filePath :>> ', filePath);
+    await promises_1.default.mkdir(path_1.default.dirname(filePath), {
+        recursive: true,
+    });
+    await promises_1.default.writeFile(filePath, await (0, formatFile_1.formatFile)(content));
+};
+exports.writeFileSafely = writeFileSafely;
+//# sourceMappingURL=writeFileSafely.js.map

package/dist/utils/writeFileSafely.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeFileSafely.js","sourceRoot":"","sources":["../../src/utils/writeFileSafely.ts"],"names":[],"mappings":";;;;;;AAAA,2DAA4B;AAC5B,gDAAuB;AACvB,6CAAyC;AAGlC,MAAM,eAAe,GAAG,KAAK,EAAE,EACpC,KAAK,EACL,SAAS,EACT,OAAO,EACP,OAAO,GAMR,EAAE,EAAE;;IACH,MAAM,QAAQ,GAAG,SAAS,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,GAAG,SAAS,EAAE,CAAA;IAC9E,MAAM,QAAQ,GAAG,cAAI,CAAC,IAAI,CACxB,MAAA,OAAO,CAAC,SAAS,CAAC,MAAM,0CAAE,KAAM,EAChC,GAAG,KAAK,CAAC,IAAI,IAAI,QAAQ,KAAK,CAC/B,CAAA;IACD,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAA;IACtC,MAAM,kBAAE,CAAC,KAAK,CAAC,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;QACrC,SAAS,EAAE,IAAI;KAChB,CAAC,CAAA;IAEF,MAAM,kBAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAA,uBAAU,EAAC,OAAO,CAAC,CAAC,CAAA;AACzD,CAAC,CAAA;AAtBY,QAAA,eAAe,mBAsB3B"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prisma-generator-express",
   "description": "Prisma generator of Express CRUD API",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "main": "dist/generator.js",
   "license": "MIT",
   "bin": {
@@ -15,7 +15,8 @@
     "dev": "npx tsc -w",
     "build": "npx tsc",
     "prepack": "yarn build",
-    "test": "jest"
+    "test": "jest",
+    "prepublishOnly": "node copy.js "
   },
   "dependencies": {
     "@prisma/client": "5.14.0",
@@ -36,6 +37,7 @@
     "prisma": "5.14.0",
     "semantic-release": "^23.1.1",
     "ts-jest": "29.1.2",
+    "shx": "^0.3.4",
     "typescript": "5.4.5"
   },
   "homepage": "https://github.com/multipliedtwice/prisma-generator-express/blob/master/README.md",
@@ -51,8 +53,10 @@
     "generator"
   ],
   "files": [
-    "../../../README.md",
-    "../../../LICENSE"
+    "dist/**/*",
+    "src/**/*",
+    "../../README.md",
+    "../../LICENSE"
   ],
   "release": {
     "branches": [

package/src/bin.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './generator'

package/src/constants.ts

@@ -0,0 +1 @@
+export const GENERATOR_NAME = 'prisma-generator-express'

package/src/generator.ts

@@ -0,0 +1,174 @@
+import { generatorHandler, GeneratorOptions } from '@prisma/generator-helper'
+import { logger } from '@prisma/sdk'
+import { GENERATOR_NAME } from './constants'
+import { writeFileSafely } from './utils/writeFileSafely'
+import { generateFindUniqueFunction } from './helpers/generateFindUnique'
+import { generateImportPrismaStatement } from './helpers/generateImportPrismaStatement'
+import { generateFindManyFunction } from './helpers/generateFindMany'
+import { generateFindFirstFunction } from './helpers/generateFindFirst'
+import { generateCreateFunction } from './helpers/generateCreate'
+import { generateRouterFunction } from './helpers/generateRouteFile'
+import { generateCreateManyFunction } from './helpers/generateCreateMany'
+import { generateUpdateFunction } from './helpers/generateUpdate'
+import { generateUpdateManyFunction } from './helpers/generateUpdateMany'
+import { generateUpsertFunction } from './helpers/generateUpsert'
+import { generateDeleteFunction } from './helpers/generateDelete'
+import { generateDeleteManyFunction } from './helpers/generateDeleteMany'
+import { generateAggregateFunction } from './helpers/generateAggregate'
+import { generateCountFunction } from './helpers/generateCount'
+import { generateGroupByFunction } from './helpers/generateGroupBy'
+
+const { version } = require('../package.json')
+
+generatorHandler({
+  onManifest() {
+    logger.info(`${GENERATOR_NAME}:Registered`)
+    return {
+      version,
+      defaultOutput: '../generated',
+      prettyName: GENERATOR_NAME,
+    }
+  },
+  onGenerate: async (options: GeneratorOptions) => {
+    const prismaImportStatement = generateImportPrismaStatement(options)
+
+    options.dmmf.datamodel.models.forEach(async (model) => {
+      await writeFileSafely({
+        content: generateFindUniqueFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'FindUnique',
+      })
+
+      await writeFileSafely({
+        content: generateFindFirstFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'FindFirst',
+      })
+
+      await writeFileSafely({
+        content: generateFindManyFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'FindMany',
+      })
+
+      await writeFileSafely({
+        content: generateCreateFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'Create',
+      })
+
+      await writeFileSafely({
+        content: generateCreateManyFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'CreateMany',
+      })
+
+      await writeFileSafely({
+        content: generateUpdateFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'Update',
+      })
+
+      await writeFileSafely({
+        content: generateUpdateManyFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'UpdateMany',
+      })
+
+      await writeFileSafely({
+        content: generateUpsertFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'Upsert',
+      })
+
+      await writeFileSafely({
+        content: generateDeleteFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'Delete',
+      })
+
+      await writeFileSafely({
+        content: generateDeleteManyFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'DeleteMany',
+      })
+
+      await writeFileSafely({
+        content: generateAggregateFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'Aggregate',
+      })
+
+      await writeFileSafely({
+        content: generateCountFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'Count',
+      })
+
+      await writeFileSafely({
+        content: generateGroupByFunction({
+          model,
+          prismaImportStatement,
+        }),
+        options,
+        model,
+        operation: 'GroupBy',
+      })
+
+      await writeFileSafely({
+        content: generateRouterFunction({ model }),
+        options,
+        model,
+        operation: 'index',
+      })
+    })
+  },
+})

package/src/helpers/generateAggregate.ts

@@ -0,0 +1,58 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles aggregation queries
+ * and includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the arguments based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
+export const generateAggregateFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}Aggregate`
+  const argsTypeName = `Prisma.${modelName}AggregateArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
+import { ZodTypeAny } from 'zod';
+
+interface AggregateRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type AggregateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
+
+export async function ${functionName}(req: AggregateRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const result = await req.prisma.${modelName.toLowerCase()}.aggregate(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(result);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else {
+      res.status(200).json(result);
+    }
+  } catch (error) {
+    console.error('Error in handling aggregation request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateCount.ts

@@ -0,0 +1,58 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles count queries
+ * and includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the arguments based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
+export const generateCountFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}Count`
+  const argsTypeName = `Prisma.${modelName}CountArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
+import { ZodTypeAny } from 'zod';
+
+interface CountRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type CountMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
+
+export async function ${functionName}(req: CountRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const result = await req.prisma.${modelName.toLowerCase()}.count(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(result);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else {
+      res.status(200).json(result);
+    }
+  } catch (error) {
+    console.error('Error in handling count request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateCreate.ts

@@ -0,0 +1,58 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles creation of records and includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the arguments based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
+export const generateCreateFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}Create`
+  const argsTypeName = `Prisma.${modelName}CreateArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
+import { ZodTypeAny } from 'zod';
+
+interface CreateRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type CreateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: CreateRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const data = await req.prisma.${modelName.toLowerCase()}.create(req.body);
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(data);
+      if (validationResult.success) {
+        res.status(201).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else if (!req.omitOutputValidation) {
+      throw new Error('Output validation schema must be provided unless explicitly omitted.');
+    } else {
+      res.status(201).json(data);
+    }
+  } catch (error) {
+    console.error('Error in handling create request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateCreateMany.ts

@@ -0,0 +1,58 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles the creation of multiple records and includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the arguments based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
+export const generateCreateManyFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}CreateMany`
+  const argsTypeName = `Prisma.${modelName}CreateManyArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface CreateManyRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type CreateManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: CreateManyRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const data = await req.prisma.${modelName.toLowerCase()}.createMany(req.body);
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(data);
+      if (validationResult.success) {
+        res.status(201).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else if (!req.omitOutputValidation) {
+      throw new Error('Output validation schema must be provided unless explicitly omitted.');
+    } else {
+      res.status(201).json(data);
+    }
+  } catch (error) {
+    console.error('Error in handling createMany request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateDelete.ts

@@ -0,0 +1,60 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles deleting records
+ * and includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the arguments based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
+export const generateDeleteFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}Delete`
+  const argsTypeName = `Prisma.${modelName}DeleteArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface DeleteRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type DeleteMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: DeleteRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const data = await req.prisma.${modelName.toLowerCase()}.delete(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(data);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else if (!req.omitOutputValidation) {
+      throw new Error('Output validation schema must be provided unless explicitly omitted.');
+    } else {
+      res.status(200).json(data);
+    }
+  } catch (error) {
+    console.error('Error in handling delete request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateDeleteMany.ts

@@ -0,0 +1,58 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles batch deleting records
+ * and includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the arguments based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
+export const generateDeleteManyFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}DeleteMany`
+  const argsTypeName = `Prisma.${modelName}DeleteManyArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface DeleteManyRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type DeleteManyMiddleware = RequestHandler<ParamsDictionary, any, Prisma.${modelName}DeleteManyArgs, Record<string, any>>;
+
+export async function ${functionName}(req: DeleteManyRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const result = await req.prisma.${modelName.toLowerCase()}.deleteMany(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(result);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else {
+      res.status(200).json(result);
+    }
+  } catch (error) {
+    console.error('Error in handling batch delete request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}