prisma-generator-express 1.16.7 → 1.19.0

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/generateImportPrismaStatement.ts

@@ -1,38 +0,0 @@
-import { GeneratorOptions } from '@prisma/generator-helper'
-import path from 'path'
-
-interface ImportPrismaStatementOptions {
-  outputPath: string
-}
-
-function getImportGeneratorOptions(
-  options: GeneratorOptions,
-): ImportPrismaStatementOptions {
-  const clientGenerator = options.otherGenerators.find(
-    (gen) => gen.name === 'client',
-  )
-
-  if (!clientGenerator || !clientGenerator.output?.value) {
-    throw new Error('Prisma client generator not found.')
-  }
-
-  const modelDirPath = path.join(
-    options.generator.output?.value!,
-    'modelFolder', // workaround for saving with /modelName/operation structure
-  )
-  const clientOutputPath = clientGenerator.output.value
-
-  const relativeImportPath = path.relative(modelDirPath, clientOutputPath)
-
-  return {
-    outputPath: relativeImportPath.split(path.sep).join(path.posix.sep),
-  }
-}
-
-export function generateImportPrismaStatement(
-  generatorOptions: GeneratorOptions,
-): string {
-  const options = getImportGeneratorOptions(generatorOptions)
-  // console.log('options.outputPath :>> ', options.outputPath)
-  return `import type { Prisma } from '${options.outputPath}';\nimport type { PrismaClient } from '${options.outputPath}';\n`
-}

package/src/helpers/generateRouteFile.ts

@@ -1,195 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-
-export function generateRouterFunction({
-  model,
-}: {
-  model: DMMF.Model
-}): string {
-  const modelName = model.name
-  const routerFunctionName = `${modelName}Router`
-
-  return `import express, {
-  RequestHandler
-} from 'express'
-import { ParsedQs } from 'qs'
-import { ${modelName}FindFirst } from './${modelName}FindFirst';
-import { ${modelName}FindMany } from './${modelName}FindMany';
-import { ${modelName}FindUnique } from './${modelName}FindUnique';
-import { ${modelName}Create } from './${modelName}Create';
-import { ${modelName}CreateMany } from './${modelName}CreateMany';
-import { ${modelName}Update } from './${modelName}Update';
-import { ${modelName}UpdateMany } from './${modelName}UpdateMany';
-import { ${modelName}Upsert } from './${modelName}Upsert';
-import { ${modelName}Delete } from './${modelName}Delete';
-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 { createValidatorMiddleware, removeTrailingSlash } from '../createValidatorMiddleware'
-import { RouteConfig, ValidatorConfig } from '../routeConfig'
-import { parseQueryParams } from "../parseQueryParams";
-
-const defaultBeforeAfter = {
-  before: [] as RequestHandler[],
-  after: [] as RequestHandler[],
-  inputValidator: undefined,
-  outputValidator: undefined,
-};
-
-/**
- * Generates an Express router for ${modelName} model.
- * @param config Contains optional middleware to enable routes.
- * @param customUrlPrefix Optional custom URL prefix for the routes.
- * @returns {express.Router}
- */
-export function ${routerFunctionName}(config: RouteConfig<RequestHandler>) {
-  const router = express.Router();
-  const basePath = removeTrailingSlash(config.customUrlPrefix || '') +
-                  removeTrailingSlash(config.addModelPrefix !== false ? '/${modelName.toLowerCase()}' : '');
-
-  const setupRoute = (
-    path: string,
-    method: "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head",
-    middlewares: RequestHandler[],
-    handler: RequestHandler,
-    inputValidator?: ValidatorConfig,
-    outputValidator?: ValidatorConfig
-  ) => {
-    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](removeTrailingSlash(basePath + path), ...middlewaresWithValidators);
-  };
-
-
-  if (config.enableAll || config?.findFirst) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.findFirst || defaultBeforeAfter;
-    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/first', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.findMany) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.findMany || defaultBeforeAfter;
-    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.findUnique) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.findUnique || defaultBeforeAfter;
-    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/:id', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.create) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.create || defaultBeforeAfter;
-    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.createMany) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.createMany || defaultBeforeAfter;
-    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/many', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.update) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.update || defaultBeforeAfter;
-    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.updateMany) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.updateMany || defaultBeforeAfter;
-    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/many', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.upsert) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.upsert || defaultBeforeAfter;
-    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.delete) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.delete || defaultBeforeAfter;
-    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.deleteMany) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.deleteMany || defaultBeforeAfter;
-    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/many', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.aggregate) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.aggregate || defaultBeforeAfter;
-    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/aggregate', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.count) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.count || defaultBeforeAfter;
-    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/count', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.groupBy) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.groupBy || defaultBeforeAfter;
-    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/groupby', ...after);
-    }
-  }
-
-  return router;
-}
-`
-}

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)
-  }
-}`
-}

package/src/helpers/generateUpdateMany.ts

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

package/src/helpers/generateUpsert.ts

@@ -1,57 +0,0 @@
-import { DMMF } from '@prisma/generator-helper'
-import { toPascalCase } from '../utils/strings'
-
-/**
- * Generates an Express middleware function that handles the upsert operation (create or update)
- * 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 generateUpsertFunction = (options: {
-  model: DMMF.Model
-  prismaImportStatement: string
-}): string => {
-  const { model, prismaImportStatement } = options
-  const modelName = model.name
-  const functionName = `${modelName}Upsert`
-  const argsTypeName = `Prisma.${modelName}UpsertArgs`
-
-  return `
-${prismaImportStatement}
-import { Request, Response, NextFunction } from 'express';
-import { RequestHandler, ParamsDictionary } from 'express-serve-static-core';
-import { ZodTypeAny } from 'zod';
-
-interface UpsertRequest extends Request {
-  prisma: PrismaClient;
-  body: ${argsTypeName};
-  outputValidation?: ZodTypeAny;
-  locals?: {
-    outputValidator?: ZodTypeAny;
-  };
-}
-
-export type UpsertMiddleware = RequestHandler<ParamsDictionary, any, ${argsTypeName}, Record<string, any>>
-
-export async function ${functionName}(req: UpsertRequest, res: Response, next: NextFunction) {
-  try {
-    const outputValidator = req.locals?.outputValidator || req.outputValidation;
-
-    const data = await req.prisma.${toPascalCase(modelName)}.upsert(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/utils/copyFiles.ts

@@ -1,27 +0,0 @@
-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/src/utils/formatFile.ts

@@ -1,22 +0,0 @@
-import prettier from 'prettier'
-
-export const formatFile = (content: string): Promise<string> => {
-  return new Promise((res, rej) =>
-    prettier.resolveConfig(process.cwd()).then((options) => {
-      if (!options) {
-        res(content) // no prettier config was found, no need to format
-      }
-
-      try {
-        const formatted = prettier.format(content, {
-          ...options,
-          parser: 'typescript',
-        })
-
-        res(formatted)
-      } catch (error) {
-        rej(error)
-      }
-    })
-  )
-}

package/src/utils/strings.ts

@@ -1,7 +0,0 @@
-export const capitalize = (str: string) =>
-  str.charAt(0).toUpperCase() + str.slice(1)
-
-export function toPascalCase(str: string) {
-  if (!str) return str
-  return str.charAt(0).toLowerCase() + str.slice(1)
-}

package/src/utils/writeFileSafely.ts

@@ -1,29 +0,0 @@
-import fs from 'fs/promises'
-import path from 'path'
-import { formatFile } from './formatFile'
-import { DMMF, GeneratorOptions } from '@prisma/generator-helper'
-
-export const writeFileSafely = async ({
-  model,
-  operation,
-  options,
-  content,
-}: {
-  model?: DMMF.Model
-  operation: string
-  options: GeneratorOptions
-  content: string
-}) => {
-  const fileName =
-    operation === 'index' ? 'index' : `${model?.name || ''}${operation}`
-  const filePath = path.join(
-    options.generator.output?.value!,
-    model ? `${model?.name}/${fileName}.ts` : `/${fileName}.ts`,
-  )
-  console.log('filePath :>> ', filePath)
-  await fs.mkdir(path.dirname(filePath), {
-    recursive: true,
-  })
-
-  await fs.writeFile(filePath, await formatFile(content))
-}