prisma-generator-express 1.0.3 → 1.0.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 multipliedtwice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,180 @@
+# Prisma Generator Express
+
+[![npm version](https://badge.fury.io/js/prisma-generator-express.svg)](https://badge.fury.io/js/prisma-generator-express)
+[![npm](https://img.shields.io/npm/dt/prisma-generator-express.svg)](https://www.npmjs.com/package/prisma-generator-express)
+[![HitCount](https://hits.dwyl.com/multipliedtwice/prisma-generator-express.svg?style=flat)](http://hits.dwyl.com/multipliedtwice/prisma-generator-express)
+[![npm](https://img.shields.io/npm/l/prisma-generator-express.svg)](LICENSE)
+
+This tool helps you quickly create API endpoints in your Express app using your Prisma models.
+
+When you run `npx prisma generate`, it automatically creates two things:
+
+- Service functions that you can import into your Express routes. By default these functions handle CRUD operations and output validation. This behavior can be controlled.
+- Router generator function that lets you select which routes to add to the application and which middlewares to apply.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Basic Usage](#basic-usage)
+- [Router Generator Usage](#router-generator-usage)
+- [Request Object Properties](#request-object-properties)
+- [Roadmap](#roadmap)
+
+# Installation
+
+Using npm:
+
+```bash
+ npm install prisma-generator-express
+```
+
+Using yarn:
+
+```bash
+ yarn add prisma-generator-express
+```
+
+# Basic usage
+
+- Include this generator in your schema.prisma file:
+
+```prisma
+generator express {
+  provider = "prisma-generator-express"
+}
+```
+
+- Generate your middleware functions by running:
+
+```bash
+  npx prisma generate
+```
+
+- Attach Prisma instance
+
+```ts
+import { PrismaClient } from '@prisma/client'
+import express from 'express'
+
+const prisma = new PrismaClient()
+const app = express()
+
+app.use(express.json()) // for parsing application/json
+
+// Attach Prisma to every request
+app.use((req, res, next) => {
+  req.prisma = prisma
+  next()
+})
+```
+
+- Here’s how you can use a generated function in your Express app:
+
+```ts
+import { UserFindUnique } from './generated/UserFindUnique' // Adjust the path as necessary
+import { FindUniqueUserSchema } from './prisma-zod-generator/schemas/FindUniqueUser.schema' // Adjust the path as necessary
+import { FindUniqueUserSchemaOutput } from './prisma-zod-generator/schemas/FindUniqueUserOutput.schema' // Adjust the path as necessary
+
+// move this to /helpers
+export function validateQuery(schema: ZodSchema) {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      req.query = schema.parse(req.query)
+      next()
+    } catch (error) {
+      res.status(400).json({
+        error: 'Input Validation failed',
+        details: error.errors,
+      })
+    }
+  }
+}
+
+app.get(
+  '/user/:id',
+  validateQuery(FindUniqueUserSchema),
+  async (req, res, next) => {
+    // Attach generated Zod schema for output validation
+    req.outputValidation = FindUniqueUserOutput
+
+    // Use the generated middleware to handle the request
+    await UserFindUnique(req, res, next)
+  },
+)
+```
+
+The `UserFindUnique` function will fetch the user details from the database, validate the output with Zod, and handle the API response.
+
+# Router generator usage
+
+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
+
+const app = express()
+
+export const validateUserQuery = (
+  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)
+  }
+}
+
+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
+}
+
+// Use the router in your application
+app.use('/users', UserRouter(userRouterConfig))
+
+app.listen(3000, () => {
+  console.log('Server is running on http://localhost:3000')
+})
+```
+
+## Request Object Properties
+
+The following properties can be attached to the `req` object to control the behavior of generated middleware:
+
+| Property               | Type         | Description                                                                                                                                                                        |
+| ---------------------- | ------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `prisma`               | PrismaClient | An instance of PrismaClient that allows the middleware to interact with your database.                                                                                             |
+| `passToNext`           | boolean      | Optional, if `true` - the result of a Prisma request will be passed to a next middleware as `req.locals.data`                                                                      |
+| `query`                | Object       | A structured object that conforms to Prisma's API for the selected method.                                                                                                         |
+| `outputValidation`     | ZodTypeAny   | (Optional) A Zod schema used to validate the data returned from the Prisma query before sending it to the client. This helps ensure the response adheres to expected data formats. |
+| `omitOutputValidation` | Boolean      | (Optional) A flag that, if set to `true`, disables output validation even if a Zod schema is provided.                                                                             |
+
+## Roadmap
+
+| Function       | Supported          | Notes      |
+| -------------- | ------------------ | ---------- |
+| `Model router` | :white_check_mark: | Available. |
+| `findUnique`   | :white_check_mark: | Available. |
+| `findFirst`    | :white_check_mark: | Available. |
+| `findMany`     | :white_check_mark: | Available. |
+| `create`       | :white_check_mark: | Available. |
+| `createMany`   | :white_check_mark: | Available. |
+| `update`       | :white_check_mark: | Available. |
+| `updateMany`   | :white_check_mark: | Available. |
+| `upsert`       | :white_check_mark: | Available. |
+| `delete`       | :white_check_mark: | Available. |
+| `deleteMany`   | :white_check_mark: | Available. |
+| `aggregate`    | :white_check_mark: | Available. |
+| `count`        | :white_check_mark: | Available. |
+| `groupBy`      | :white_check_mark: | Available. |

package/dist/bin.js.map

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

package/dist/constants.js

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

package/dist/constants.js.map

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

package/dist/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":"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"}

package/dist/helpers/genEnum.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.genEnum = void 0;
+const genEnum = ({ name, values }) => {
+    const enumValues = values.map(({ name }) => `${name}="${name}"`).join(',\n');
+    return `enum ${name} { \n${enumValues}\n }`;
+};
+exports.genEnum = genEnum;
+//# sourceMappingURL=genEnum.js.map

package/dist/helpers/genEnum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"genEnum.js","sourceRoot":"","sources":["../../src/helpers/genEnum.ts"],"names":[],"mappings":";;;AAEO,MAAM,OAAO,GAAG,CAAC,EAAE,IAAI,EAAE,MAAM,EAAsB,EAAE,EAAE;IAC9D,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,GAAG,IAAI,KAAK,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IAE5E,OAAO,QAAQ,IAAI,QAAQ,UAAU,MAAM,CAAA;AAC7C,CAAC,CAAA;AAJY,QAAA,OAAO,WAInB"}

package/dist/helpers/generateAggregate.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAggregateFunction = void 0;
+const generateAggregateFunction = (options) => {
+    const { model, prismaImportStatement } = options;
+    const modelName = model.name;
+    const functionName = `${modelName}Aggregate`;
+    const argsTypeName = `Prisma.${modelName}AggregateArgs`;
+    return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
+import { ZodTypeAny } from 'zod';
+
+interface AggregateRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type AggregateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
+
+export async function ${functionName}(req: AggregateRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const result = await req.prisma.${modelName.toLowerCase()}.aggregate(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(result);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else {
+      res.status(200).json(result);
+    }
+  } catch (error) {
+    console.error('Error in handling aggregation request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`;
+};
+exports.generateAggregateFunction = generateAggregateFunction;
+//# sourceMappingURL=generateAggregate.js.map

package/dist/helpers/generateAggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateAggregate.js","sourceRoot":"","sources":["../../src/helpers/generateAggregate.ts"],"names":[],"mappings":";;;AASO,MAAM,yBAAyB,GAAG,CAAC,OAGzC,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,WAAW,CAAA;IAC5C,MAAM,YAAY,GAAG,UAAU,SAAS,eAAe,CAAA;IAEvD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;0EAKoD,YAAY;;wBAE9D,YAAY;;;;;;sCAME,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;EAiB3D,CAAA;AACF,CAAC,CAAA;AAhDY,QAAA,yBAAyB,6BAgDrC"}

package/dist/helpers/generateCount.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCountFunction = void 0;
+const generateCountFunction = (options) => {
+    const { model, prismaImportStatement } = options;
+    const modelName = model.name;
+    const functionName = `${modelName}Count`;
+    const argsTypeName = `Prisma.${modelName}CountArgs`;
+    return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
+import { ZodTypeAny } from 'zod';
+
+interface CountRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type CountMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
+
+export async function ${functionName}(req: CountRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const result = await req.prisma.${modelName.toLowerCase()}.count(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(result);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else {
+      res.status(200).json(result);
+    }
+  } catch (error) {
+    console.error('Error in handling count request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`;
+};
+exports.generateCountFunction = generateCountFunction;
+//# sourceMappingURL=generateCount.js.map

package/dist/helpers/generateCount.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateCount.js","sourceRoot":"","sources":["../../src/helpers/generateCount.ts"],"names":[],"mappings":";;;AASO,MAAM,qBAAqB,GAAG,CAAC,OAGrC,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,OAAO,CAAA;IACxC,MAAM,YAAY,GAAG,UAAU,SAAS,WAAW,CAAA;IAEnD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;sEAKgD,YAAY;;wBAE1D,YAAY;;;;;;sCAME,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;EAiB3D,CAAA;AACF,CAAC,CAAA;AAhDY,QAAA,qBAAqB,yBAgDjC"}

package/dist/helpers/generateCreate.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCreateFunction = void 0;
+const generateCreateFunction = (options) => {
+    const { model, prismaImportStatement } = options;
+    const modelName = model.name;
+    const functionName = `${modelName}Create`;
+    const argsTypeName = `Prisma.${modelName}CreateArgs`;
+    return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
+import { ZodTypeAny } from 'zod';
+
+interface CreateRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type CreateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: CreateRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const data = await req.prisma.${modelName.toLowerCase()}.create(req.body);
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(data);
+      if (validationResult.success) {
+        res.status(201).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else if (!req.omitOutputValidation) {
+      throw new Error('Output validation schema must be provided unless explicitly omitted.');
+    } else {
+      res.status(201).json(data);
+    }
+  } catch (error) {
+    console.error('Error in handling create request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`;
+};
+exports.generateCreateFunction = generateCreateFunction;
+//# sourceMappingURL=generateCreate.js.map

package/dist/helpers/generateCreate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateCreate.js","sourceRoot":"","sources":["../../src/helpers/generateCreate.ts"],"names":[],"mappings":";;;AAQO,MAAM,sBAAsB,GAAG,CAAC,OAGtC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,QAAQ,CAAA;IACzC,MAAM,YAAY,GAAG,UAAU,SAAS,YAAY,CAAA;IAEpD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;uEAKiD,YAAY;;wBAE3D,YAAY;;;;;;oCAMA,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;;EAkBzD,CAAA;AACF,CAAC,CAAA;AAjDY,QAAA,sBAAsB,0BAiDlC"}

package/dist/helpers/generateCreateMany.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCreateManyFunction = void 0;
+const generateCreateManyFunction = (options) => {
+    const { model, prismaImportStatement } = options;
+    const modelName = model.name;
+    const functionName = `${modelName}CreateMany`;
+    const argsTypeName = `Prisma.${modelName}CreateManyArgs`;
+    return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface CreateManyRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type CreateManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: CreateManyRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const data = await req.prisma.${modelName.toLowerCase()}.createMany(req.body);
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(data);
+      if (validationResult.success) {
+        res.status(201).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else if (!req.omitOutputValidation) {
+      throw new Error('Output validation schema must be provided unless explicitly omitted.');
+    } else {
+      res.status(201).json(data);
+    }
+  } catch (error) {
+    console.error('Error in handling createMany request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`;
+};
+exports.generateCreateManyFunction = generateCreateManyFunction;
+//# sourceMappingURL=generateCreateMany.js.map

package/dist/helpers/generateCreateMany.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateCreateMany.js","sourceRoot":"","sources":["../../src/helpers/generateCreateMany.ts"],"names":[],"mappings":";;;AAQO,MAAM,0BAA0B,GAAG,CAAC,OAG1C,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,YAAY,CAAA;IAC7C,MAAM,YAAY,GAAG,UAAU,SAAS,gBAAgB,CAAA;IAExD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;2EAKqD,YAAY;;wBAE/D,YAAY;;;;;;oCAMA,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;;EAkBzD,CAAA;AACF,CAAC,CAAA;AAjDY,QAAA,0BAA0B,8BAiDtC"}

package/dist/helpers/generateDelete.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDeleteFunction = void 0;
+const generateDeleteFunction = (options) => {
+    const { model, prismaImportStatement } = options;
+    const modelName = model.name;
+    const functionName = `${modelName}Delete`;
+    const argsTypeName = `Prisma.${modelName}DeleteArgs`;
+    return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface DeleteRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type DeleteMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
+
+export async function ${functionName}(req: DeleteRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const data = await req.prisma.${modelName.toLowerCase()}.delete(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(data);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else if (!req.omitOutputValidation) {
+      throw new Error('Output validation schema must be provided unless explicitly omitted.');
+    } else {
+      res.status(200).json(data);
+    }
+  } catch (error) {
+    console.error('Error in handling delete request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`;
+};
+exports.generateDeleteFunction = generateDeleteFunction;
+//# sourceMappingURL=generateDelete.js.map

package/dist/helpers/generateDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateDelete.js","sourceRoot":"","sources":["../../src/helpers/generateDelete.ts"],"names":[],"mappings":";;;AASO,MAAM,sBAAsB,GAAG,CAAC,OAGtC,EAAU,EAAE;IACX,MAAM,EAAE,KAAK,EAAE,qBAAqB,EAAE,GAAG,OAAO,CAAA;IAChD,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,YAAY,GAAG,GAAG,SAAS,QAAQ,CAAA;IACzC,MAAM,YAAY,GAAG,UAAU,SAAS,YAAY,CAAA;IAEpD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;uEAKiD,YAAY;;wBAE3D,YAAY;;;;;;oCAMA,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;;;EAmBzD,CAAA;AACF,CAAC,CAAA;AAlDY,QAAA,sBAAsB,0BAkDlC"}

package/dist/helpers/generateDeleteMany.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDeleteManyFunction = void 0;
+const generateDeleteManyFunction = (options) => {
+    const { model, prismaImportStatement } = options;
+    const modelName = model.name;
+    const functionName = `${modelName}DeleteMany`;
+    const argsTypeName = `Prisma.${modelName}DeleteManyArgs`;
+    return `
+${prismaImportStatement}
+import { Request, Response, NextFunction } from 'express';
+import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
+import { ZodTypeAny } from 'zod';
+
+interface DeleteManyRequest extends Request {
+  prisma: PrismaClient;
+  body: ${argsTypeName};
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+}
+
+export type DeleteManyMiddleware = RequestHandler<ParamsDictionary, any, Prisma.${modelName}DeleteManyArgs, Record<string, any>>;
+
+export async function ${functionName}(req: DeleteManyRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const result = await req.prisma.${modelName.toLowerCase()}.deleteMany(req.body);
+
+    if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(result);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else {
+      res.status(200).json(result);
+    }
+  } catch (error) {
+    console.error('Error in handling batch delete request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`;
+};
+exports.generateDeleteManyFunction = generateDeleteManyFunction;
+//# sourceMappingURL=generateDeleteMany.js.map

package/dist/helpers/generateDeleteMany.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateDeleteMany.js","sourceRoot":"","sources":["../../src/helpers/generateDeleteMany.ts"],"names":[],"mappings":";;;AASO,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;;;;;kFAK4D,SAAS;;wBAEnE,YAAY;;;;;;sCAME,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;EAiB3D,CAAA;AACF,CAAC,CAAA;AAhDY,QAAA,0BAA0B,8BAgDtC"}

package/dist/helpers/generateFindFirst.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFindFirstFunction = void 0;
+const generateFindFirstFunction = (options) => {
+    const { model, prismaImportStatement } = options;
+    const modelName = model.name;
+    const functionName = `${modelName}FindFirst`;
+    const queryTypeName = `Prisma.${modelName}FindFirstArgs`;
+    return `
+${prismaImportStatement.replace('{ Prisma }', `{ Prisma, ${modelName} }`)}
+import { Request, Response, NextFunction } from 'express'
+import {
+  RequestHandler,
+  ParamsDictionary,
+} from 'express-serve-static-core' 
+import { ParsedQs } from 'qs';
+import { ZodTypeAny } from 'zod';
+
+export interface FindFirstRequest extends Request {
+  prisma: PrismaClient;
+  query: ${queryTypeName} & ParsedQs;
+  outputValidation?: ZodTypeAny;
+  omitOutputValidation?: boolean;
+  passToNext?: boolean;
+  locals: {
+    data?: ${modelName} | null
+  }
+}
+export type FindFirstMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
+
+export async function ${functionName}(req: FindFirstRequest, res: Response, next: NextFunction) {
+  try {
+    if (!req.outputValidation && !req.omitOutputValidation) {
+      throw new Error('Output validation schema or omission flag must be provided.');
+    }
+
+    const data = await req.prisma.${modelName.toLowerCase()}.findFirst(req.query as ${queryTypeName});
+    if (req.passToNext) {
+      req.locals.data = data;
+      next();
+    } else if (!req.omitOutputValidation && req.outputValidation) {
+      const validationResult = req.outputValidation.safeParse(data);
+      if (validationResult.success) {
+        res.status(200).json(validationResult.data);
+      } else {
+        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+      }
+    } else if (!req.omitOutputValidation) {
+      throw new Error('Output validation schema must be provided unless explicitly omitted. Attach omitOutputValidation = true to request to suppress this error.');
+    } else {
+      res.status(200).json(data); 
+    }
+  } catch (error) {
+    console.error('Error in handling request:', error);
+    res.status(500).json({ error: error.message });
+    next(error);
+  }
+}`;
+};
+exports.generateFindFirstFunction = generateFindFirstFunction;
+//# sourceMappingURL=generateFindFirst.js.map

package/dist/helpers/generateFindFirst.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateFindFirst.js","sourceRoot":"","sources":["../../src/helpers/generateFindFirst.ts"],"names":[],"mappings":";;;AAQO,MAAM,yBAAyB,GAAG,CAAC,OAGzC,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,WAAW,CAAA;IAC5C,MAAM,aAAa,GAAG,UAAU,SAAS,eAAe,CAAA;IAExD,OAAO;EACP,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE,aAAa,SAAS,IAAI,CAAC;;;;;;;;;;;WAW9D,aAAa;;;;;aAKX,SAAS;;;+EAGyD,aAAa;;wBAEpE,YAAY;;;;;;oCAMA,SAAS,CAAC,WAAW,EAAE,2BAA2B,aAAa;;;;;;;;;;;;;;;;;;;;;EAqBjG,CAAA;AACF,CAAC,CAAA;AA3DY,QAAA,yBAAyB,6BA2DrC"}