prisma-generator-express 1.0.2 → 1.0.4

package/dist/helpers/generateFindFirst.js

@@ -1,61 +0,0 @@
-"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

@@ -1 +0,0 @@
-{"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"}

package/dist/helpers/generateFindMany.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFindManyFunction = void 0;
-const generateFindManyFunction = (options) => {
-    const { model, prismaImportStatement } = options;
-    const modelName = model.name;
-    const functionName = `${modelName}FindMany`;
-    const queryTypeName = `Prisma.${modelName}FindManyArgs`;
-    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 FindManyRequest extends Request {
-  prisma: PrismaClient;
-  query: ${queryTypeName} & ParsedQs;
-  outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
-  passToNext?: boolean;
-  locals: {
-    data?: ${modelName}[]
-  }
-}
-export type FindManyMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
-
-export async function ${functionName}(req: FindManyRequest, 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()}.findMany(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.generateFindManyFunction = generateFindManyFunction;
-//# sourceMappingURL=generateFindMany.js.map

package/dist/helpers/generateFindMany.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateFindMany.js","sourceRoot":"","sources":["../../src/helpers/generateFindMany.ts"],"names":[],"mappings":";;;AAQO,MAAM,wBAAwB,GAAG,CAAC,OAGxC,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,UAAU,CAAA;IAC3C,MAAM,aAAa,GAAG,UAAU,SAAS,cAAc,CAAA;IAEvD,OAAO;EACP,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE,aAAa,SAAS,IAAI,CAAC;;;;;;;;;;;WAW9D,aAAa;;;;;aAKX,SAAS;;;8EAGwD,aAAa;;wBAEnE,YAAY;;;;;;oCAMA,SAAS,CAAC,WAAW,EAAE,0BAA0B,aAAa;;;;;;;;;;;;;;;;;;;;;EAqBhG,CAAA;AACF,CAAC,CAAA;AA3DY,QAAA,wBAAwB,4BA2DpC"}

package/dist/helpers/generateFindUnique copy.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFindUniqueFunction = void 0;
-const generateFindUniqueFunction = (options) => {
-    const { model, prismaImportStatement } = options;
-    const modelName = model.name;
-    const functionName = `${modelName}FindUnique`;
-    const queryTypeName = `Prisma.${modelName}FindUniqueArgs`;
-    return `
-${prismaImportStatement}
-import { Request, Response, NextFunction } from 'express';
-import { ParsedQs } from 'qs';
-import { ZodTypeAny } from 'zod';
-
-interface PrismaRequest extends Request {
-  prisma: PrismaClient;
-  query: ${queryTypeName} & ParsedQs;
-  outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
-}
-
-export async function ${functionName}(req: PrismaRequest, 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()}.findUnique(req.query as ${queryTypeName});
-    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.generateFindUniqueFunction = generateFindUniqueFunction;
-//# sourceMappingURL=generateFindUnique%20copy.js.map

package/dist/helpers/generateFindUnique copy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateFindUnique copy.js","sourceRoot":"","sources":["../../src/helpers/generateFindUnique copy.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,aAAa,GAAG,UAAU,SAAS,gBAAgB,CAAA;IAEzD,OAAO;EACP,qBAAqB;;;;;;;WAOZ,aAAa;;;;;wBAKA,YAAY;;;;;;oCAMA,SAAS,CAAC,WAAW,EAAE,4BAA4B,aAAa;;;;;;;;;;;;;;;;;;EAkBlG,CAAA;AACF,CAAC,CAAA;AA/CY,QAAA,0BAA0B,8BA+CtC"}

package/dist/helpers/generateFindUnique.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateFindUniqueFunction = void 0;
-const generateFindUniqueFunction = (options) => {
-    const { model, prismaImportStatement } = options;
-    const modelName = model.name;
-    const functionName = `${modelName}FindUnique`;
-    const queryTypeName = `Prisma.${modelName}FindUniqueArgs`;
-    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 FindUniqueRequest extends Request {
-  prisma: PrismaClient;
-  query: ${queryTypeName} & ParsedQs;
-  outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
-  passToNext?: boolean;
-  locals: {
-    data?: ${modelName} | null
-  }
-}
-export type FindUniqueMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
-
-export async function ${functionName}(req: FindUniqueRequest, 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()}.findUnique(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.generateFindUniqueFunction = generateFindUniqueFunction;
-//# sourceMappingURL=generateFindUnique.js.map

package/dist/helpers/generateFindUnique.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateFindUnique.js","sourceRoot":"","sources":["../../src/helpers/generateFindUnique.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,aAAa,GAAG,UAAU,SAAS,gBAAgB,CAAA;IAEzD,OAAO;EACP,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE,aAAa,SAAS,IAAI,CAAC;;;;;;;;;;;WAW9D,aAAa;;;;;aAKX,SAAS;;;gFAG0D,aAAa;;wBAErE,YAAY;;;;;;oCAMA,SAAS,CAAC,WAAW,EAAE,4BAA4B,aAAa;;;;;;;;;;;;;;;;;;;;;EAqBlG,CAAA;AACF,CAAC,CAAA;AA3DY,QAAA,0BAA0B,8BA2DtC"}

package/dist/helpers/generateGroupBy.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateGroupByFunction = void 0;
-const generateGroupByFunction = (options) => {
-    const { model, prismaImportStatement } = options;
-    const modelName = model.name;
-    const functionName = `${modelName}GroupBy`;
-    const argsTypeName = `Prisma.${modelName}GroupByArgs`;
-    return `
-${prismaImportStatement}
-import { Request, Response, NextFunction } from 'express';
-import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
-import { ZodTypeAny } from 'zod';
-
-interface GroupByRequest extends Request {
-  prisma: PrismaClient;
-  body: ${argsTypeName};
-  outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
-}
-
-export type GroupByMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
-
-export async function ${functionName}(req: GroupByRequest, 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()}.groupBy(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 groupBy request:', error);
-    res.status(500).json({ error: error.message });
-    next(error);
-  }
-}`;
-};
-exports.generateGroupByFunction = generateGroupByFunction;
-//# sourceMappingURL=generateGroupBy.js.map

package/dist/helpers/generateGroupBy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateGroupBy.js","sourceRoot":"","sources":["../../src/helpers/generateGroupBy.ts"],"names":[],"mappings":";;;AASO,MAAM,uBAAuB,GAAG,CAAC,OAGvC,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,SAAS,CAAA;IAC1C,MAAM,YAAY,GAAG,UAAU,SAAS,aAAa,CAAA;IAErD,OAAO;EACP,qBAAqB;;;;;;;UAOb,YAAY;;;;;wEAKkD,YAAY;;wBAE5D,YAAY;;;;;;sCAME,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;EAiB3D,CAAA;AACF,CAAC,CAAA;AAhDY,QAAA,uBAAuB,2BAgDnC"}

package/dist/helpers/generateImportPrismaStatement.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportPrismaStatement = void 0;
-const path_1 = __importDefault(require("path"));
-function getImportGeneratorOptions(options) {
-    var _a, _b;
-    const clientGenerator = options.otherGenerators.find((gen) => gen.name === 'client');
-    if (!clientGenerator || !((_a = clientGenerator.output) === null || _a === void 0 ? void 0 : _a.value)) {
-        throw new Error('Prisma client generator not found.');
-    }
-    const modelDirPath = path_1.default.join((_b = options.generator.output) === null || _b === void 0 ? void 0 : _b.value, 'modelFolder');
-    const clientOutputPath = clientGenerator.output.value;
-    const relativeImportPath = path_1.default.relative(modelDirPath, clientOutputPath);
-    return {
-        outputPath: relativeImportPath.split(path_1.default.sep).join(path_1.default.posix.sep),
-    };
-}
-function generateImportPrismaStatement(generatorOptions) {
-    const options = getImportGeneratorOptions(generatorOptions);
-    return `import type { Prisma } from '${options.outputPath}';\nimport type { PrismaClient } from '${options.outputPath}';\n`;
-}
-exports.generateImportPrismaStatement = generateImportPrismaStatement;
-//# sourceMappingURL=generateImportPrismaStatement.js.map

package/dist/helpers/generateImportPrismaStatement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateImportPrismaStatement.js","sourceRoot":"","sources":["../../src/helpers/generateImportPrismaStatement.ts"],"names":[],"mappings":";;;;;;AACA,gDAAuB;AAMvB,SAAS,yBAAyB,CAChC,OAAyB;;IAEzB,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,CAClD,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,QAAQ,CAC/B,CAAA;IAED,IAAI,CAAC,eAAe,IAAI,CAAC,CAAA,MAAA,eAAe,CAAC,MAAM,0CAAE,KAAK,CAAA,EAAE,CAAC;QACvD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;IACvD,CAAC;IAED,MAAM,YAAY,GAAG,cAAI,CAAC,IAAI,CAC5B,MAAA,OAAO,CAAC,SAAS,CAAC,MAAM,0CAAE,KAAM,EAChC,aAAa,CACd,CAAA;IACD,MAAM,gBAAgB,GAAG,eAAe,CAAC,MAAM,CAAC,KAAK,CAAA;IAErD,MAAM,kBAAkB,GAAG,cAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAA;IAExE,OAAO;QACL,UAAU,EAAE,kBAAkB,CAAC,KAAK,CAAC,cAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,cAAI,CAAC,KAAK,CAAC,GAAG,CAAC;KACpE,CAAA;AACH,CAAC;AAED,SAAgB,6BAA6B,CAC3C,gBAAkC;IAElC,MAAM,OAAO,GAAG,yBAAyB,CAAC,gBAAgB,CAAC,CAAA;IAE3D,OAAO,gCAAgC,OAAO,CAAC,UAAU,0CAA0C,OAAO,CAAC,UAAU,MAAM,CAAA;AAC7H,CAAC;AAND,sEAMC"}

package/dist/helpers/generatePrismaImport.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=generatePrismaImport.js.map

package/dist/helpers/generatePrismaImport.js.map

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

package/dist/helpers/generateRouteFile.js

@@ -1,181 +0,0 @@
-"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, 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[]
-}
-
-/**
- * Generates an Express router for ${modelName} model.
- * @param config Contains optional middleware to enable routes.
- * @returns {express.Router}
- */
-export function ${routerFunctionName}(config: RouteConfig) {
-  const router = express.Router();
-  
-  if (config?.findFirstMiddleware && config?.findFirstMiddleware.length) {
-    const middlewares = [...config.findFirstMiddleware, ${modelName}FindFirst]
-    if (config.findFirstNextMiddleware) {
-      middlewares.push(...config.findFirstNextMiddleware);
-    }
-    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);
-    }
-    router.get('/', ...middlewares as FindManyMiddleware[]);
-  }
-
-  if (config?.findUniqueMiddleware && config?.findUniqueMiddleware.length) {
-    const middlewares = [...config.findUniqueMiddleware, ${modelName}FindUnique]
-    if (config.findUniqueNextMiddleware) {
-      middlewares.push(...config.findUniqueNextMiddleware);
-    }
-    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);
-    }
-    router.post('/', ...middlewares);
-  }
-
-  if (config?.createManyMiddleware && config?.createManyMiddleware.length) {
-    const middlewares = [...config.createManyMiddleware, ${modelName}CreateMany]
-    if (config.createManyNextMiddleware) {
-      middlewares.push(...config.createManyNextMiddleware);
-    }
-    router.post('/many', ...middlewares);
-  }
-
-  if (config?.updateMiddleware && config?.updateMiddleware.length) {
-    const middlewares = [...config.updateMiddleware, ${modelName}Update]
-    if (config.updateNextMiddleware) {
-      middlewares.push(...config.updateNextMiddleware);
-    }
-    router.put('/', ...middlewares);
-  }
-
-  if (config?.updateManyMiddleware && config?.updateManyMiddleware.length) {
-    const middlewares = [...config.updateManyMiddleware, ${modelName}UpdateMany]
-    if (config.updateManyNextMiddleware) {
-      middlewares.push(...config.updateManyNextMiddleware);
-    }
-    router.put('/many', ...middlewares);
-  }
-
-  if (config?.upsertMiddleware && config?.upsertMiddleware.length) {
-    const middlewares = [...config.upsertMiddleware, ${modelName}Upsert]
-    if (config.upsertNextMiddleware) {
-      middlewares.push(...config.upsertNextMiddleware);
-    }
-    router.patch('/', ...middlewares);
-  }
-
-  if (config?.deleteMiddleware && config?.deleteMiddleware.length) {
-    const middlewares = [...config.deleteMiddleware, ${modelName}Delete]
-    if (config.deleteNextMiddleware) {
-      middlewares.push(...config.deleteNextMiddleware);
-    }
-    router.delete('/', ...middlewares);
-  }
-
-  if (config?.deleteManyMiddleware && config?.deleteManyMiddleware.length) {
-    const middlewares = [...config.deleteManyMiddleware, ${modelName}DeleteMany]
-    if (config.deleteManyNextMiddleware) {
-      middlewares.push(...config.deleteManyNextMiddleware);
-    }
-    router.delete('/many', ...middlewares);
-  }
-
-  if (config?.aggregateMiddleware && config?.aggregateMiddleware.length) {
-    const middlewares = [...config.aggregateMiddleware, ${modelName}Aggregate]
-    if (config.aggregateNextMiddleware) {
-      middlewares.push(...config.aggregateNextMiddleware);
-    }
-    router.get('/aggregate', ...middlewares);
-  }
-
-  if (config?.countMiddleware && config?.countMiddleware.length) {
-    const middlewares = [...config.countMiddleware, ${modelName}Count]
-    if (config.countNextMiddleware) {
-      middlewares.push(...config.countNextMiddleware);
-    }
-    router.get('/count', ...middlewares);
-  }
-
-  if (config?.groupByMiddleware && config?.groupByMiddleware.length) {
-    const middlewares = [...config.groupByMiddleware, ${modelName}GroupBy]
-    if (config.groupByNextMiddleware) {
-      middlewares.push(...config.groupByNextMiddleware);
-    }
-    router.get('/groupby', ...middlewares);
-  }
-
-  return router;
-}
-`;
-}
-exports.generateRouterFunction = generateRouterFunction;
-//# sourceMappingURL=generateRouteFile.js.map

package/dist/helpers/generateRouteFile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateRouteFile.js","sourceRoot":"","sources":["../../src/helpers/generateRouteFile.ts"],"names":[],"mappings":";;;AAEA,SAAgB,sBAAsB,CAAC,EACrC,KAAK,GAGN;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,kBAAkB,GAAG,GAAG,SAAS,QAAQ,CAAA;IAE/C,OAAO;;WAEE,SAAS,iDAAiD,SAAS;WACnE,SAAS,+CAA+C,SAAS;WACjE,SAAS,mDAAmD,SAAS;WACrE,SAAS,2CAA2C,SAAS;WAC7D,SAAS,mDAAmD,SAAS;WACrE,SAAS,2CAA2C,SAAS;WAC7D,SAAS,mDAAmD,SAAS;WACrE,SAAS,2CAA2C,SAAS;WAC7D,SAAS,2CAA2C,SAAS;WAC7D,SAAS,mDAAmD,SAAS;WACrE,SAAS,iDAAiD,SAAS;WACnE,SAAS,yCAAyC,SAAS;WAC3D,SAAS,6CAA6C,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qCA4CrC,SAAS;;;;kBAI5B,kBAAkB;;;;0DAIsB,SAAS;;;;;;;;yDAQV,SAAS;;;;;;;;2DAQP,SAAS;;;;;;;;uDAQb,SAAS;;;;;;;;2DAQL,SAAS;;;;;;;;uDAQb,SAAS;;;;;;;;2DAQL,SAAS;;;;;;;;uDAQb,SAAS;;;;;;;;uDAQT,SAAS;;;;;;;;2DAQL,SAAS;;;;;;;;0DAQV,SAAS;;;;;;;;sDAQb,SAAS;;;;;;;;wDAQP,SAAS;;;;;;;;;CAShE,CAAA;AACD,CAAC;AApLD,wDAoLC"}

package/dist/helpers/generateUpdate.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUpdateFunction = void 0;
-const generateUpdateFunction = (options) => {
-    const { model, prismaImportStatement } = options;
-    const modelName = model.name;
-    const functionName = `${modelName}Update`;
-    const argsTypeName = `Prisma.${modelName}UpdateArgs`;
-    return `
-${prismaImportStatement}
-import { Request, Response, NextFunction } from 'express';
-import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
-import { ZodTypeAny } from 'zod';
-
-interface UpdateRequest extends Request {
-  prisma: PrismaClient;
-  body: ${argsTypeName};
-  outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
-}
-
-export type UpdateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
-
-export async function ${functionName}(req: UpdateRequest, 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()}.update({
-      where: { id: parseInt(req.params.id) },
-      data: 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 update request:', error);
-    res.status(500).json({ error: error.message });
-    next(error);
-  }
-}`;
-};
-exports.generateUpdateFunction = generateUpdateFunction;
-//# sourceMappingURL=generateUpdate.js.map

package/dist/helpers/generateUpdate.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateUpdate.js","sourceRoot":"","sources":["../../src/helpers/generateUpdate.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;;;;;;;;;;;;;;;;;;;;;;EAsBzD,CAAA;AACF,CAAC,CAAA;AArDY,QAAA,sBAAsB,0BAqDlC"}

package/dist/helpers/generateUpdateMany.js

@@ -1,52 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateUpdateManyFunction = void 0;
-const generateUpdateManyFunction = (options) => {
-    const { model, prismaImportStatement } = options;
-    const modelName = model.name;
-    const functionName = `${modelName}UpdateMany`;
-    const argsTypeName = `Prisma.${modelName}UpdateManyArgs`;
-    return `
-${prismaImportStatement}
-import { Request, Response, NextFunction } from 'express';
-import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
-import { ZodTypeAny } from 'zod';
-
-interface UpdateManyRequest extends Request {
-  prisma: PrismaClient;
-  body: ${argsTypeName};
-  outputValidation?: ZodTypeAny;
-  omitOutputValidation?: boolean;
-}
-
-export type UpdateManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
-
-export async function ${functionName}(req: UpdateManyRequest, 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()}.updateMany(req.body);
-
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
-      if (validationResult.success) {
-        res.status(200).json({ count: validationResult.data.count });
-      } 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({ count: data.count });
-    }
-  } catch (error) {
-    console.error('Error in handling updateMany request:', error);
-    res.status(500).json({ error: error.message });
-    next(error);
-  }
-}`;
-};
-exports.generateUpdateManyFunction = generateUpdateManyFunction;
-//# sourceMappingURL=generateUpdateMany.js.map

package/dist/helpers/generateUpdateMany.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateUpdateMany.js","sourceRoot":"","sources":["../../src/helpers/generateUpdateMany.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;;;;;;;;;;;;;;;;;;;EAmBzD,CAAA;AACF,CAAC,CAAA;AAlDY,QAAA,0BAA0B,8BAkDtC"}