prisma-generator-express 1.1.0 → 1.2.0

package/README.md

@@ -1,7 +1,8 @@
 # Prisma Generator Express
 
-[![npm version](https://badge.fury.io/js/prisma-generator-express.svg)](https://badge.fury.io/js/prisma-generator-express)
+[![npm version](https://img.shields.io/npm/v/prisma-generator-express.svg)](https://www.npmjs.com/package/prisma-generator-express)
 [![npm](https://img.shields.io/npm/dt/prisma-generator-express.svg)](https://www.npmjs.com/package/prisma-generator-express)
+[![npm](https://img.shields.io/npm/types/prisma-generator-express)](https://www.npmjs.com/package/prisma-generator-express)
 [![HitCount](https://hits.dwyl.com/multipliedtwice/prisma-generator-express.svg?style=flat)](http://hits.dwyl.com/multipliedtwice/prisma-generator-express)
 [![npm](https://img.shields.io/npm/l/prisma-generator-express.svg)](LICENSE)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prisma-generator-express",
   "description": "Prisma generator of Express CRUD API",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "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,12 +37,13 @@
     "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",
   "repository": {
     "type": "git",
-    "url": "https://github.com/multipliedtwice/prisma-generator-express"
+    "url": "git+https://github.com/multipliedtwice/prisma-generator-express.git"
   },
   "author": "multipliedtwice",
   "keywords": [
@@ -50,6 +52,12 @@
     "crud",
     "generator"
   ],
+  "files": [
+    "dist/**/*",
+    "src/**/*",
+    "../../README.md",
+    "../../LICENSE"
+  ],
   "release": {
     "branches": [
       "master"

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);
+  }
+}`
+}

package/src/helpers/generateFindFirst.ts

@@ -0,0 +1,68 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the query parameter 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 generateFindFirstFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}FindFirst`
+  const queryTypeName = `Prisma.${modelName}FindFirstArgs`
+
+  return `
+${prismaImportStatement.replace('{ Prisma }', `{ Prisma, ${modelName} }`)}
+import { Request, Response, NextFunction } from 'express'
+import {
+  RequestHandler,
+  ParamsDictionary,
+} from 'express-serve-static-core' 
+import { ParsedQs } from 'qs';
+import { ZodTypeAny } from 'zod';
+
+export interface FindFirstRequest extends Request {
+  prisma: PrismaClient;
+  query: ${queryTypeName} & ParsedQs;
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+  passToNext?: boolean;
+  locals: {
+    data?: ${modelName} | null
+  }
+}
+export type FindFirstMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
+
+export async function ${functionName}(req: FindFirstRequest, 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()}.findFirst(req.query as ${queryTypeName});
+    if (req.passToNext) {
+      req.locals.data = data;
+      next();
+    } else 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. Attach omitOutputValidation = true to request to suppress this error.');
+    } else {
+      res.status(200).json(data); 
+    }
+  } catch (error) {
+    console.error('Error in handling request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateFindMany.ts

@@ -0,0 +1,68 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles multiple record retrieval with optional output validation using Zod.
+ * This version dynamically includes the correct type for the query parameter 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 generateFindManyFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}FindMany`
+  const queryTypeName = `Prisma.${modelName}FindManyArgs`
+
+  return `
+${prismaImportStatement.replace('{ Prisma }', `{ Prisma, ${modelName} }`)}
+import { Request, Response, NextFunction } from 'express'
+import {
+  RequestHandler,
+  ParamsDictionary,
+} from 'express-serve-static-core'
+import { ParsedQs } from 'qs';
+import { ZodTypeAny } from 'zod';
+
+export interface FindManyRequest extends Request {
+  prisma: PrismaClient;
+  query: ${queryTypeName} & ParsedQs;
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+  passToNext?: boolean;
+  locals: {
+    data?: ${modelName}[]
+  }
+}
+export type FindManyMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
+
+export async function ${functionName}(req: FindManyRequest, 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()}.findMany(req.query as ${queryTypeName});
+    if (req.passToNext) {
+      req.locals.data = data;
+      next();
+    } else 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. Attach omitOutputValidation = true to request to suppress this error.');
+    } else {
+      res.status(200).json(data);
+    }
+  } catch (error) {
+    console.error('Error in handling request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateFindUnique.ts

@@ -0,0 +1,68 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the query parameter 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 generateFindUniqueFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}FindUnique`
+  const queryTypeName = `Prisma.${modelName}FindUniqueArgs`
+
+  return `
+${prismaImportStatement.replace('{ Prisma }', `{ Prisma, ${modelName} }`)}
+import { Request, Response, NextFunction } from 'express'
+import {
+  RequestHandler,
+  ParamsDictionary,
+} from 'express-serve-static-core' 
+import { ParsedQs } from 'qs';
+import { ZodTypeAny } from 'zod';
+
+export interface FindUniqueRequest extends Request {
+  prisma: PrismaClient;
+  query: ${queryTypeName} & ParsedQs;
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+  passToNext?: boolean;
+  locals: {
+    data?: ${modelName} | null
+  }
+}
+export type FindUniqueMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
+
+export async function ${functionName}(req: FindUniqueRequest, 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()}.findUnique(req.query as ${queryTypeName});
+    if (req.passToNext) {
+      req.locals.data = data;
+      next();
+    } else 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. Attach omitOutputValidation = true to request to suppress this error.');
+    } else {
+      res.status(200).json(data);
+    }
+  } catch (error) {
+    console.error('Error in handling request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateGroupBy.ts

@@ -0,0 +1,58 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles groupBy 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 generateGroupByFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}GroupBy`
+  const argsTypeName = `Prisma.${modelName}GroupByArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
+import { ZodTypeAny } from 'zod';
+
+interface GroupByRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type GroupByMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
+
+export async function ${functionName}(req: GroupByRequest, 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()}.groupBy(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 groupBy request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateImportPrismaStatement.ts

@@ -0,0 +1,38 @@
+import { GeneratorOptions } from '@prisma/generator-helper'
+import path from 'path'
+
+interface ImportPrismaStatementOptions {
+  outputPath: string
+}
+
+function getImportGeneratorOptions(
+  options: GeneratorOptions,
+): ImportPrismaStatementOptions {
+  const clientGenerator = options.otherGenerators.find(
+    (gen) => gen.name === 'client',
+  )
+
+  if (!clientGenerator || !clientGenerator.output?.value) {
+    throw new Error('Prisma client generator not found.')
+  }
+
+  const modelDirPath = path.join(
+    options.generator.output?.value!,
+    'modelFolder', // workaround for saving with /modelName/operation structure
+  )
+  const clientOutputPath = clientGenerator.output.value
+
+  const relativeImportPath = path.relative(modelDirPath, clientOutputPath)
+
+  return {
+    outputPath: relativeImportPath.split(path.sep).join(path.posix.sep),
+  }
+}
+
+export function generateImportPrismaStatement(
+  generatorOptions: GeneratorOptions,
+): string {
+  const options = getImportGeneratorOptions(generatorOptions)
+  // console.log('options.outputPath :>> ', options.outputPath)
+  return `import type { Prisma } from '${options.outputPath}';\nimport type { PrismaClient } from '${options.outputPath}';\n`
+}

package/src/helpers/generateRouteFile.ts

@@ -0,0 +1,183 @@
+import { DMMF } from '@prisma/generator-helper'
+
+export function generateRouterFunction({
+  model,
+}: {
+  model: DMMF.Model
+}): string {
+  const modelName = model.name
+  const routerFunctionName = `${modelName}Router`
+
+  return `
+import express, { RequestHandler } from 'express';
+import { ${modelName}FindFirst, type FindFirstMiddleware } from './${modelName}FindFirst';
+import { ${modelName}FindMany, type FindManyMiddleware } from './${modelName}FindMany';
+import { ${modelName}FindUnique, type FindUniqueMiddleware } from './${modelName}FindUnique';
+import { ${modelName}Create, type CreateMiddleware } from './${modelName}Create';
+import { ${modelName}CreateMany, type CreateManyMiddleware } from './${modelName}CreateMany';
+import { ${modelName}Update, type UpdateMiddleware } from './${modelName}Update';
+import { ${modelName}UpdateMany, type UpdateManyMiddleware } from './${modelName}UpdateMany';
+import { ${modelName}Upsert, type UpsertMiddleware } from './${modelName}Upsert';
+import { ${modelName}Delete, type DeleteMiddleware } from './${modelName}Delete';
+import { ${modelName}DeleteMany, type DeleteManyMiddleware } from './${modelName}DeleteMany';
+import { ${modelName}Aggregate, type AggregateMiddleware } from './${modelName}Aggregate';
+import { ${modelName}Count, type CountMiddleware } from './${modelName}Count';
+import { ${modelName}GroupBy, type GroupByMiddleware } from './${modelName}GroupBy';
+
+interface RouteConfig {
+  findFirstMiddleware?: FindFirstMiddleware[]
+  findFirstNextMiddleware?: RequestHandler[]
+
+  findManyMiddleware?: FindManyMiddleware[]
+  findManyNextMiddleware?: RequestHandler[]
+  
+  findUniqueMiddleware?: FindUniqueMiddleware[]
+  findUniqueNextMiddleware?: RequestHandler[]
+
+  createMiddleware?: CreateMiddleware[]
+  createNextMiddleware?: RequestHandler[]
+
+  createManyMiddleware?: CreateManyMiddleware[]
+  createManyNextMiddleware?: RequestHandler[]
+
+  updateMiddleware?: UpdateMiddleware[]
+  updateNextMiddleware?: RequestHandler[]
+
+  updateManyMiddleware?: UpdateManyMiddleware[]
+  updateManyNextMiddleware?: RequestHandler[]
+
+  upsertMiddleware?: UpsertMiddleware[]
+  upsertNextMiddleware?: RequestHandler[]
+
+  deleteMiddleware?: DeleteMiddleware[]
+  deleteNextMiddleware?: RequestHandler[]
+
+  deleteManyMiddleware?: DeleteManyMiddleware[]
+  deleteManyNextMiddleware?: RequestHandler[]
+
+  aggregateMiddleware?: AggregateMiddleware[]
+  aggregateNextMiddleware?: RequestHandler[]
+
+  countMiddleware?: CountMiddleware[]
+  countNextMiddleware?: RequestHandler[]
+
+  groupByMiddleware?: GroupByMiddleware[]
+  groupByNextMiddleware?: RequestHandler[]
+}
+
+/**
+ * Generates an Express router for ${modelName} model.
+ * @param config Contains optional middleware to enable routes.
+ * @returns {express.Router}
+ */
+export function ${routerFunctionName}(config: RouteConfig) {
+  const router = express.Router();
+  
+  if (config?.findFirstMiddleware && config?.findFirstMiddleware.length) {
+    const middlewares = [...config.findFirstMiddleware, ${modelName}FindFirst]
+    if (config.findFirstNextMiddleware) {
+      middlewares.push(...config.findFirstNextMiddleware);
+    }
+    router.get('/first', ...middlewares as FindFirstMiddleware[]);
+  }
+
+  if (config?.findManyMiddleware && config?.findManyMiddleware.length) {
+    const middlewares = [...config.findManyMiddleware, ${modelName}FindMany]
+    if (config.findManyNextMiddleware) {
+      middlewares.push(...config.findManyNextMiddleware);
+    }
+    router.get('/', ...middlewares as FindManyMiddleware[]);
+  }
+
+  if (config?.findUniqueMiddleware && config?.findUniqueMiddleware.length) {
+    const middlewares = [...config.findUniqueMiddleware, ${modelName}FindUnique]
+    if (config.findUniqueNextMiddleware) {
+      middlewares.push(...config.findUniqueNextMiddleware);
+    }
+    router.get('/:id', ...middlewares as FindUniqueMiddleware[]);
+  }
+
+  if (config?.createMiddleware && config?.createMiddleware.length) {
+    const middlewares = [...config.createMiddleware, ${modelName}Create]
+    if (config.createNextMiddleware) {
+      middlewares.push(...config.createNextMiddleware);
+    }
+    router.post('/', ...middlewares);
+  }
+
+  if (config?.createManyMiddleware && config?.createManyMiddleware.length) {
+    const middlewares = [...config.createManyMiddleware, ${modelName}CreateMany]
+    if (config.createManyNextMiddleware) {
+      middlewares.push(...config.createManyNextMiddleware);
+    }
+    router.post('/many', ...middlewares);
+  }
+
+  if (config?.updateMiddleware && config?.updateMiddleware.length) {
+    const middlewares = [...config.updateMiddleware, ${modelName}Update]
+    if (config.updateNextMiddleware) {
+      middlewares.push(...config.updateNextMiddleware);
+    }
+    router.put('/', ...middlewares);
+  }
+
+  if (config?.updateManyMiddleware && config?.updateManyMiddleware.length) {
+    const middlewares = [...config.updateManyMiddleware, ${modelName}UpdateMany]
+    if (config.updateManyNextMiddleware) {
+      middlewares.push(...config.updateManyNextMiddleware);
+    }
+    router.put('/many', ...middlewares);
+  }
+
+  if (config?.upsertMiddleware && config?.upsertMiddleware.length) {
+    const middlewares = [...config.upsertMiddleware, ${modelName}Upsert]
+    if (config.upsertNextMiddleware) {
+      middlewares.push(...config.upsertNextMiddleware);
+    }
+    router.patch('/', ...middlewares);
+  }
+
+  if (config?.deleteMiddleware && config?.deleteMiddleware.length) {
+    const middlewares = [...config.deleteMiddleware, ${modelName}Delete]
+    if (config.deleteNextMiddleware) {
+      middlewares.push(...config.deleteNextMiddleware);
+    }
+    router.delete('/', ...middlewares);
+  }
+
+  if (config?.deleteManyMiddleware && config?.deleteManyMiddleware.length) {
+    const middlewares = [...config.deleteManyMiddleware, ${modelName}DeleteMany]
+    if (config.deleteManyNextMiddleware) {
+      middlewares.push(...config.deleteManyNextMiddleware);
+    }
+    router.delete('/many', ...middlewares);
+  }
+
+  if (config?.aggregateMiddleware && config?.aggregateMiddleware.length) {
+    const middlewares = [...config.aggregateMiddleware, ${modelName}Aggregate]
+    if (config.aggregateNextMiddleware) {
+      middlewares.push(...config.aggregateNextMiddleware);
+    }
+    router.get('/aggregate', ...middlewares);
+  }
+
+  if (config?.countMiddleware && config?.countMiddleware.length) {
+    const middlewares = [...config.countMiddleware, ${modelName}Count]
+    if (config.countNextMiddleware) {
+      middlewares.push(...config.countNextMiddleware);
+    }
+    router.get('/count', ...middlewares);
+  }
+
+  if (config?.groupByMiddleware && config?.groupByMiddleware.length) {
+    const middlewares = [...config.groupByMiddleware, ${modelName}GroupBy]
+    if (config.groupByNextMiddleware) {
+      middlewares.push(...config.groupByNextMiddleware);
+    }
+    router.get('/groupby', ...middlewares);
+  }
+
+  return router;
+}
+`
+}

package/src/helpers/generateUpdate.ts

@@ -0,0 +1,62 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles updating 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 generateUpdateFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}Update`
+  const argsTypeName = `Prisma.${modelName}UpdateArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface UpdateRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type UpdateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: UpdateRequest, 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()}.update({
+      where: { id: parseInt(req.params.id) },
+      data: 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 update request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateUpdateMany.ts

@@ -0,0 +1,59 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles updating 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 generateUpdateManyFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}UpdateMany`
+  const argsTypeName = `Prisma.${modelName}UpdateManyArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface UpdateManyRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type UpdateManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: UpdateManyRequest, 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()}.updateMany(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(data);
+      if (validationResult.success) {
+        res.status(200).json({ count: validationResult.data.count });
+      } 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({ count: data.count });
+    }
+  } catch (error) {
+    console.error('Error in handling updateMany request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/helpers/generateUpsert.ts

@@ -0,0 +1,60 @@
+import { DMMF } from '@prisma/generator-helper'
+
+/**
+ * Generates an Express middleware function that handles the upsert operation (create or update)
+ * 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 generateUpsertFunction = (options: {
+  model: DMMF.Model
+  prismaImportStatement: string
+}): string => {
+  const { model, prismaImportStatement } = options
+  const modelName = model.name
+  const functionName = `${modelName}Upsert`
+  const argsTypeName = `Prisma.${modelName}UpsertArgs`
+
+  return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface UpsertRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type UpsertMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: UpsertRequest, 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()}.upsert(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 upsert request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`
+}

package/src/utils/formatFile.ts

@@ -0,0 +1,22 @@
+import prettier from 'prettier'
+
+export const formatFile = (content: string): Promise<string> => {
+  return new Promise((res, rej) =>
+    prettier.resolveConfig(process.cwd()).then((options) => {
+      if (!options) {
+        res(content) // no prettier config was found, no need to format
+      }
+
+      try {
+        const formatted = prettier.format(content, {
+          ...options,
+          parser: 'typescript',
+        })
+
+        res(formatted)
+      } catch (error) {
+        rej(error)
+      }
+    })
+  )
+}

package/src/utils/writeFileSafely.ts

@@ -0,0 +1,28 @@
+import fs from 'fs/promises'
+import path from 'path'
+import { formatFile } from './formatFile'
+import { DMMF, GeneratorOptions } from '@prisma/generator-helper'
+
+export const writeFileSafely = async ({
+  model,
+  operation,
+  options,
+  content,
+}: {
+  model: DMMF.Model
+  operation: string
+  options: GeneratorOptions
+  content: string
+}) => {
+  const fileName = operation === 'index' ? 'index' : `${model.name}${operation}`
+  const filePath = path.join(
+    options.generator.output?.value!,
+    `${model.name}/${fileName}.ts`,
+  )
+  console.log('filePath :>> ', filePath)
+  await fs.mkdir(path.dirname(filePath), {
+    recursive: true,
+  })
+
+  await fs.writeFile(filePath, await formatFile(content))
+}

package/CHANGELOG.md

@@ -1,14 +0,0 @@
-# [1.1.0](https://github.com/multipliedtwice/prisma-generator-express/compare/v1.0.0...v1.1.0) (2024-05-15)
-
-
-### Features
-
-* **generator:** add MIT License and README file for Prisma Generator Express ([6c99565](https://github.com/multipliedtwice/prisma-generator-express/commit/6c995652c53946e0f3f303f0495fcfe4e7b96e48))
-* **generator:** update package.json description to provide a more specific description of the Prisma generator for Express CRUD API ([7b99050](https://github.com/multipliedtwice/prisma-generator-express/commit/7b99050d2089490082b6c6b7f5174f8572172779))
-
-# 1.0.0 (2024-05-15)
-
-
-### Bug Fixes
-
-* **generator:** update minimum required Node.js version to 20.0 in engines field ([1b4e7b2](https://github.com/multipliedtwice/prisma-generator-express/commit/1b4e7b2a8e29cc8a9710cc6393ada81b01631de3))