prisma-generator-express 1.7.1 → 1.8.0

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

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFindFirstFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the query parameter based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
 const generateFindFirstFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -51,12 +57,15 @@ export async function ${functionName}(req: FindFirstRequest, res: Response, next
     } else {
       res.status(200).json(data); 
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling 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.generateFindFirstFunction = generateFindFirstFunction;
-//# sourceMappingURL=generateFindFirst.js.map

package/src/helpers/generateFindFirst.ts

@@ -59,9 +59,13 @@ export async function ${functionName}(req: FindFirstRequest, res: Response, next
     } else {
       res.status(200).json(data); 
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling 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/generateFindMany.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFindManyFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that handles multiple record retrieval with optional output validation using Zod.
+ * This version dynamically includes the correct type for the query parameter based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
 const generateFindManyFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -51,12 +57,15 @@ export async function ${functionName}(req: FindManyRequest, res: Response, next:
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling 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.generateFindManyFunction = generateFindManyFunction;
-//# sourceMappingURL=generateFindMany.js.map

package/src/helpers/generateFindMany.ts

@@ -59,9 +59,13 @@ export async function ${functionName}(req: FindManyRequest, res: Response, next:
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling 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/generateFindUnique.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateFindUniqueFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the query parameter based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
 const generateFindUniqueFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -51,12 +57,15 @@ export async function ${functionName}(req: FindUniqueRequest, res: Response, nex
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
-    console.error('Error in handling request:', error);
-    res.status(500).json({ error: error.message });
+  } 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);
   }
 }`;
 };
 exports.generateFindUniqueFunction = generateFindUniqueFunction;
-//# sourceMappingURL=generateFindUnique.js.map

package/src/helpers/generateFindUnique.ts

@@ -59,9 +59,13 @@ export async function ${functionName}(req: FindUniqueRequest, res: Response, nex
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
-    console.error('Error in handling request:', error);
-    res.status(500).json({ error: error.message });
+  } 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);
   }
 }`

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

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateGroupByFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that handles groupBy queries
+ * and includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the arguments based on the Prisma model.
+ * @param options - The options containing the model name and the import statement for Prisma types.
+ * @returns {string} - The generated middleware function as a string.
+ */
 const generateGroupByFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -42,12 +49,15 @@ export async function ${functionName}(req: GroupByRequest, res: Response, next:
     } else {
       res.status(200).json(result);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling groupBy 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.generateGroupByFunction = generateGroupByFunction;
-//# sourceMappingURL=generateGroupBy.js.map

package/src/helpers/generateGroupBy.ts

@@ -53,9 +53,13 @@ export async function ${functionName}(req: GroupByRequest, res: Response, next:
     } else {
       res.status(200).json(result);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling groupBy 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/generateImportPrismaStatement.js

@@ -20,7 +20,7 @@ function getImportGeneratorOptions(options) {
 }
 function generateImportPrismaStatement(generatorOptions) {
     const options = getImportGeneratorOptions(generatorOptions);
+    // console.log('options.outputPath :>> ', options.outputPath)
     return `import type { Prisma } from '${options.outputPath}';\nimport type { PrismaClient } from '${options.outputPath}';\n`;
 }
 exports.generateImportPrismaStatement = generateImportPrismaStatement;
-//# sourceMappingURL=generateImportPrismaStatement.js.map

package/src/helpers/generateRouteConfigType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouteConfigType = void 0;
+function generateRouteConfigType() {
+    return `import { RequestHandler } from 'express';
+
+  interface MiddlewareConfig<M> {
+    before?: M[];
+    after?: RequestHandler[];
+  }
+  
+  export interface RouteConfig<M> {
+    findFirst?: MiddlewareConfig<M>;
+    findMany?: MiddlewareConfig<M>;
+    findUnique?: MiddlewareConfig<M>;
+    create?: MiddlewareConfig<M>;
+    createMany?: MiddlewareConfig<M>;
+    update?: MiddlewareConfig<M>;
+    updateMany?: MiddlewareConfig<M>;
+    upsert?: MiddlewareConfig<M>;
+    delete?: MiddlewareConfig<M>;
+    deleteMany?: MiddlewareConfig<M>;
+    aggregate?: MiddlewareConfig<M>;
+    count?: MiddlewareConfig<M>;
+    groupBy?: MiddlewareConfig<M>;
+    addModelPrefix?: boolean;
+    enableAll?: boolean;
+  }
+  
+  export default RouteConfig;`;
+}
+exports.generateRouteConfigType = generateRouteConfigType;

package/src/helpers/generateRouteConfigType.ts

@@ -0,0 +1,28 @@
+export function generateRouteConfigType() {
+  return `import { RequestHandler } from 'express';
+
+  interface MiddlewareConfig<M> {
+    before?: M[];
+    after?: RequestHandler[];
+  }
+  
+  export interface RouteConfig<M> {
+    findFirst?: MiddlewareConfig<M>;
+    findMany?: MiddlewareConfig<M>;
+    findUnique?: MiddlewareConfig<M>;
+    create?: MiddlewareConfig<M>;
+    createMany?: MiddlewareConfig<M>;
+    update?: MiddlewareConfig<M>;
+    updateMany?: MiddlewareConfig<M>;
+    upsert?: MiddlewareConfig<M>;
+    delete?: MiddlewareConfig<M>;
+    deleteMany?: MiddlewareConfig<M>;
+    aggregate?: MiddlewareConfig<M>;
+    count?: MiddlewareConfig<M>;
+    groupBy?: MiddlewareConfig<M>;
+    addModelPrefix?: boolean;
+    enableAll?: boolean;
+  }
+  
+  export default RouteConfig;`
+}

package/src/helpers/generateRouteFile.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouterFunction = void 0;
+function generateRouterFunction({ model, }) {
+    const modelName = model.name;
+    const routerFunctionName = `${modelName}Router`;
+    return `
+import express, { RequestHandler } from 'express';
+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<RequestHandler>) {
+  const router = express.Router();
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  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);
+    }
+  }
+
+  return router;
+}
+`;
+}
+exports.generateRouterFunction = generateRouterFunction;