prisma-generator-express 1.12.0 → 1.14.0

package/src/helpers/generateGroupBy.ts

@@ -30,37 +30,36 @@ interface GroupByRequest extends Request {
   query: Partial<${argsTypeName}> & ParsedQs;
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type GroupByMiddleware = RequestHandler<ParamsDictionary, any, {}, ParsedQs>;
 
 export async function ${functionName}(req: GroupByRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     // @ts-ignore
     const result = await req.prisma.${lowercaseFirstLetter(modelName)}.groupBy(req.query);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(result);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(result);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
       }
     } else {
-      res.status(200).json(result);
+      return res.status(200).json(result);
     }
   } catch (error: unknown) {
-    console.error('Error in handling groupBy request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateRouteFile.ts

@@ -8,8 +8,12 @@ export function generateRouterFunction({
   const modelName = model.name
   const routerFunctionName = `${modelName}Router`
 
-  return `
-import express, { RequestHandler } from 'express';
+  return `import express, {
+  NextFunction,
+  RequestHandler,
+  Request,
+  Response,
+} from 'express'
 import { ParsedQs } from 'qs'
 import { ${modelName}FindFirst } from './${modelName}FindFirst';
 import { ${modelName}FindMany } from './${modelName}FindMany';
@@ -24,13 +28,16 @@ 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";
-import qs from "qs";
+import { createValidatorMiddleware, ValidatorOptions } from '../createValidatorMiddleware'
+import { createOutputValidatorMiddleware } from '../createOutputValidatorMiddleware'
+import { RouteConfig, ValidatorConfig } from '../routeConfig'
 import { parseQueryParams } from "../ParseQueryParams";
 
 const defaultBeforeAfter = {
   before: [] as RequestHandler[],
   after: [] as RequestHandler[],
+  input: undefined,
+  output: undefined,
 };
 
 /**
@@ -47,113 +54,139 @@ export function ${routerFunctionName}(config: RouteConfig<RequestHandler>) {
     path: string,
     method: "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head",
     middlewares: RequestHandler[],
-    handler: RequestHandler
+    handler: RequestHandler,
+    inputValidator?: ValidatorConfig,
+    outputValidator?: ValidatorConfig
   ) => {
-    router[method](basePath + path, (req, res, next) => {
-      if (req.query)
-        req.query = parseQueryParams(qs.parse(req.query as Record<string, string>)) as ParsedQs;      next();
-    }, ...middlewares, handler);
+    const middlewaresWithValidators: RequestHandler[] = [
+      (req, res, next) => {
+        if (req.query) {
+          req.query = parseQueryParams(req.query as Record<string, string>) as ParsedQs;
+        }
+        next();
+      },
+      ...middlewares
+    ];
+  
+    if (inputValidator) {
+      middlewaresWithValidators.push(createValidatorMiddleware({
+        schema: inputValidator.schema,
+        allowedPaths: inputValidator.allow,
+        forbiddenPaths: inputValidator.forbid,
+        target: method === 'get' ? 'query' : 'body',
+      }));
+    }
+  
+    middlewaresWithValidators.push((req, res, next) => {
+      res.locals.outputValidator = outputValidator;
+      next();
+    });
+  
+    middlewaresWithValidators.push(handler);
+  
+    router[method](basePath + path, ...middlewaresWithValidators);
   };
 
+
   if (config.enableAll || config?.findFirst) {
-    const { before = [], after = [] } = config.findFirst || defaultBeforeAfter;
-    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler);
+    const { before = [], after = [], input, output } = config.findFirst || defaultBeforeAfter;
+    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.findMany || defaultBeforeAfter;
+    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.findUnique || defaultBeforeAfter;
+    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any, input, output);
     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);
+    const { before = [], after = [], input, output } = config.create || defaultBeforeAfter;
+    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.createMany || defaultBeforeAfter;
+    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.update || defaultBeforeAfter;
+    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.updateMany || defaultBeforeAfter;
+    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.upsert || defaultBeforeAfter;
+    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.delete || defaultBeforeAfter;
+    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.deleteMany || defaultBeforeAfter;
+    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.aggregate || defaultBeforeAfter;
+    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.count || defaultBeforeAfter;
+    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler, input, output);
     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);
+    const { before = [], after = [], input, output } = config.groupBy || defaultBeforeAfter;
+    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler, input, output);
     if (after.length) {
       router.use(basePath + '/groupby', ...after);
     }

package/src/helpers/generateUpdate.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * Generates an Express middleware function that handles updating records and includes conditional output validation with Zod.
  * This version dynamically includes the correct type for the arguments based on the Prisma model.
@@ -26,38 +27,35 @@ interface UpdateRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 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) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const data = await req.prisma.${lowercaseFirstLetter(modelName)}.update(req.body);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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);
+      return res.status(200).json(data);
     }
   } catch (error: unknown) {
-    console.error('Error in handling update request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateUpdateMany.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * Generates an Express middleware function that handles updating multiple records and includes conditional output validation with Zod.
  * This version dynamically includes the correct type for the arguments based on the Prisma model.
@@ -26,38 +27,35 @@ interface UpdateManyRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 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) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const data = await req.prisma.${lowercaseFirstLetter(modelName)}.updateMany(req.body);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json({ count: validationResult.data.count });
+        return res.status(200).json({ count: validationResult.data.count });
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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 });
+      return res.status(200).json({ count: data.count });
     }
   } catch (error: unknown) {
-    console.error('Error in handling updateMany request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/helpers/generateUpsert.ts

@@ -1,5 +1,6 @@
 import { DMMF } from '@prisma/generator-helper'
 import { lowercaseFirstLetter } from '../utils/strings'
+
 /**
  * Generates an Express middleware function that handles the upsert operation (create or update)
  * and includes conditional output validation with Zod.
@@ -27,38 +28,35 @@ interface UpsertRequest extends Request {
   body: ${argsTypeName};
   outputValidation?: ZodTypeAny;
   omitOutputValidation?: boolean;
+  locals?: {
+    outputValidator?: ZodTypeAny;
+  };
 }
 
 export type UpsertMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
 
 export async function ${functionName}(req: UpsertRequest, res: Response, next: NextFunction) {
   try {
-    if (!req.outputValidation && !req.omitOutputValidation) {
+    const outputValidator = req.locals?.outputValidator || req.outputValidation;
+
+    if (!outputValidator && !req.omitOutputValidation) {
       throw new Error('Output validation schema or omission flag must be provided.');
     }
 
     const data = await req.prisma.${lowercaseFirstLetter(modelName)}.upsert(req.body);
 
-    if (!req.omitOutputValidation && req.outputValidation) {
-      const validationResult = req.outputValidation.safeParse(data);
+    if (!req.omitOutputValidation && outputValidator) {
+      const validationResult = outputValidator.safeParse(data);
       if (validationResult.success) {
-        res.status(200).json(validationResult.data);
+        return res.status(200).json(validationResult.data);
       } else {
-        res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
+        return 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);
+      return res.status(200).json(data);
     }
   } catch (error: unknown) {
-    console.error('Error in handling upsert request:', error);
-    if (error instanceof Error) {
-      res.status(500).json({ error: error.message });
-    } else {
-      res.status(500).json({ error: "Unknown error occurred" });
-    }
-    next(error);
+    return next(error);
   }
 }`
 }

package/src/utils/copyFiles.ts

@@ -0,0 +1,27 @@
+import { GeneratorOptions } from '@prisma/generator-helper'
+import fs from 'fs/promises'
+import path from 'path'
+
+export const copyFiles = async (
+  options: GeneratorOptions,
+  destPath?: string,
+) => {
+  const sourceDir = path.join(__dirname.replace('dist', 'src'), '..', 'copy')
+  const destinationDir = destPath || options.generator.output?.value!
+
+  const files = await fs.readdir(sourceDir)
+
+  for (const file of files) {
+    if (file.endsWith('.spec.ts')) {
+      continue
+    }
+
+    const sourceFile = path.join(sourceDir, file)
+    const destinationFile = path.join(destinationDir, file)
+
+    await fs.mkdir(path.dirname(destinationFile), { recursive: true })
+    await fs.copyFile(sourceFile, destinationFile)
+  }
+
+  console.log(`Files copied from ${sourceDir} to ${destinationDir}`)
+}

package/dist/helpers/generateQsParser.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateParseQueryParams = void 0;
-function generateParseQueryParams() {
-    return `/**
-  * Type guard to check if a value is an object.
-  * @param {unknown} value - The value to check.
-  * @returns {boolean} True if the value is an object, false otherwise.
-  */
- const isObject = (value: unknown): value is Record<string, unknown> => {
-   return typeof value === "object" && value !== null;
- };
- 
- /**
-  * Parses a query value to convert strings to their respective types.
-  * @param {string} value - The query value to parse.
-  * @returns {any} The parsed value.
-  */
- const parseQueryValue = (value: string): unknown => {
-   if (value === "true") return true;
-   if (value === "false") return false;
-   if (value === "null") return null;
-   if (!isNaN(Number(value))) return Number(value);
-   return value;
- };
- 
- /**
-  * Recursively parses query parameters to convert strings to their respective types.
-  * @param {unknown} params - The query parameters to parse.
-  * @returns {unknown} The parsed query parameters.
-  */
- export const parseQueryParams = (params: unknown): unknown => {
-   if (typeof params === "string") {
-     return parseQueryValue(params);
-   }
-   if (Array.isArray(params)) {
-     return params.map(parseQueryParams);
-   }
-   if (isObject(params)) {
-     const parsedParams: Record<string, unknown> = {};
-     for (const key in params) {
-       if (key === "AND" || key === "OR" || key === "NOT") {
-         parsedParams[key] = Array.isArray(params[key])
-           ? (params[key] as unknown[]).map(parseQueryParams)
-           : parseQueryParams(params[key]);
-       } else {
-         parsedParams[key] = parseQueryParams(params[key]);
-       }
-     }
-     return parsedParams;
-   }
-   return params;
- };`;
-}
-exports.generateParseQueryParams = generateParseQueryParams;
-//# sourceMappingURL=generateQsParser.js.map

package/dist/helpers/generateQsParser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateQsParser.js","sourceRoot":"","sources":["../../src/helpers/generateQsParser.ts"],"names":[],"mappings":";;;AAAA,SAAgB,wBAAwB;IACtC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgDL,CAAA;AACJ,CAAC;AAlDD,4DAkDC"}

package/dist/helpers/generateRouteConfigType.js

@@ -1,34 +0,0 @@
-"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;
-    customUrlPrefix?: string;
-  }
-  
-  export default RouteConfig;`;
-}
-exports.generateRouteConfigType = generateRouteConfigType;
-//# sourceMappingURL=generateRouteConfigType.js.map

package/dist/helpers/generateRouteConfigType.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateRouteConfigType.js","sourceRoot":"","sources":["../../src/helpers/generateRouteConfigType.ts"],"names":[],"mappings":";;;AAAA,SAAgB,uBAAuB;IACrC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;8BA0BqB,CAAA;AAC9B,CAAC;AA5BD,0DA4BC"}

package/src/helpers/generateQsParser.ts

@@ -1,51 +0,0 @@
-export function generateParseQueryParams() {
-  return `/**
-  * Type guard to check if a value is an object.
-  * @param {unknown} value - The value to check.
-  * @returns {boolean} True if the value is an object, false otherwise.
-  */
- const isObject = (value: unknown): value is Record<string, unknown> => {
-   return typeof value === "object" && value !== null;
- };
- 
- /**
-  * Parses a query value to convert strings to their respective types.
-  * @param {string} value - The query value to parse.
-  * @returns {any} The parsed value.
-  */
- const parseQueryValue = (value: string): unknown => {
-   if (value === "true") return true;
-   if (value === "false") return false;
-   if (value === "null") return null;
-   if (!isNaN(Number(value))) return Number(value);
-   return value;
- };
- 
- /**
-  * Recursively parses query parameters to convert strings to their respective types.
-  * @param {unknown} params - The query parameters to parse.
-  * @returns {unknown} The parsed query parameters.
-  */
- export const parseQueryParams = (params: unknown): unknown => {
-   if (typeof params === "string") {
-     return parseQueryValue(params);
-   }
-   if (Array.isArray(params)) {
-     return params.map(parseQueryParams);
-   }
-   if (isObject(params)) {
-     const parsedParams: Record<string, unknown> = {};
-     for (const key in params) {
-       if (key === "AND" || key === "OR" || key === "NOT") {
-         parsedParams[key] = Array.isArray(params[key])
-           ? (params[key] as unknown[]).map(parseQueryParams)
-           : parseQueryParams(params[key]);
-       } else {
-         parsedParams[key] = parseQueryParams(params[key]);
-       }
-     }
-     return parsedParams;
-   }
-   return params;
- };`
-}

package/src/helpers/generateRouteConfigType.ts

@@ -1,29 +0,0 @@
-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;
-    customUrlPrefix?: string;
-  }
-  
-  export default RouteConfig;`
-}