prisma-generator-express 1.14.3 → 1.15.1

package/dist/helpers/generateRouteFile.js

@@ -5,10 +5,7 @@ function generateRouterFunction({ model, }) {
     const modelName = model.name;
     const routerFunctionName = `${modelName}Router`;
     return `import express, {
-  NextFunction,
-  RequestHandler,
-  Request,
-  Response,
+  RequestHandler
 } from 'express'
 import { ParsedQs } from 'qs'
 import { ${modelName}FindFirst } from './${modelName}FindFirst';
@@ -24,16 +21,15 @@ 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 { createValidatorMiddleware, ValidatorOptions } from '../createValidatorMiddleware'
-import { createOutputValidatorMiddleware } from '../createOutputValidatorMiddleware'
+import { createValidatorMiddleware } from '../createValidatorMiddleware'
 import { RouteConfig, ValidatorConfig } from '../routeConfig'
 import { parseQueryParams } from "../parseQueryParams";
 
 const defaultBeforeAfter = {
   before: [] as RequestHandler[],
   after: [] as RequestHandler[],
-  input: undefined,
-  output: undefined,
+  inputValidator: undefined,
+  outputValidator: undefined,
 };
 
 /**
@@ -85,104 +81,104 @@ export function ${routerFunctionName}(config: RouteConfig<RequestHandler>) {
 
 
   if (config.enableAll || config?.findFirst) {
-    const { before = [], after = [], input, output } = config.findFirst || defaultBeforeAfter;
-    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.findFirst || defaultBeforeAfter;
+    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/first', ...after);
     }
   }
 
   if (config.enableAll || config?.findMany) {
-    const { before = [], after = [], input, output } = config.findMany || defaultBeforeAfter;
-    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.findMany || defaultBeforeAfter;
+    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.findUnique) {
-    const { before = [], after = [], input, output } = config.findUnique || defaultBeforeAfter;
-    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.findUnique || defaultBeforeAfter;
+    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/:id', ...after);
     }
   }
 
   if (config.enableAll || config?.create) {
-    const { before = [], after = [], input, output } = config.create || defaultBeforeAfter;
-    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.create || defaultBeforeAfter;
+    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.createMany) {
-    const { before = [], after = [], input, output } = config.createMany || defaultBeforeAfter;
-    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.createMany || defaultBeforeAfter;
+    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.update) {
-    const { before = [], after = [], input, output } = config.update || defaultBeforeAfter;
-    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.update || defaultBeforeAfter;
+    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.updateMany) {
-    const { before = [], after = [], input, output } = config.updateMany || defaultBeforeAfter;
-    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.updateMany || defaultBeforeAfter;
+    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.upsert) {
-    const { before = [], after = [], input, output } = config.upsert || defaultBeforeAfter;
-    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.upsert || defaultBeforeAfter;
+    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.delete) {
-    const { before = [], after = [], input, output } = config.delete || defaultBeforeAfter;
-    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.delete || defaultBeforeAfter;
+    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/', ...after);
     }
   }
 
   if (config.enableAll || config?.deleteMany) {
-    const { before = [], after = [], input, output } = config.deleteMany || defaultBeforeAfter;
-    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.deleteMany || defaultBeforeAfter;
+    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/many', ...after);
     }
   }
 
   if (config.enableAll || config?.aggregate) {
-    const { before = [], after = [], input, output } = config.aggregate || defaultBeforeAfter;
-    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.aggregate || defaultBeforeAfter;
+    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/aggregate', ...after);
     }
   }
 
   if (config.enableAll || config?.count) {
-    const { before = [], after = [], input, output } = config.count || defaultBeforeAfter;
-    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.count || defaultBeforeAfter;
+    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler, inputValidator, outputValidator);
     if (after.length) {
       router.use(basePath + '/count', ...after);
     }
   }
 
   if (config.enableAll || config?.groupBy) {
-    const { before = [], after = [], input, output } = config.groupBy || defaultBeforeAfter;
-    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler, input, output);
+    const { before = [], after = [], inputValidator, outputValidator) = config.groupBy || defaultBeforeAfter;
+    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler, inputValidator, outputValidator);
     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;;;;;;;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"}
+{"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;;;;WAIE,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;;;;;;;;;;;;;qCAab,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;AA/LD,wDA+LC"}

package/dist/helpers/generateUpdate.js

@@ -17,7 +17,6 @@ interface UpdateRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -29,13 +28,9 @@ export async function ${functionName}(req: UpdateRequest, res: Response, next: N
   try {
     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);
+    const data = await req.prisma.${(0, strings_1.toPascalCase)(modelName)}.update(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -45,8 +40,8 @@ export async function ${functionName}(req: UpdateRequest, res: Response, next: N
     } else {
       return res.status(200).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    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;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"}
+{"version":3,"file":"generateUpdate.js","sourceRoot":"","sources":["../../src/helpers/generateUpdate.ts"],"names":[],"mappings":";;;AACA,8CAA+C;AAQxC,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;;;;;;;uEAOiD,YAAY;;wBAE3D,YAAY;;;;oCAIA,IAAA,sBAAY,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;EAezD,CAAA;AACF,CAAC,CAAA;AA9CY,QAAA,sBAAsB,0BA8ClC"}

package/dist/helpers/generateUpdateMany.js

@@ -17,7 +17,6 @@ interface UpdateManyRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -29,13 +28,9 @@ export async function ${functionName}(req: UpdateManyRequest, res: Response, nex
   try {
     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);
+    const data = await req.prisma.${(0, strings_1.toPascalCase)(modelName)}.updateMany(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json({ count: validationResult.data.count });
@@ -45,8 +40,8 @@ export async function ${functionName}(req: UpdateManyRequest, res: Response, nex
     } else {
       return res.status(200).json({ count: data.count });
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    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;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"}
+{"version":3,"file":"generateUpdateMany.js","sourceRoot":"","sources":["../../src/helpers/generateUpdateMany.ts"],"names":[],"mappings":";;;AACA,8CAA+C;AAQxC,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;;;;;;;2EAOqD,YAAY;;wBAE/D,YAAY;;;;oCAIA,IAAA,sBAAY,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;EAezD,CAAA;AACF,CAAC,CAAA;AA9CY,QAAA,0BAA0B,8BA8CtC"}

package/dist/helpers/generateUpsert.js

@@ -17,7 +17,6 @@ interface UpsertRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -29,13 +28,9 @@ export async function ${functionName}(req: UpsertRequest, res: Response, next: N
   try {
     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);
+    const data = await req.prisma.${(0, strings_1.toPascalCase)(modelName)}.upsert(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -45,8 +40,8 @@ export async function ${functionName}(req: UpsertRequest, res: Response, next: N
     } else {
       return res.status(200).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    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;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"}
+{"version":3,"file":"generateUpsert.js","sourceRoot":"","sources":["../../src/helpers/generateUpsert.ts"],"names":[],"mappings":";;;AACA,8CAA+C;AASxC,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;;;;;;;uEAOiD,YAAY;;wBAE3D,YAAY;;;;oCAIA,IAAA,sBAAY,EAAC,SAAS,CAAC;;;;;;;;;;;;;;;EAezD,CAAA;AACF,CAAC,CAAA;AA9CY,QAAA,sBAAsB,0BA8ClC"}

package/dist/utils/strings.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lowercaseFirstLetter = exports.capitalize = void 0;
+exports.toPascalCase = exports.capitalize = void 0;
 const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 exports.capitalize = capitalize;
-function lowercaseFirstLetter(str) {
+function toPascalCase(str) {
     if (!str)
         return str;
     return str.charAt(0).toLowerCase() + str.slice(1);
 }
-exports.lowercaseFirstLetter = lowercaseFirstLetter;
+exports.toPascalCase = toPascalCase;
 //# sourceMappingURL=strings.js.map

package/dist/utils/strings.js.map

@@ -1 +1 @@
-{"version":3,"file":"strings.js","sourceRoot":"","sources":["../../src/utils/strings.ts"],"names":[],"mappings":";;;AAAO,MAAM,UAAU,GAAG,CAAC,GAAW,EAAE,EAAE,CACxC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AAD/B,QAAA,UAAU,cACqB;AAE5C,SAAgB,oBAAoB,CAAC,GAAW;IAC9C,IAAI,CAAC,GAAG;QAAE,OAAO,GAAG,CAAA;IACpB,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AACnD,CAAC;AAHD,oDAGC"}
+{"version":3,"file":"strings.js","sourceRoot":"","sources":["../../src/utils/strings.ts"],"names":[],"mappings":";;;AAAO,MAAM,UAAU,GAAG,CAAC,GAAW,EAAE,EAAE,CACxC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AAD/B,QAAA,UAAU,cACqB;AAE5C,SAAgB,YAAY,CAAC,GAAW;IACtC,IAAI,CAAC,GAAG;QAAE,OAAO,GAAG,CAAA;IACpB,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;AACnD,CAAC;AAHD,oCAGC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prisma-generator-express",
   "description": "Prisma generator of Express CRUD API",
-  "version": "1.14.3",
+  "version": "1.15.1",
   "main": "dist/generator.js",
   "license": "MIT",
   "bin": {
@@ -20,12 +20,12 @@
     "prepublishOnly": "node copy.js "
   },
   "dependencies": {
-    "@prisma/client": "5.14.0",
-    "@prisma/generator-helper": "5.14.0",
+    "@prisma/client": "5.15.0",
+    "@prisma/generator-helper": "5.15.0",
     "@prisma/sdk": "4.0.0",
     "express": "^4.19.2",
     "lodash": "^4.17.21",
-    "prettier": "3.2.5",
+    "prettier": "3.3.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
@@ -35,11 +35,11 @@
     "@types/express": "^4.17.21",
     "@types/jest": "29.5.12",
     "@types/lodash": "^4.17.4",
-    "@types/node": "20.12.13",
+    "@types/node": "20.14.2",
     "@types/prettier": "3.0.0",
     "jest": "29.7.0",
-    "prisma": "5.14.0",
-    "semantic-release": "^23.1.1",
+    "prisma": "5.15.0",
+    "semantic-release": "^24.0.0",
     "ts-jest": "29.1.4",
     "typescript": "5.4.5"
   },

package/src/generator.ts

@@ -35,6 +35,16 @@ generatorHandler({
     const prismaImportStatement = generateImportPrismaStatement(options)
 
     for await (const model of options.dmmf.datamodel.models) {
+      if (
+        model.documentation &&
+        model.documentation.includes('generator off')
+      ) {
+        logger.info(
+          `Skipping generation for model ${model.name} as it is marked with 'generator off'.`,
+        )
+        continue
+      }
+
       await writeFileSafely({
         content: generateFindUniqueFunction({
           model,

package/src/helpers/generateAggregate.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { capitalize, lowercaseFirstLetter } from '../utils/strings'
+import { capitalize, toPascalCase } from '../utils/strings'
 
 /**
  * Generates an Express middleware function that handles aggregation queries
@@ -29,7 +29,6 @@ interface AggregateRequest extends Request {
   prisma: PrismaClient;
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ValidatorConfig;
   };
@@ -41,13 +40,9 @@ export async function ${functionName}(req: AggregateRequest, res: Response, next
   try {
     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});
+    const result = await req.prisma.${toPascalCase(modelName)}.aggregate(req.query as ${argsTypeName});
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -57,8 +52,8 @@ export async function ${functionName}(req: AggregateRequest, res: Response, next
     } else {
       return res.status(200).json(result);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateCount.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 
 /**
  * Generates an Express middleware function that handles count queries
@@ -28,7 +28,6 @@ interface CountRequest extends Request {
   prisma: PrismaClient;
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -40,13 +39,9 @@ export async function ${functionName}(req: CountRequest, res: Response, next: Ne
   try {
     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});
+    const result = await req.prisma.${toPascalCase(modelName)}.count(req.query as ${argsTypeName});
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -56,8 +51,8 @@ export async function ${functionName}(req: CountRequest, res: Response, next: Ne
     } else {
       return res.status(200).json(result);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateCreate.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 
 /**
  * Generates an Express middleware function that handles creation of records and includes conditional output validation with Zod.
@@ -26,7 +26,6 @@ interface CreateRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -38,13 +37,9 @@ export async function ${functionName}(req: CreateRequest, res: Response, next: N
   try {
     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);
+    const data = await req.prisma.${toPascalCase(modelName)}.create(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(201).json(validationResult.data);
@@ -54,8 +49,8 @@ export async function ${functionName}(req: CreateRequest, res: Response, next: N
     } else {
       return res.status(201).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateCreateMany.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 /**
  * 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.
@@ -25,7 +25,6 @@ interface CreateManyRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -37,13 +36,9 @@ export async function ${functionName}(req: CreateManyRequest, res: Response, nex
   try {
     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);
+    const data = await req.prisma.${toPascalCase(modelName)}.createMany(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(201).json(validationResult.data);
@@ -53,8 +48,8 @@ export async function ${functionName}(req: CreateManyRequest, res: Response, nex
     } else {
       return res.status(201).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateDelete.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 
 /**
  * Generates an Express middleware function that handles deleting records
@@ -27,7 +27,6 @@ interface DeleteRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -39,13 +38,9 @@ export async function ${functionName}(req: DeleteRequest, res: Response, next: N
   try {
     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);
+    const data = await req.prisma.${toPascalCase(modelName)}.delete(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -55,8 +50,8 @@ export async function ${functionName}(req: DeleteRequest, res: Response, next: N
     } else {
       return res.status(200).json(data);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }

package/src/helpers/generateDeleteMany.ts

@@ -1,5 +1,5 @@
 import { DMMF } from '@prisma/generator-helper'
-import { lowercaseFirstLetter } from '../utils/strings'
+import { toPascalCase } from '../utils/strings'
 
 /**
  * Generates an Express middleware function that handles batch deleting records
@@ -27,7 +27,6 @@ interface DeleteManyRequest extends Request {
   prisma: PrismaClient;
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
   locals?: {
     outputValidator?: ZodTypeAny;
   };
@@ -39,13 +38,9 @@ export async function ${functionName}(req: DeleteManyRequest, res: Response, nex
   try {
     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);
+    const result = await req.prisma.${toPascalCase(modelName)}.deleteMany(req.body);
 
-    if (!req.omitOutputValidation && outputValidator) {
+    if (outputValidator) {
       const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
         return res.status(200).json(validationResult.data);
@@ -55,8 +50,8 @@ export async function ${functionName}(req: DeleteManyRequest, res: Response, nex
     } else {
       return res.status(200).json(result);
     }
-  } catch (error: unknown) {
-    return next(error);
+  } catch(error: unknown) {
+    next(error)
   }
 }`
 }