prisma-generator-express 1.7.1 → 1.8.0

package/src/helpers/generateRouteFile.ts

@@ -10,171 +10,146 @@ export function generateRouterFunction({
 
   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[]
-}
+import { ${modelName}FindFirst } from './${modelName}FindFirst';
+import { ${modelName}FindMany } from './${modelName}FindMany';
+import { ${modelName}FindUnique } from './${modelName}FindUnique';
+import { ${modelName}Create } from './${modelName}Create';
+import { ${modelName}CreateMany } from './${modelName}CreateMany';
+import { ${modelName}Update } from './${modelName}Update';
+import { ${modelName}UpdateMany } from './${modelName}UpdateMany';
+import { ${modelName}Upsert } from './${modelName}Upsert';
+import { ${modelName}Delete } from './${modelName}Delete';
+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";
+
+const defaultBeforeAfter = {
+  before: [] as RequestHandler[],
+  after: [] as RequestHandler[],
+};
 
 /**
  * Generates an Express router for ${modelName} model.
  * @param config Contains optional middleware to enable routes.
  * @returns {express.Router}
  */
-export function ${routerFunctionName}(config: RouteConfig) {
+export function ${routerFunctionName}(config: RouteConfig<RequestHandler>) {
   const router = express.Router();
-  
-  if (config?.findFirstMiddleware && config?.findFirstMiddleware.length) {
-    const middlewares = [...config.findFirstMiddleware, ${modelName}FindFirst]
-    if (config.findFirstNextMiddleware) {
-      middlewares.push(...config.findFirstNextMiddleware);
+  const basePath = config.addModelPrefix ? '/${modelName.toLowerCase()}' : '';
+
+  const setupRoute = (
+    path: string,
+    method: "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head",
+    middlewares: RequestHandler[],
+    handler: RequestHandler
+  ) => {
+    router[method](basePath + path, ...middlewares, handler);
+  };
+
+  if (config.enableAll || config?.findFirst) {
+    const { before = [], after = [] } = config.findFirst || defaultBeforeAfter;
+    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/first', ...after);
     }
-    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);
+  if (config.enableAll || config?.findMany) {
+    const { before = [], after = [] } = config.findMany || defaultBeforeAfter;
+    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/', ...after);
     }
-    router.get('/', ...middlewares as FindManyMiddleware[]);
   }
 
-  if (config?.findUniqueMiddleware && config?.findUniqueMiddleware.length) {
-    const middlewares = [...config.findUniqueMiddleware, ${modelName}FindUnique]
-    if (config.findUniqueNextMiddleware) {
-      middlewares.push(...config.findUniqueNextMiddleware);
+  if (config.enableAll || config?.findUnique) {
+    const { before = [], after = [] } = config.findUnique || defaultBeforeAfter;
+    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any);
+    if (after.length) {
+      router.use(basePath + '/:id', ...after);
     }
-    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);
+  if (config.enableAll || config?.create) {
+    const { before = [], after = [] } = config.create || defaultBeforeAfter;
+    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/', ...after);
     }
-    router.post('/', ...middlewares as CreateMiddleware[]);
   }
 
-  if (config?.createManyMiddleware && config?.createManyMiddleware.length) {
-    const middlewares = [...config.createManyMiddleware, ${modelName}CreateMany]
-    if (config.createManyNextMiddleware) {
-      middlewares.push(...config.createManyNextMiddleware);
+  if (config.enableAll || config?.createMany) {
+    const { before = [], after = [] } = config.createMany || defaultBeforeAfter;
+    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/many', ...after);
     }
-    router.post('/many', ...middlewares as CreateManyMiddleware[]);
   }
 
-  if (config?.updateMiddleware && config?.updateMiddleware.length) {
-    const middlewares = [...config.updateMiddleware, ${modelName}Update]
-    if (config.updateNextMiddleware) {
-      middlewares.push(...config.updateNextMiddleware);
+  if (config.enableAll || config?.update) {
+    const { before = [], after = [] } = config.update || defaultBeforeAfter;
+    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/', ...after);
     }
-    router.put('/', ...middlewares as UpdateMiddleware[]);
   }
 
-  if (config?.updateManyMiddleware && config?.updateManyMiddleware.length) {
-    const middlewares = [...config.updateManyMiddleware, ${modelName}UpdateMany]
-    if (config.updateManyNextMiddleware) {
-      middlewares.push(...config.updateManyNextMiddleware);
+  if (config.enableAll || config?.updateMany) {
+    const { before = [], after = [] } = config.updateMany || defaultBeforeAfter;
+    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/many', ...after);
     }
-    router.put('/many', ...middlewares as UpdateManyMiddleware[]);
   }
 
-  if (config?.upsertMiddleware && config?.upsertMiddleware.length) {
-    const middlewares = [...config.upsertMiddleware, ${modelName}Upsert]
-    if (config.upsertNextMiddleware) {
-      middlewares.push(...config.upsertNextMiddleware);
+  if (config.enableAll || config?.upsert) {
+    const { before = [], after = [] } = config.upsert || defaultBeforeAfter;
+    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/', ...after);
     }
-    router.patch('/', ...middlewares as UpsertMiddleware[]);
   }
 
-  if (config?.deleteMiddleware && config?.deleteMiddleware.length) {
-    const middlewares = [...config.deleteMiddleware, ${modelName}Delete]
-    if (config.deleteNextMiddleware) {
-      middlewares.push(...config.deleteNextMiddleware);
+  if (config.enableAll || config?.delete) {
+    const { before = [], after = [] } = config.delete || defaultBeforeAfter;
+    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/', ...after);
     }
-    router.delete('/', ...middlewares as DeleteMiddleware[]);
   }
 
-  if (config?.deleteManyMiddleware && config?.deleteManyMiddleware.length) {
-    const middlewares = [...config.deleteManyMiddleware, ${modelName}DeleteMany]
-    if (config.deleteManyNextMiddleware) {
-      middlewares.push(...config.deleteManyNextMiddleware);
+  if (config.enableAll || config?.deleteMany) {
+    const { before = [], after = [] } = config.deleteMany || defaultBeforeAfter;
+    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/many', ...after);
     }
-    router.delete('/many', ...middlewares as DeleteManyMiddleware[]);
   }
 
-  if (config?.aggregateMiddleware && config?.aggregateMiddleware.length) {
-    const middlewares = [...config.aggregateMiddleware, ${modelName}Aggregate]
-    if (config.aggregateNextMiddleware) {
-      middlewares.push(...config.aggregateNextMiddleware);
+  if (config.enableAll || config?.aggregate) {
+    const { before = [], after = [] } = config.aggregate || defaultBeforeAfter;
+    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/aggregate', ...after);
     }
-    router.get('/aggregate', ...middlewares as AggregateMiddleware[]);
   }
 
-  if (config?.countMiddleware && config?.countMiddleware.length) {
-    const middlewares = [...config.countMiddleware, ${modelName}Count]
-    if (config.countNextMiddleware) {
-      middlewares.push(...config.countNextMiddleware);
+  if (config.enableAll || config?.count) {
+    const { before = [], after = [] } = config.count || defaultBeforeAfter;
+    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/count', ...after);
     }
-    router.get('/count', ...middlewares as CountMiddleware[]);
   }
 
-  if (config?.groupByMiddleware && config?.groupByMiddleware.length) {
-    const middlewares = [...config.groupByMiddleware, ${modelName}GroupBy]
-    if (config.groupByNextMiddleware) {
-      middlewares.push(...config.groupByNextMiddleware);
+  if (config.enableAll || config?.groupBy) {
+    const { before = [], after = [] } = config.groupBy || defaultBeforeAfter;
+    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler);
+    if (after.length) {
+      router.use(basePath + '/groupby', ...after);
     }
-    router.get('/groupby', ...middlewares as GroupByMiddleware[]);
   }
 
   return router;

package/{dist → src}/helpers/generateUpdate.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateUpdateFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * 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.
+ */
 const generateUpdateFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -42,12 +48,15 @@ export async function ${functionName}(req: UpdateRequest, res: Response, next: N
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling update request:', error);
-    res.status(500).json({ error: error.message });
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`;
 };
 exports.generateUpdateFunction = generateUpdateFunction;
-//# sourceMappingURL=generateUpdate.js.map

package/src/helpers/generateUpdate.ts

@@ -50,9 +50,13 @@ export async function ${functionName}(req: UpdateRequest, res: Response, next: N
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling update request:', error);
-    res.status(500).json({ error: error.message });
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`

package/{dist → src}/helpers/generateUpdateMany.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateUpdateManyFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * 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.
+ */
 const generateUpdateManyFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -42,12 +48,15 @@ export async function ${functionName}(req: UpdateManyRequest, res: Response, nex
     } else {
       res.status(200).json({ count: data.count });
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling updateMany request:', error);
-    res.status(500).json({ error: error.message });
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`;
 };
 exports.generateUpdateManyFunction = generateUpdateManyFunction;
-//# sourceMappingURL=generateUpdateMany.js.map

package/src/helpers/generateUpdateMany.ts

@@ -50,9 +50,13 @@ export async function ${functionName}(req: UpdateManyRequest, res: Response, nex
     } else {
       res.status(200).json({ count: data.count });
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling updateMany request:', error);
-    res.status(500).json({ error: error.message });
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`

package/{dist → src}/helpers/generateUpsert.js

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateUpsertFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * 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.
+ */
 const generateUpsertFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -42,12 +49,15 @@ export async function ${functionName}(req: UpsertRequest, res: Response, next: N
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling upsert request:', error);
-    res.status(500).json({ error: error.message });
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`;
 };
 exports.generateUpsertFunction = generateUpsertFunction;
-//# sourceMappingURL=generateUpsert.js.map

package/src/helpers/generateUpsert.ts

@@ -51,9 +51,13 @@ export async function ${functionName}(req: UpsertRequest, res: Response, next: N
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling upsert request:', error);
-    res.status(500).json({ error: error.message });
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`

package/{dist → src}/utils/formatFile.js

@@ -8,13 +8,10 @@ const prettier_1 = __importDefault(require("prettier"));
 const formatFile = (content) => {
     return new Promise((res, rej) => prettier_1.default.resolveConfig(process.cwd()).then((options) => {
         if (!options) {
-            res(content);
+            res(content); // no prettier config was found, no need to format
         }
         try {
-            const formatted = prettier_1.default.format(content, {
-                ...options,
-                parser: 'typescript',
-            });
+            const formatted = prettier_1.default.format(content, Object.assign(Object.assign({}, options), { parser: 'typescript' }));
             res(formatted);
         }
         catch (error) {
@@ -23,4 +20,3 @@ const formatFile = (content) => {
     }));
 };
 exports.formatFile = formatFile;
-//# sourceMappingURL=formatFile.js.map

package/{dist → src}/utils/strings.js

@@ -9,4 +9,3 @@ function lowercaseFirstLetter(str) {
     return str.charAt(0).toLowerCase() + str.slice(1);
 }
 exports.lowercaseFirstLetter = lowercaseFirstLetter;
-//# sourceMappingURL=strings.js.map

package/src/utils/writeFileSafely.js

@@ -0,0 +1,29 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeFileSafely = void 0;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const formatFile_1 = require("./formatFile");
+const writeFileSafely = (_a) => __awaiter(void 0, [_a], void 0, function* ({ model, operation, options, content, }) {
+    var _b;
+    const fileName = operation === 'index' ? 'index' : `${(model === null || model === void 0 ? void 0 : model.name) || ''}${operation}`;
+    const filePath = path_1.default.join((_b = options.generator.output) === null || _b === void 0 ? void 0 : _b.value, model ? `${model === null || model === void 0 ? void 0 : model.name}/${fileName}.ts` : `/${fileName}.ts`);
+    console.log('filePath :>> ', filePath);
+    yield promises_1.default.mkdir(path_1.default.dirname(filePath), {
+        recursive: true,
+    });
+    yield promises_1.default.writeFile(filePath, yield (0, formatFile_1.formatFile)(content));
+});
+exports.writeFileSafely = writeFileSafely;

package/src/utils/writeFileSafely.ts

@@ -9,15 +9,16 @@ export const writeFileSafely = async ({
   options,
   content,
 }: {
-  model: DMMF.Model
+  model?: DMMF.Model
   operation: string
   options: GeneratorOptions
   content: string
 }) => {
-  const fileName = operation === 'index' ? 'index' : `${model.name}${operation}`
+  const fileName =
+    operation === 'index' ? 'index' : `${model?.name || ''}${operation}`
   const filePath = path.join(
     options.generator.output?.value!,
-    `${model.name}/${fileName}.ts`,
+    model ? `${model?.name}/${fileName}.ts` : `/${fileName}.ts`,
   )
   console.log('filePath :>> ', filePath)
   await fs.mkdir(path.dirname(filePath), {

package/dist/bin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":";;;AACA,uBAAoB"}

package/dist/constants.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAAa,QAAA,cAAc,GAAG,0BAA0B,CAAA"}