prisma-generator-express 1.16.7 → 1.18.0

package/src/helpers/generateAggregate.ts

@@ -1,59 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { capitalize, toPascalCase } from '../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.
- */
-export const generateAggregateFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  const { model, prismaImportStatement } = options
-  const modelName = model.name
-  const functionName = `${modelName}Aggregate`
-  const argsTypeName = `Prisma.${capitalize(modelName)}AggregateArgs`
-
-  return `
-${prismaImportStatement}
-import { Request, Response, NextFunction } from 'express';
-import { RequestHandler, ParamsDictionary } from 'express-serve-static-core'
-import { ParsedQs } from 'qs'
-import { ZodTypeAny } from 'zod';
-import { ValidatorConfig } from '../routeConfig'
-
-interface AggregateRequest extends Request {
-  prisma: PrismaClient;
-  query: Partial<${argsTypeName}> & ParsedQs;
-  outputValidation?: ZodTypeAny;
-  locals?: {
-    outputValidator?: ValidatorConfig;
-  };
-}
-
-export type AggregateMiddleware = RequestHandler<ParamsDictionary, any, Partial<${argsTypeName}>, Record<string, any>>;
-
-export async function ${functionName}(req: AggregateRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = res.locals.outputValidator?.schema || req.outputValidation;
-
-    const result = await req.prisma.${toPascalCase(modelName)}.aggregate(req.query as ${argsTypeName});
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(result);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(result);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateCount.ts

@@ -1,58 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../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.
- */
-export const generateCountFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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 { ParsedQs } from 'qs';
-import { ZodTypeAny } from 'zod';
-
-interface CountRequest extends Request {
-  prisma: PrismaClient;
-  query: Partial<${argsTypeName}> & ParsedQs;
-  outputValidation?: ZodTypeAny;
-  locals?: {
-    outputValidator?: ZodTypeAny;
-  };
-}
-
-export type CountMiddleware = RequestHandler<ParamsDictionary, any, {}, ParsedQs>;
-
-export async function ${functionName}(req: CountRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const result = await req.prisma.${toPascalCase(modelName)}.count(req.query as ${argsTypeName});
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(result);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(result);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateCreate.ts

@@ -1,56 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../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.
- */
-export const generateCreateFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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;
-  locals?: {
-    outputValidator?: ZodTypeAny;
-  };
-}
-
-export type CreateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
-
-export async function ${functionName}(req: CreateRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const data = await req.prisma.${toPascalCase(modelName)}.create(req.body);
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(data);
-      if (validationResult.success) {
-        return res.status(201).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(201).json(data);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateCreateMany.ts

@@ -1,55 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../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.
- */
-export const generateCreateManyFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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;
-  locals?: {
-    outputValidator?: ZodTypeAny;
-  };
-}
-
-export type CreateManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
-
-export async function ${functionName}(req: CreateManyRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const data = await req.prisma.${toPascalCase(modelName)}.createMany(req.body);
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(data);
-      if (validationResult.success) {
-        return res.status(201).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(201).json(data);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateDelete.ts

@@ -1,57 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../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.
- */
-export const generateDeleteFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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;
-  locals?: {
-    outputValidator?: ZodTypeAny;
-  };
-}
-
-export type DeleteMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
-
-export async function ${functionName}(req: DeleteRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const data = await req.prisma.${toPascalCase(modelName)}.delete(req.body);
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(data);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(data);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateDeleteMany.ts

@@ -1,57 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../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.
- */
-export const generateDeleteManyFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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;
-  locals?: {
-    outputValidator?: ZodTypeAny;
-  };
-}
-
-export type DeleteManyMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>;
-
-export async function ${functionName}(req: DeleteManyRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const result = await req.prisma.${toPascalCase(modelName)}.deleteMany(req.body);
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(result);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(result);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateFindFirst.ts

@@ -1,62 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../utils/strings'
-/**
- * Generates an Express middleware function that includes conditional output validation with Zod.
- * This version dynamically includes the correct type for the query parameter based on the Prisma model.
- * @param options - The options containing the model name and the import statement for Prisma types.
- * @returns {string} - The generated middleware function as a string.
- */
-export const generateFindFirstFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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;
-  passToNext?: boolean;
-  locals?: {
-    data?: ${modelName} | null
-    outputValidator?: ZodTypeAny;
-  }
-}
-export type FindFirstMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
-
-export async function ${functionName}(req: FindFirstRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const data = await req.prisma.${toPascalCase(modelName)}.findFirst(req.query as ${queryTypeName});
-    if (req.passToNext) {
-      if (req.locals) req.locals.data = data;
-      next();
-    } else if (outputValidator) {
-      const validationResult = outputValidator.safeParse(data);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(data); 
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateFindMany.ts

@@ -1,62 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../utils/strings'
-/**
- * Generates an Express middleware function that handles multiple record retrieval with optional output validation using Zod.
- * This version dynamically includes the correct type for the query parameter based on the Prisma model.
- * @param options - The options containing the model name and the import statement for Prisma types.
- * @returns {string} - The generated middleware function as a string.
- */
-export const generateFindManyFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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;
-  passToNext?: boolean;
-  locals?: {
-    data?: ${modelName}[]
-    outputValidator?: ZodTypeAny;
-  }
-}
-export type FindManyMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
-
-export async function ${functionName}(req: FindManyRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const data = await req.prisma.${toPascalCase(modelName)}.findMany(req.query as ${queryTypeName});
-    if (req.passToNext) {
-      if (req.locals) req.locals.data = data;
-      next();
-    } else if (outputValidator) {
-      const validationResult = outputValidator.safeParse(data);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(data);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateFindUnique.ts

@@ -1,62 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../utils/strings'
-/**
- * Generates an Express middleware function that includes conditional output validation with Zod.
- * This version dynamically includes the correct type for the query parameter based on the Prisma model.
- * @param options - The options containing the model name and the import statement for Prisma types.
- * @returns {string} - The generated middleware function as a string.
- */
-export const generateFindUniqueFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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;
-  passToNext?: boolean;
-  locals?: {
-    data?: ${modelName} | null
-    outputValidator?: ZodTypeAny;
-  }
-}
-export type FindUniqueMiddleware = RequestHandler<ParamsDictionary, any, any, ${queryTypeName} & ParsedQs, Record<string, any>>
-
-export async function ${functionName}(req: FindUniqueRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const data = await req.prisma.${toPascalCase(modelName)}.findUnique(req.query as ${queryTypeName});
-    if (req.passToNext) {
-      if (req.locals) req.locals.data = data;
-      next();
-    } else if (outputValidator) {
-      const validationResult = outputValidator.safeParse(data);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(data);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateGroupBy.ts

@@ -1,60 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../utils/strings'
-import { PrismaClient, Prisma } from '@prisma/client'
-
-/**
- * Generates an Express middleware function that handles groupBy queries
- * and includes conditional output validation with Zod.
- * This version dynamically includes the correct type for the arguments based on the Prisma model.
- * @param options - The options containing the model name and the import statement for Prisma types.
- * @returns {string} - The generated middleware function as a string.
- */
-export const generateGroupByFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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 { ParsedQs } from 'qs';
-import { ZodTypeAny } from 'zod';
-
-interface GroupByRequest extends Request {
-  prisma: PrismaClient;
-  query: Partial<${argsTypeName}> & ParsedQs;
-  outputValidation?: ZodTypeAny;
-  locals?: {
-    outputValidator?: ZodTypeAny;
-  };
-}
-
-export type GroupByMiddleware = RequestHandler<ParamsDictionary, any, {}, ParsedQs>;
-
-export async function ${functionName}(req: GroupByRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    // @ts-ignore
-    const result = await req.prisma.${toPascalCase(modelName)}.groupBy(req.query);
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(result);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(result);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}

package/src/helpers/generateUpdate.ts

@@ -1,56 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } 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.
- * @param options - The options containing the model name and the import statement for Prisma types.
- * @returns {string} - The generated middleware function as a string.
- */
-export const generateUpdateFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  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;
-  locals?: {
-    outputValidator?: ZodTypeAny;
-  };
-}
-
-export type UpdateMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
-
-export async function ${functionName}(req: UpdateRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const data = await req.prisma.${toPascalCase(modelName)}.update(req.body);
-
-    if (outputValidator) {
-      const validationResult = outputValidator.safeParse(data);
-      if (validationResult.success) {
-        return res.status(200).json(validationResult.data);
-      } else {
-        return res.status(400).json({ error: 'Invalid data format', details: validationResult.error });
-      }
-    } else {
-      return res.status(200).json(data);
-    }
-  } catch(error: unknown) {
-    next(error)
-  }
-}`
-}