prisma-generator-express 1.7.1 → 1.8.0

package/README.md

@@ -111,38 +111,67 @@ The `UserFindUnique` function will fetch the user details from the database, val
 The library will create functions to generate routers per each model in schema. Each route can accept middleware that will be injected right before generated handler is invoked. You can use it to modify/remove/validate request payload. The output validation can be also attached to `req` object on this step.
 
 ```ts
-import express from 'express'
-import { UserRouter } from './path/to/generated/UserRouter' // Adjust the path as necessary
-import { UserFindManyArgs } from './prisma-zod-generator/schemas/UserFindManyArgs.schema' // Adjust the path as necessary
+import express, { json } from 'express'
+import type { Response, Request, NextFunction, RequestHandler } from 'express'
+
+import { orderItemRouter } from '../prisma/generated/express/orderItem'
+import RouteConfig from '../prisma/generated/express/RouteConfig'
+import { PrismaClient } from '../prisma/generated/client'
 
 const app = express()
 
-export const validateUserQuery = (
+const prisma = new PrismaClient()
+
+/**
+ * Middleware to attach Prisma client instance to the request object.
+ * This ensures that Prisma client is available in all subsequent middleware and route handlers.
+ */
+const addPrisma: RequestHandler = (
   req: Request,
   res: Response,
   next: NextFunction,
 ) => {
-  try {
-    UserFindManyArgs.parse(req.query)
-    next()
-  } catch (error) {
-    if (error instanceof ZodError) {
-      return res.status(400).json({
-        message: 'Validation failed',
-        errors: error.errors,
-      })
-    }
-    next(error)
-  }
+  req.prisma = prisma
+  req.omitOutputValidation = true
+  next()
+}
+
+/**
+ * Before middleware to set a custom property on the request object.
+ * Demonstrates how to add custom properties to the request object to be used in later middleware or route handlers.
+ */
+const beforeFindMany: RequestHandler = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  ;(req as any).passToNext = true
+  next()
+}
+
+/**
+ * After middleware placeholder for any post-processing after the main route handler.
+ * This example just calls next() but can be extended to perform actions like logging or response modification.
+ */
+const afterFindMany: RequestHandler = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  console.log('req.locals?.data :>> ', req.locals?.data)
+  next()
 }
 
-const userRouterConfig = {
-  findManyMiddleware: [validateUserQuery], // Add other middleware as needed
-  findUniqueMiddleware: undefined, // This can be omitted, route won't be generated if middleware is not provided
+const someRouterConfig: RouteConfig<RequestHandler> = {
+  findMany: {
+    before: [beforeFindMany],
+    after: [afterFindMany],
+  },
+  addModelPrefix: true,
+  enableAll: true,
 }
 
-// Use the router in your application
-app.use('/users', UserRouter(userRouterConfig))
+app.use(addPrisma, orderItemRouter(someRouterConfig))
 
 app.listen(3000, () => {
   console.log('Server is running on http://localhost:3000')

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prisma-generator-express",
   "description": "Prisma generator of Express CRUD API",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "main": "dist/generator.js",
   "license": "MIT",
   "bin": {
@@ -13,7 +13,7 @@
   "scripts": {
     "start": "node dist/bin.js",
     "dev": "npx tsc -w",
-    "build": "npx tsc",
+    "build": "npx tsc --project ../../tsconfig.json",
     "prepack": "yarn build",
     "test": "jest",
     "prepublishOnly": "node copy.js "

package/{dist → src}/bin.js

@@ -2,4 +2,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 require("./generator");
-//# sourceMappingURL=bin.js.map

package/{dist → src}/constants.js

@@ -2,4 +2,3 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GENERATOR_NAME = void 0;
 exports.GENERATOR_NAME = 'prisma-generator-express';
-//# sourceMappingURL=constants.js.map

package/src/generator.js

@@ -0,0 +1,195 @@
+"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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const generator_helper_1 = require("@prisma/generator-helper");
+const sdk_1 = require("@prisma/sdk");
+const constants_1 = require("./constants");
+const writeFileSafely_1 = require("./utils/writeFileSafely");
+const generateFindUnique_1 = require("./helpers/generateFindUnique");
+const generateImportPrismaStatement_1 = require("./helpers/generateImportPrismaStatement");
+const generateFindMany_1 = require("./helpers/generateFindMany");
+const generateFindFirst_1 = require("./helpers/generateFindFirst");
+const generateCreate_1 = require("./helpers/generateCreate");
+const generateRouteFile_1 = require("./helpers/generateRouteFile");
+const generateCreateMany_1 = require("./helpers/generateCreateMany");
+const generateUpdate_1 = require("./helpers/generateUpdate");
+const generateUpdateMany_1 = require("./helpers/generateUpdateMany");
+const generateUpsert_1 = require("./helpers/generateUpsert");
+const generateDelete_1 = require("./helpers/generateDelete");
+const generateDeleteMany_1 = require("./helpers/generateDeleteMany");
+const generateAggregate_1 = require("./helpers/generateAggregate");
+const generateCount_1 = require("./helpers/generateCount");
+const generateGroupBy_1 = require("./helpers/generateGroupBy");
+const generateRouteConfigType_1 = require("./helpers/generateRouteConfigType");
+const { version } = require('../package.json');
+(0, generator_helper_1.generatorHandler)({
+    onManifest() {
+        sdk_1.logger.info(`${constants_1.GENERATOR_NAME}:Registered`);
+        return {
+            version,
+            defaultOutput: '../generated',
+            prettyName: constants_1.GENERATOR_NAME,
+        };
+    },
+    onGenerate: (options) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, e_1, _b, _c;
+        const prismaImportStatement = (0, generateImportPrismaStatement_1.generateImportPrismaStatement)(options);
+        try {
+            for (var _d = true, _e = __asyncValues(options.dmmf.datamodel.models), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const model = _c;
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateFindUnique_1.generateFindUniqueFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'FindUnique',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateFindFirst_1.generateFindFirstFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'FindFirst',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateFindMany_1.generateFindManyFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'FindMany',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateCreate_1.generateCreateFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'Create',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateCreateMany_1.generateCreateManyFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'CreateMany',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateUpdate_1.generateUpdateFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'Update',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateUpdateMany_1.generateUpdateManyFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'UpdateMany',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateUpsert_1.generateUpsertFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'Upsert',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateDelete_1.generateDeleteFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'Delete',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateDeleteMany_1.generateDeleteManyFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'DeleteMany',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateAggregate_1.generateAggregateFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'Aggregate',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateCount_1.generateCountFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'Count',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateGroupBy_1.generateGroupByFunction)({
+                        model,
+                        prismaImportStatement,
+                    }),
+                    options,
+                    model,
+                    operation: 'GroupBy',
+                });
+                yield (0, writeFileSafely_1.writeFileSafely)({
+                    content: (0, generateRouteFile_1.generateRouterFunction)({ model }),
+                    options,
+                    model,
+                    operation: 'index',
+                });
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        yield (0, writeFileSafely_1.writeFileSafely)({
+            content: (0, generateRouteConfigType_1.generateRouteConfigType)(),
+            options,
+            operation: 'RouteConfig',
+        });
+    }),
+});

package/src/generator.ts

@@ -17,6 +17,7 @@ import { generateDeleteManyFunction } from './helpers/generateDeleteMany'
 import { generateAggregateFunction } from './helpers/generateAggregate'
 import { generateCountFunction } from './helpers/generateCount'
 import { generateGroupByFunction } from './helpers/generateGroupBy'
+import { generateRouteConfigType } from './helpers/generateRouteConfigType'
 
 const { version } = require('../package.json')
 
@@ -170,5 +171,11 @@ generatorHandler({
         operation: 'index',
       })
     }
+
+    await writeFileSafely({
+      content: generateRouteConfigType(),
+      options,
+      operation: 'RouteConfig',
+    })
   },
 })

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

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateAggregateFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that handles aggregation 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 generateAggregateFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -41,12 +48,15 @@ export async function ${functionName}(req: AggregateRequest, res: Response, next
     } else {
       res.status(200).json(result);
     }
-  } catch (error) {
-    console.error('Error in handling aggregation request:', error);
-    res.status(500).json({ error: error.message });
+  } catch (error: unknown) {
+    console.error("Error in handling aggregation request:", error);
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`;
 };
 exports.generateAggregateFunction = generateAggregateFunction;
-//# sourceMappingURL=generateAggregate.js.map

package/src/helpers/generateAggregate.ts

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

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

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCountFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that handles count 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 generateCountFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -41,12 +48,15 @@ export async function ${functionName}(req: CountRequest, res: Response, next: Ne
     } else {
       res.status(200).json(result);
     }
-  } catch (error) {
-    console.error('Error in handling count request:', error);
-    res.status(500).json({ error: error.message });
+  } catch (error: unknown) {
+    console.error("Error in handling count request:", error);
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`;
 };
 exports.generateCountFunction = generateCountFunction;
-//# sourceMappingURL=generateCount.js.map

package/src/helpers/generateCount.ts

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

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

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCreateFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that handles creation of records and includes conditional output validation with Zod.
+ * This version dynamically includes the correct type for the arguments based on the Prisma model.
+ * @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 generateCreateFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -41,12 +47,15 @@ export async function ${functionName}(req: CreateRequest, res: Response, next: N
     } else {
       res.status(201).json(data);
     }
-  } catch (error) {
-    console.error('Error in handling create request:', error);
-    res.status(500).json({ error: error.message });
+  } catch (error: unknown) {
+    console.error("Error in handling create request:", error);
+    if (error instanceof Error) {
+      res.status(500).json({ error: error.message });
+    } else {
+      res.status(500).json({ error: "Unknown error occurred" });
+    }
     next(error);
   }
 }`;
 };
 exports.generateCreateFunction = generateCreateFunction;
-//# sourceMappingURL=generateCreate.js.map

package/src/helpers/generateCreate.ts

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

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

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCreateManyFunction = void 0;
 const strings_1 = require("../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.
+ * @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 generateCreateManyFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -41,12 +47,15 @@ export async function ${functionName}(req: CreateManyRequest, res: Response, nex
     } else {
       res.status(201).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling createMany 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.generateCreateManyFunction = generateCreateManyFunction;
-//# sourceMappingURL=generateCreateMany.js.map

package/src/helpers/generateCreateMany.ts

@@ -49,9 +49,13 @@ export async function ${functionName}(req: CreateManyRequest, res: Response, nex
     } else {
       res.status(201).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling createMany 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/generateDelete.js

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDeleteFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that handles deleting 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 generateDeleteFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -42,12 +49,15 @@ export async function ${functionName}(req: DeleteRequest, res: Response, next: N
     } else {
       res.status(200).json(data);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling delete 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.generateDeleteFunction = generateDeleteFunction;
-//# sourceMappingURL=generateDelete.js.map

package/src/helpers/generateDelete.ts

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

@@ -2,6 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateDeleteManyFunction = void 0;
 const strings_1 = require("../utils/strings");
+/**
+ * Generates an Express middleware function that handles batch deleting 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 generateDeleteManyFunction = (options) => {
     const { model, prismaImportStatement } = options;
     const modelName = model.name;
@@ -40,12 +47,15 @@ export async function ${functionName}(req: DeleteManyRequest, res: Response, nex
     } else {
       res.status(200).json(result);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling batch delete 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.generateDeleteManyFunction = generateDeleteManyFunction;
-//# sourceMappingURL=generateDeleteMany.js.map

package/src/helpers/generateDeleteMany.ts

@@ -49,9 +49,13 @@ export async function ${functionName}(req: DeleteManyRequest, res: Response, nex
     } else {
       res.status(200).json(result);
     }
-  } catch (error) {
+  } catch (error: unknown) {
     console.error('Error in handling batch delete 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);
   }
 }`