prisma-generator-express 1.12.0 → 1.14.0

package/src/copy/transformZod.ts

@@ -0,0 +1,140 @@
+import { get } from 'lodash'
+import {
+  z,
+  ZodEffects,
+  ZodError,
+  ZodIssue,
+  ZodIssueCode,
+  ZodObject,
+  ZodTypeAny,
+} from 'zod'
+
+function startsWith(str: string, prefix: string): boolean {
+  return str.slice(0, prefix.length) === prefix
+}
+
+function every<T>(
+  array: T[],
+  callback: (value: T, index: number, array: T[]) => boolean,
+): boolean {
+  for (let i = 0; i < array.length; i++) {
+    if (!callback(array[i], i, array)) {
+      return false
+    }
+  }
+  return true
+}
+
+function isKeyAllowed(key: string, allowedPaths: string[]): boolean {
+  return !every(
+    allowedPaths,
+    (path) =>
+      !startsWith(key.replace(/\[\d+\]/g, ''), path.replace(/\[\d+\]/g, '')) &&
+      !startsWith(path.replace(/\[\d+\]/g, ''), key.replace(/\[\d+\]/g, '')),
+  )
+}
+
+export function allow<T extends ZodTypeAny>(
+  schema: T,
+  allowedPaths: string[],
+): ZodEffects<T, any, any> {
+  const rootSchema = schema instanceof z.ZodObject ? schema : undefined
+
+  return schema.transform((data) => {
+    const flatData = flattenObject(data, '', rootSchema)
+    const disallowedPaths: string[] = []
+
+    for (const key of Object.keys(flatData)) {
+      if (!isKeyAllowed(key, allowedPaths)) {
+        disallowedPaths.push(key)
+      }
+    }
+
+    if (disallowedPaths.length > 0) {
+      const errors: ZodIssue[] = []
+      for (const path of disallowedPaths) {
+        errors.push({
+          code: ZodIssueCode.custom,
+          message: `Field '${path}' is not allowed.`,
+          path: path.split('.'),
+        })
+      }
+      throw new ZodError(errors)
+    }
+
+    return data
+  }) as ZodEffects<T, any, any>
+}
+
+export function forbid<T extends z.ZodTypeAny>(
+  schema: T,
+  forbiddenPaths: string[],
+): ZodEffects<T, any, any> {
+  return schema.transform((data) => {
+    const forbiddenMatches: string[] = []
+
+    for (const forbiddenPath of forbiddenPaths) {
+      const value = get(data, forbiddenPath)
+
+      if (value !== undefined) {
+        forbiddenMatches.push(forbiddenPath)
+      }
+    }
+
+    if (forbiddenMatches.length > 0) {
+      const errors: ZodIssue[] = []
+      for (const path of forbiddenMatches) {
+        errors.push({
+          code: ZodIssueCode.custom,
+          message: `Field '${path}' is forbidden.`,
+          path: [path],
+        })
+      }
+      throw new ZodError(errors)
+    }
+    return data
+  }) as ZodEffects<T, any, any>
+}
+
+export function flattenObject(
+  obj: Record<string, any>,
+  prefix = '',
+  schema?: ZodObject<any>,
+): Record<string, any> {
+  const result: Record<string, any> = {}
+
+  function flatten(current: any, prop: string, schema?: ZodObject<any>) {
+    if (Object(current) !== current) {
+      result[prop] = current
+    } else if (Array.isArray(current)) {
+      current.forEach((item, index) => {
+        flatten(item, `${prop}[]`, schema)
+      })
+    } else {
+      let isEmpty = true
+      for (const key in current) {
+        if (current.hasOwnProperty(key)) {
+          isEmpty = false
+          const currentSchema = schema?.shape[key]
+          if (
+            currentSchema instanceof z.ZodOptional &&
+            current[key] === undefined
+          ) {
+            continue
+          }
+          flatten(
+            current[key],
+            prop ? `${prop}.${key}` : key,
+            currentSchema instanceof ZodObject ? currentSchema : undefined,
+          )
+        }
+      }
+      if (isEmpty) {
+        result[prop] = {}
+      }
+    }
+  }
+
+  flatten(obj, prefix, schema)
+  return result
+}

package/src/generator.ts

@@ -17,8 +17,8 @@ import { generateDeleteManyFunction } from './helpers/generateDeleteMany'
 import { generateAggregateFunction } from './helpers/generateAggregate'
 import { generateCountFunction } from './helpers/generateCount'
 import { generateGroupByFunction } from './helpers/generateGroupBy'
-import { generateRouteConfigType } from './helpers/generateRouteConfigType'
-import { generateParseQueryParams } from './helpers/generateQsParser'
+
+import { copyFiles } from './utils/copyFiles'
 
 const { version } = require('../package.json')
 
@@ -173,16 +173,6 @@ generatorHandler({
       })
     }
 
-    await writeFileSafely({
-      content: generateRouteConfigType(),
-      options,
-      operation: 'RouteConfig',
-    })
-
-    await writeFileSafely({
-      content: generateParseQueryParams(),
-      options,
-      operation: 'ParseQueryParams',
-    })
+    await copyFiles(options)
   },
 })

package/src/helpers/generateAggregate.ts

@@ -23,42 +23,42 @@ import { Request, Response, NextFunction } from 'express';
 import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
 import { ParsedQs } from 'qs'
 import { ZodTypeAny } from 'zod';
+import { ValidatorConfig } from '../routeConfig'
 
 interface AggregateRequest extends Request {
   prisma: PrismaClient;
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ValidatorConfig;
+  };
 }
 
 export type AggregateMiddleware = RequestHandler<ParamsDictionary, any, Partial<${argsTypeName}>, Record<string, any>>;
 
 export async function ${functionName}(req: AggregateRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = res.locals.outputValidator?.schema || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const result = await req.prisma.${lowercaseFirstLetter(modelName)}.aggregate(req.query as ${argsTypeName});
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(result);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
     } else {
-      res.status(200).json(result);
+      return res.status(200).json(result);
     }
   } catch (error: unknown) {
-    console.error("Error in handling aggregation request:", error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateCount.ts

@@ -29,36 +29,35 @@ interface CountRequest extends Request {
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type CountMiddleware = RequestHandler<ParamsDictionary, any, {}, ParsedQs>;
 
 export async function ${functionName}(req: CountRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const result = await req.prisma.${lowercaseFirstLetter(modelName)}.count(req.query as ${argsTypeName});
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(result);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
     } else {
-      res.status(200).json(result);
+      return res.status(200).json(result);
     }
   } catch (error: unknown) {
-    console.error("Error in handling count request:", error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateCreate.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * 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.
@@ -26,37 +27,35 @@ interface CreateRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 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) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const data = await req.prisma.${lowercaseFirstLetter(modelName)}.create(req.body);
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(201).json(validationResult.data);
+        return res.status(201).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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);
+      return res.status(201).json(data);
     }
   } catch (error: unknown) {
-    console.error("Error in handling create request:", error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateCreateMany.ts

@@ -26,37 +26,35 @@ interface CreateManyRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 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) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const data = await req.prisma.${lowercaseFirstLetter(modelName)}.createMany(req.body);
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(201).json(validationResult.data);
+        return res.status(201).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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);
+      return res.status(201).json(data);
     }
   } catch (error: unknown) {
-    console.error('Error in handling createMany request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateDelete.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * Generates an Express middleware function that handles deleting records
  * and includes conditional output validation with Zod.
@@ -27,38 +28,35 @@ interface DeleteRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 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) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const data = await req.prisma.${lowercaseFirstLetter(modelName)}.delete(req.body);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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);
+      return res.status(200).json(data);
     }
   } catch (error: unknown) {
-    console.error('Error in handling delete request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateDeleteMany.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * Generates an Express middleware function that handles batch deleting records
  * and includes conditional output validation with Zod.
@@ -27,36 +28,35 @@ interface DeleteManyRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
-export type DeleteManyMiddleware = RequestHandler<ParamsDictionary, any, Prisma.${modelName}DeleteManyArgs, Record<string, any>>;
+export type DeleteManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
 
 export async function ${functionName}(req: DeleteManyRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const result = await req.prisma.${lowercaseFirstLetter(modelName)}.deleteMany(req.body);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(result);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
     } else {
-      res.status(200).json(result);
+      return res.status(200).json(result);
     }
   } catch (error: unknown) {
-    console.error('Error in handling batch delete request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateFindFirst.ts

@@ -33,13 +33,16 @@ export interface FindFirstRequest extends Request {
   passToNext?: boolean;
   locals?: {
     data?: ${modelName} | null
+    outputValidator?: ZodTypeAny;
   }
 }
 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) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
@@ -47,26 +50,18 @@ export async function ${functionName}(req: FindFirstRequest, res: Response, next
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    } else if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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); 
+      return res.status(200).json(data); 
     }
   } catch (error: unknown) {
-    console.error('Error in handling request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateFindMany.ts

@@ -33,13 +33,16 @@ export interface FindManyRequest extends Request {
   passToNext?: boolean;
   locals?: {
     data?: ${modelName}[]
+    outputValidator?: ZodTypeAny;
   }
 }
 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) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
@@ -47,26 +50,18 @@ export async function ${functionName}(req: FindManyRequest, res: Response, next:
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    } else if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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);
+      return res.status(200).json(data);
     }
   } catch (error: unknown) {
-    console.error('Error in handling request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateFindUnique.ts

@@ -33,13 +33,16 @@ export interface FindUniqueRequest extends Request {
   passToNext?: boolean;
   locals?: {
     data?: ${modelName} | null
+    outputValidator?: ZodTypeAny;
   }
 }
 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) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
@@ -47,26 +50,18 @@ export async function ${functionName}(req: FindUniqueRequest, res: Response, nex
     if (req.passToNext) {
       if (req.locals) req.locals.data = data;
       next();
-    } else if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    } else if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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);
+      return res.status(200).json(data);
     }
   } catch (error: unknown) {
-    console.error("Error in handling findUnique request:", error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }