prisma-generator-express 1.11.4 → 1.13.0

package/dist/helpers/generateFindUnique.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateFindUnique.js","sourceRoot":"","sources":["../../src/helpers/generateFindUnique.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAOhD,MAAM,0BAA0B,GAAG,CAAC,OAG1C,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,YAAY,CAAA;IAC7C,MAAM,aAAa,GAAG,UAAU,SAAS,gBAAgB,CAAA;IAEzD,OAAO;EACP,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE,aAAa,SAAS,IAAI,CAAC;;;;;;;;;;;WAW9D,aAAa;;;;;aAKX,SAAS;;;gFAG0D,aAAa;;wBAErE,YAAY;;;;;;oCAMA,IAAA,8BAAoB,EAAC,SAAS,CAAC,4BAA4B,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;EAyB1G,CAAA;AACF,CAAC,CAAA;AA/DY,QAAA,0BAA0B,8BA+DtC"}
+{"version":3,"file":"generateFindUnique.js","sourceRoot":"","sources":["../../src/helpers/generateFindUnique.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAOhD,MAAM,0BAA0B,GAAG,CAAC,OAG1C,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,YAAY,CAAA;IAC7C,MAAM,aAAa,GAAG,UAAU,SAAS,gBAAgB,CAAA;IAEzD,OAAO;EACP,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE,aAAa,SAAS,IAAI,CAAC;;;;;;;;;;;WAW9D,aAAa;;;;;aAKX,SAAS;;;;gFAI0D,aAAa;;wBAErE,YAAY;;;;;;;;oCAQA,IAAA,8BAAoB,EAAC,SAAS,CAAC,4BAA4B,aAAa;;;;;;;;;;;;;;;;;EAiB1G,CAAA;AACF,CAAC,CAAA;AA1DY,QAAA,0BAA0B,8BA0DtC"}

package/dist/helpers/generateGroupBy.js

@@ -19,37 +19,36 @@ interface GroupByRequest extends Request {
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type GroupByMiddleware = RequestHandler<ParamsDictionary, any, {}, ParsedQs>;
 
 export async function ${functionName}(req: GroupByRequest, 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.');
     }
 
     // @ts-ignore
     const result = await req.prisma.${(0, strings_1.lowercaseFirstLetter)(modelName)}.groupBy(req.query);
 
-    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 groupBy 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/dist/helpers/generateGroupBy.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateGroupBy.js","sourceRoot":"","sources":["../../src/helpers/generateGroupBy.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAUhD,MAAM,uBAAuB,GAAG,CAAC,OAGvC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,SAAS,CAAA;IAC1C,MAAM,YAAY,GAAG,UAAU,SAAS,aAAa,CAAA;IAErD,OAAO;EACP,qBAAqB;;;;;;;;mBAQJ,YAAY;;;;;;;wBAOP,YAAY;;;;;;;sCAOE,IAAA,8BAAoB,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;EAqBnE,CAAA;AACF,CAAC,CAAA;AAtDY,QAAA,uBAAuB,2BAsDnC"}
+{"version":3,"file":"generateGroupBy.js","sourceRoot":"","sources":["../../src/helpers/generateGroupBy.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAUhD,MAAM,uBAAuB,GAAG,CAAC,OAGvC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,SAAS,CAAA;IAC1C,MAAM,YAAY,GAAG,UAAU,SAAS,aAAa,CAAA;IAErD,OAAO;EACP,qBAAqB;;;;;;;;mBAQJ,YAAY;;;;;;;;;;wBAUP,YAAY;;;;;;;;;sCASE,IAAA,8BAAoB,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;EAenE,CAAA;AACF,CAAC,CAAA;AArDY,QAAA,uBAAuB,2BAqDnC"}

package/dist/helpers/generateRouteFile.js

@@ -4,8 +4,12 @@ exports.generateRouterFunction = void 0;
 function generateRouterFunction({ model, }) {
     const modelName = model.name;
     const routerFunctionName = `${modelName}Router`;
-    return `
-import express, { RequestHandler } from 'express';
+    return `import express, {
+  NextFunction,
+  RequestHandler,
+  Request,
+  Response,
+} from 'express'
 import { ParsedQs } from 'qs'
 import { ${modelName}FindFirst } from './${modelName}FindFirst';
 import { ${modelName}FindMany } from './${modelName}FindMany';
@@ -20,13 +24,16 @@ import { ${modelName}DeleteMany } from './${modelName}DeleteMany';
 import { ${modelName}Aggregate } from './${modelName}Aggregate';
 import { ${modelName}Count } from './${modelName}Count';
 import { ${modelName}GroupBy } from './${modelName}GroupBy';
-import { RouteConfig } from "../RouteConfig";
-import qs from "qs";
+import { createValidatorMiddleware, ValidatorOptions } from '../createValidatorMiddleware'
+import { createOutputValidatorMiddleware } from '../createOutputValidatorMiddleware'
+import { RouteConfig, ValidatorConfig } from '../routeConfig'
 import { parseQueryParams } from "../ParseQueryParams";
 
 const defaultBeforeAfter = {
   before: [] as RequestHandler[],
   after: [] as RequestHandler[],
+  input: undefined,
+  output: undefined,
 };
 
 /**
@@ -43,113 +50,139 @@ export function ${routerFunctionName}(config: RouteConfig<RequestHandler>) {
     path: string,
     method: "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head",
     middlewares: RequestHandler[],
-    handler: RequestHandler
+    handler: RequestHandler,
+    inputValidator?: ValidatorConfig,
+    outputValidator?: ValidatorConfig
   ) => {
-    router[method](basePath + path, (req, res, next) => {
-      if (req.query)
-        req.query = parseQueryParams(qs.parse(req.query as Record<string, string>)) as ParsedQs;      next();
-    }, ...middlewares, handler);
+    const middlewaresWithValidators: RequestHandler[] = [
+      (req, res, next) => {
+        if (req.query) {
+          req.query = parseQueryParams(req.query as Record<string, string>) as ParsedQs;
+        }
+        next();
+      },
+      ...middlewares
+    ];
+  
+    if (inputValidator) {
+      middlewaresWithValidators.push(createValidatorMiddleware({
+        schema: inputValidator.schema,
+        allowedPaths: inputValidator.allow,
+        forbiddenPaths: inputValidator.forbid,
+        target: method === 'get' ? 'query' : 'body',
+      }));
+    }
+  
+    middlewaresWithValidators.push((req, res, next) => {
+      res.locals.outputValidator = outputValidator;
+      next();
+    });
+  
+    middlewaresWithValidators.push(handler);
+  
+    router[method](basePath + path, ...middlewaresWithValidators);
   };
 
+
   if (config.enableAll || config?.findFirst) {
-    const { before = [], after = [] } = config.findFirst || defaultBeforeAfter;
-    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler);
+    const { before = [], after = [], input, output } = config.findFirst || defaultBeforeAfter;
+    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/first', ...after);
     }
   }
 
   if (config.enableAll || config?.findMany) {
-    const { before = [], after = [] } = config.findMany || defaultBeforeAfter;
-    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler);
+    const { before = [], after = [], input, output } = config.findMany || defaultBeforeAfter;
+    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.findUnique) {
-    const { before = [], after = [] } = config.findUnique || defaultBeforeAfter;
-    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any);
+    const { before = [], after = [], input, output } = config.findUnique || defaultBeforeAfter;
+    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any, input, output);
     if (after.length) {
       router.use(basePath + '/:id', ...after);
     }
   }
 
   if (config.enableAll || config?.create) {
-    const { before = [], after = [] } = config.create || defaultBeforeAfter;
-    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler);
+    const { before = [], after = [], input, output } = config.create || defaultBeforeAfter;
+    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.createMany) {
-    const { before = [], after = [] } = config.createMany || defaultBeforeAfter;
-    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler);
+    const { before = [], after = [], input, output } = config.createMany || defaultBeforeAfter;
+    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.update) {
-    const { before = [], after = [] } = config.update || defaultBeforeAfter;
-    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler);
+    const { before = [], after = [], input, output } = config.update || defaultBeforeAfter;
+    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.updateMany) {
-    const { before = [], after = [] } = config.updateMany || defaultBeforeAfter;
-    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler);
+    const { before = [], after = [], input, output } = config.updateMany || defaultBeforeAfter;
+    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.upsert) {
-    const { before = [], after = [] } = config.upsert || defaultBeforeAfter;
-    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler);
+    const { before = [], after = [], input, output } = config.upsert || defaultBeforeAfter;
+    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.delete) {
-    const { before = [], after = [] } = config.delete || defaultBeforeAfter;
-    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler);
+    const { before = [], after = [], input, output } = config.delete || defaultBeforeAfter;
+    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.deleteMany) {
-    const { before = [], after = [] } = config.deleteMany || defaultBeforeAfter;
-    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler);
+    const { before = [], after = [], input, output } = config.deleteMany || defaultBeforeAfter;
+    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.aggregate) {
-    const { before = [], after = [] } = config.aggregate || defaultBeforeAfter;
-    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler);
+    const { before = [], after = [], input, output } = config.aggregate || defaultBeforeAfter;
+    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/aggregate', ...after);
     }
   }
 
   if (config.enableAll || config?.count) {
-    const { before = [], after = [] } = config.count || defaultBeforeAfter;
-    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler);
+    const { before = [], after = [], input, output } = config.count || defaultBeforeAfter;
+    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/count', ...after);
     }
   }
 
   if (config.enableAll || config?.groupBy) {
-    const { before = [], after = [] } = config.groupBy || defaultBeforeAfter;
-    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler);
+    const { before = [], after = [], input, output } = config.groupBy || defaultBeforeAfter;
+    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/groupby', ...after);
     }

package/dist/helpers/generateRouteFile.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateRouteFile.js","sourceRoot":"","sources":["../../src/helpers/generateRouteFile.ts"],"names":[],"mappings":";;;AAEA,SAAgB,sBAAsB,CAAC,EACrC,KAAK,GAGN;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,kBAAkB,GAAG,GAAG,SAAS,QAAQ,CAAA;IAE/C,OAAO;;;WAGE,SAAS,uBAAuB,SAAS;WACzC,SAAS,sBAAsB,SAAS;WACxC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,oBAAoB,SAAS;WACtC,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,uBAAuB,SAAS;WACzC,SAAS,mBAAmB,SAAS;WACrC,SAAS,qBAAqB,SAAS;;;;;;;;;;;qCAWb,SAAS;;;;;kBAK5B,kBAAkB;;iFAE6C,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;0CAgB9D,SAAS;;;;;;;;qCAQd,SAAS;;;;;;;;wCAQN,SAAS;;;;;;;;sCAQX,SAAS;;;;;;;;0CAQL,SAAS;;;;;;;;qCAQd,SAAS;;;;;;;;yCAQL,SAAS;;;;;;;;uCAQX,SAAS;;;;;;;;wCAQR,SAAS;;;;;;;;4CAQL,SAAS;;;;;;;;8CAQP,SAAS;;;;;;;;0CAQb,SAAS;;;;;;;;4CAQP,SAAS;;;;;;;;CAQpD,CAAA;AACD,CAAC;AAlKD,wDAkKC"}
+{"version":3,"file":"generateRouteFile.js","sourceRoot":"","sources":["../../src/helpers/generateRouteFile.ts"],"names":[],"mappings":";;;AAEA,SAAgB,sBAAsB,CAAC,EACrC,KAAK,GAGN;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,kBAAkB,GAAG,GAAG,SAAS,QAAQ,CAAA;IAE/C,OAAO;;;;;;;WAOE,SAAS,uBAAuB,SAAS;WACzC,SAAS,sBAAsB,SAAS;WACxC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,oBAAoB,SAAS;WACtC,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,uBAAuB,SAAS;WACzC,SAAS,mBAAmB,SAAS;WACrC,SAAS,qBAAqB,SAAS;;;;;;;;;;;;;;qCAcb,SAAS;;;;;kBAK5B,kBAAkB;;iFAE6C,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CA0C9D,SAAS;;;;;;;;qCAQd,SAAS;;;;;;;;wCAQN,SAAS;;;;;;;;sCAQX,SAAS;;;;;;;;0CAQL,SAAS;;;;;;;;qCAQd,SAAS;;;;;;;;yCAQL,SAAS;;;;;;;;uCAQX,SAAS;;;;;;;;wCAQR,SAAS;;;;;;;;4CAQL,SAAS;;;;;;;;8CAQP,SAAS;;;;;;;;0CAQb,SAAS;;;;;;;;4CAQP,SAAS;;;;;;;;CAQpD,CAAA;AACD,CAAC;AAnMD,wDAmMC"}

package/dist/helpers/generateUpdate.js

@@ -18,38 +18,35 @@ interface UpdateRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 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) {
+    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.${(0, strings_1.lowercaseFirstLetter)(modelName)}.update(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 update 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/dist/helpers/generateUpdate.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateUpdate.js","sourceRoot":"","sources":["../../src/helpers/generateUpdate.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAOhD,MAAM,sBAAsB,GAAG,CAAC,OAGtC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,QAAQ,CAAA;IACzC,MAAM,YAAY,GAAG,UAAU,SAAS,YAAY,CAAA;IAEpD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;uEAKiD,YAAY;;wBAE3D,YAAY;;;;;;oCAMA,IAAA,8BAAoB,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;EAuBjE,CAAA;AACF,CAAC,CAAA;AAtDY,QAAA,sBAAsB,0BAsDlC"}
+{"version":3,"file":"generateUpdate.js","sourceRoot":"","sources":["../../src/helpers/generateUpdate.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAQhD,MAAM,sBAAsB,GAAG,CAAC,OAGtC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,QAAQ,CAAA;IACzC,MAAM,YAAY,GAAG,UAAU,SAAS,YAAY,CAAA;IAEpD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;;;;uEAQiD,YAAY;;wBAE3D,YAAY;;;;;;;;oCAQA,IAAA,8BAAoB,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;EAejE,CAAA;AACF,CAAC,CAAA;AAnDY,QAAA,sBAAsB,0BAmDlC"}

package/dist/helpers/generateUpdateMany.js

@@ -18,38 +18,35 @@ interface UpdateManyRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 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) {
+    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.${(0, strings_1.lowercaseFirstLetter)(modelName)}.updateMany(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({ count: validationResult.data.count });
+        return res.status(200).json({ count: validationResult.data.count });
       } 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({ count: data.count });
+      return res.status(200).json({ count: data.count });
     }
   } catch (error: unknown) {
-    console.error('Error in handling updateMany 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/dist/helpers/generateUpdateMany.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateUpdateMany.js","sourceRoot":"","sources":["../../src/helpers/generateUpdateMany.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAOhD,MAAM,0BAA0B,GAAG,CAAC,OAG1C,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,YAAY,CAAA;IAC7C,MAAM,YAAY,GAAG,UAAU,SAAS,gBAAgB,CAAA;IAExD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;2EAKqD,YAAY;;wBAE/D,YAAY;;;;;;oCAMA,IAAA,8BAAoB,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;EAuBjE,CAAA;AACF,CAAC,CAAA;AAtDY,QAAA,0BAA0B,8BAsDtC"}
+{"version":3,"file":"generateUpdateMany.js","sourceRoot":"","sources":["../../src/helpers/generateUpdateMany.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAQhD,MAAM,0BAA0B,GAAG,CAAC,OAG1C,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,YAAY,CAAA;IAC7C,MAAM,YAAY,GAAG,UAAU,SAAS,gBAAgB,CAAA;IAExD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;;;;2EAQqD,YAAY;;wBAE/D,YAAY;;;;;;;;oCAQA,IAAA,8BAAoB,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;EAejE,CAAA;AACF,CAAC,CAAA;AAnDY,QAAA,0BAA0B,8BAmDtC"}

package/dist/helpers/generateUpsert.js

@@ -18,38 +18,35 @@ interface UpsertRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 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) {
+    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.${(0, strings_1.lowercaseFirstLetter)(modelName)}.upsert(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 upsert 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/dist/helpers/generateUpsert.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateUpsert.js","sourceRoot":"","sources":["../../src/helpers/generateUpsert.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAQhD,MAAM,sBAAsB,GAAG,CAAC,OAGtC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,QAAQ,CAAA;IACzC,MAAM,YAAY,GAAG,UAAU,SAAS,YAAY,CAAA;IAEpD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;uEAKiD,YAAY;;wBAE3D,YAAY;;;;;;oCAMA,IAAA,8BAAoB,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;;;;;;;;;EAuBjE,CAAA;AACF,CAAC,CAAA;AAtDY,QAAA,sBAAsB,0BAsDlC"}
+{"version":3,"file":"generateUpsert.js","sourceRoot":"","sources":["../../src/helpers/generateUpsert.ts"],"names":[],"mappings":";;;AACA,8CAAuD;AAShD,MAAM,sBAAsB,GAAG,CAAC,OAGtC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,QAAQ,CAAA;IACzC,MAAM,YAAY,GAAG,UAAU,SAAS,YAAY,CAAA;IAEpD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;;;;uEAQiD,YAAY;;wBAE3D,YAAY;;;;;;;;oCAQA,IAAA,8BAAoB,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;EAejE,CAAA;AACF,CAAC,CAAA;AAnDY,QAAA,sBAAsB,0BAmDlC"}

package/dist/utils/copyFiles.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyFiles = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const copyFiles = async (options, destPath) => {
+    var _a;
+    const sourceDir = path_1.default.join(__dirname.replace('dist', 'src'), '..', 'copy');
+    const destinationDir = destPath || ((_a = options.generator.output) === null || _a === void 0 ? void 0 : _a.value);
+    const files = await promises_1.default.readdir(sourceDir);
+    for (const file of files) {
+        if (file.endsWith('.spec.ts')) {
+            continue;
+        }
+        const sourceFile = path_1.default.join(sourceDir, file);
+        const destinationFile = path_1.default.join(destinationDir, file);
+        await promises_1.default.mkdir(path_1.default.dirname(destinationFile), { recursive: true });
+        await promises_1.default.copyFile(sourceFile, destinationFile);
+    }
+    console.log(`Files copied from ${sourceDir} to ${destinationDir}`);
+};
+exports.copyFiles = copyFiles;
+//# sourceMappingURL=copyFiles.js.map

package/dist/utils/copyFiles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"copyFiles.js","sourceRoot":"","sources":["../../src/utils/copyFiles.ts"],"names":[],"mappings":";;;;;;AACA,2DAA4B;AAC5B,gDAAuB;AAEhB,MAAM,SAAS,GAAG,KAAK,EAC5B,OAAyB,EACzB,QAAiB,EACjB,EAAE;;IACF,MAAM,SAAS,GAAG,cAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE,KAAK,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAA;IAC3E,MAAM,cAAc,GAAG,QAAQ,KAAI,MAAA,OAAO,CAAC,SAAS,CAAC,MAAM,0CAAE,KAAM,CAAA,CAAA;IAEnE,MAAM,KAAK,GAAG,MAAM,kBAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;IAEzC,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YAC9B,SAAQ;QACV,CAAC;QAED,MAAM,UAAU,GAAG,cAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,CAAA;QAC7C,MAAM,eAAe,GAAG,cAAI,CAAC,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,CAAA;QAEvD,MAAM,kBAAE,CAAC,KAAK,CAAC,cAAI,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;QAClE,MAAM,kBAAE,CAAC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC,CAAA;IAChD,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,qBAAqB,SAAS,OAAO,cAAc,EAAE,CAAC,CAAA;AACpE,CAAC,CAAA;AAtBY,QAAA,SAAS,aAsBrB"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prisma-generator-express",
   "description": "Prisma generator of Express CRUD API",
-  "version": "1.11.4",
+  "version": "1.13.0",
   "main": "dist/generator.js",
   "license": "MIT",
   "bin": {
@@ -16,6 +16,7 @@
     "build": "npx tsc",
     "prepack": "yarn build",
     "test": "jest",
+    "coverage": "jest --coverage",
     "prepublishOnly": "node copy.js "
   },
   "dependencies": {
@@ -23,6 +24,7 @@
     "@prisma/generator-helper": "5.14.0",
     "@prisma/sdk": "4.0.0",
     "express": "^4.19.2",
+    "lodash": "^4.17.21",
     "prettier": "3.2.5",
     "zod": "^3.23.8"
   },
@@ -32,6 +34,7 @@
     "@semantic-release/git": "^10.0.1",
     "@types/express": "^4.17.21",
     "@types/jest": "29.5.12",
+    "@types/lodash": "^4.17.4",
     "@types/node": "20.12.12",
     "@types/prettier": "3.0.0",
     "jest": "29.7.0",

package/src/copy/createOutputValidatorMiddleware.ts

@@ -0,0 +1,44 @@
+import { NextFunction } from 'express'
+import { allow, forbid } from './transformZod'
+import { ValidatorOptions } from './createValidatorMiddleware'
+
+/**
+ * Creates a middleware for validating response data using a Zod schema.
+ * @param {ValidatorOptions} options - The validation options.
+ * @param {ZodSchema<any>} options.schema - The Zod schema to validate the response data.
+ * @param {string[]} [options.allowedPaths] - Paths that are allowed in the response data.
+ * @param {string[]} [options.forbiddenPaths] - Paths that are forbidden in the response data.
+ * @returns {function} Express middleware function.
+ */
+export function createOutputValidatorMiddleware({
+  schema,
+  allowedPaths,
+  forbiddenPaths,
+}: ValidatorOptions) {
+  if (allowedPaths) {
+    schema = allow(schema, allowedPaths)
+  }
+
+  if (forbiddenPaths) {
+    schema = forbid(schema, forbiddenPaths)
+  }
+
+  return (req: Request, res: Response, next: NextFunction) => {
+    const originalSend = res.send
+
+    res.send = function (data) {
+      const validationResult = schema.safeParse(data)
+      if (!validationResult.success) {
+        const errors = validationResult.error.errors
+        return next({
+          status: 400,
+          message: 'Output validation failed',
+          errors,
+        })
+      }
+      return originalSend.call(this, data)
+    }
+
+    next()
+  }
+}

package/src/copy/createValidatorMiddleware.ts

@@ -0,0 +1,55 @@
+import { Request, Response, NextFunction } from 'express'
+import { ZodSchema } from 'zod'
+import { allow, forbid } from './transformZod'
+
+export interface ValidatorOptions {
+  schema: ZodSchema<any>
+  allowedPaths?: string[]
+  forbiddenPaths?: string[]
+  target?: 'body' | 'query'
+}
+
+/**
+ * Creates a middleware for validating request data using a Zod schema.
+ * @param {ValidatorOptions} options - The validation options.
+ * @param {ZodSchema<any>} options.schema - The Zod schema to validate the request data.
+ * @param {string[]} [options.allowedPaths] - Paths that are allowed in the request data. For example [`where.user.id`, `select.id`]
+ * @param {string[]} [options.forbiddenPaths] - Paths that are forbidden in the request data.
+ * @param {'body' | 'query'} [options.target='body'] - The part of the request to validate ('body' or 'query').
+ * @returns {function} Express middleware function.
+ */
+export function createValidatorMiddleware({
+  schema,
+  allowedPaths,
+  forbiddenPaths,
+  target = 'body',
+}: ValidatorOptions) {
+  if (allowedPaths) {
+    schema = allow(schema, allowedPaths)
+  }
+
+  if (forbiddenPaths) {
+    schema = forbid(schema, forbiddenPaths)
+  }
+
+  return (req: Request, res: Response, next: NextFunction) => {
+    let validationResult
+
+    if (target === 'query') {
+      validationResult = schema.safeParse(req.query)
+    } else {
+      validationResult = schema.safeParse(req.body)
+    }
+
+    if (!validationResult.success) {
+      const errors = validationResult.error.errors
+      return next({
+        status: 400,
+        message: 'Validation failed',
+        errors,
+      })
+    }
+
+    next()
+  }
+}