prisma-generator-express 1.16.6 → 1.18.0

package/src/copy/routeConfig.ts

@@ -1,10 +1,10 @@
 import { RequestHandler } from 'express'
-import { ZodTypeAny } from 'zod'
+import { ZodType } from 'zod'
 
 export interface ValidatorConfig {
   allow?: string[]
   forbid?: string[]
-  schema: ZodTypeAny
+  schema: ZodType
 }
 
 interface MiddlewareConfig<M> {
@@ -20,8 +20,10 @@ export interface RouteConfig<M> {
   findUnique?: MiddlewareConfig<M>
   create?: MiddlewareConfig<M>
   createMany?: MiddlewareConfig<M>
+  createManyAndReturn?: MiddlewareConfig<M>
   update?: MiddlewareConfig<M>
   updateMany?: MiddlewareConfig<M>
+  updateManyAndReturn?: MiddlewareConfig<M>
   upsert?: MiddlewareConfig<M>
   delete?: MiddlewareConfig<M>
   deleteMany?: MiddlewareConfig<M>
@@ -31,4 +33,4 @@ export interface RouteConfig<M> {
   addModelPrefix?: boolean
   enableAll?: boolean
   customUrlPrefix?: string
-}
+}

package/src/copy/transformZod.ts

@@ -1,12 +1,10 @@
 import { get } from 'lodash'
 import {
+  output,
   z,
-  ZodEffects,
   ZodError,
-  ZodIssue,
-  ZodIssueCode,
   ZodObject,
-  ZodTypeAny,
+  ZodType,
 } from 'zod'
 
 function startsWith(str: string, prefix: string): boolean {
@@ -34,13 +32,14 @@ function isKeyAllowed(key: string, allowedPaths: string[]): boolean {
   )
 }
 
-export function allow<T extends ZodTypeAny>(
+export function allow<T extends ZodType>(
   schema: T,
   allowedPaths: string[],
-): ZodEffects<T, any, any> {
-  const rootSchema = schema instanceof z.ZodObject ? schema.strict() : undefined
+) {
+  const schemaToTransform = schema instanceof z.ZodObject ? schema.strict() : schema
+  const rootSchema = schemaToTransform instanceof z.ZodObject ? schemaToTransform : undefined
 
-  return rootSchema?.transform((data) => {
+  return schemaToTransform.transform((data) => {
     const flatData = flattenObject(data, '', rootSchema)
 
     const disallowedPaths: string[] = []
@@ -56,13 +55,13 @@ export function allow<T extends ZodTypeAny>(
     }
 
     return data
-  }) as unknown as ZodEffects<T, any, any>
+  })
 }
 
-export function forbid<T extends z.ZodTypeAny>(
+export function forbid<T extends ZodType>(
   schema: T,
   forbiddenPaths: string[],
-): ZodEffects<T, any, any> {
+) {
   return schema.transform((data) => {
     const forbiddenMatches: string[] = []
 
@@ -78,11 +77,11 @@ export function forbid<T extends z.ZodTypeAny>(
       throw createZodErrorFromPaths(forbiddenMatches, 'Field is forbidden:')
     }
     return data
-  }) as ZodEffects<T, any, any>
+  })
 }
 
-export function flattenObject(
-  obj: Record<string, any>,
+export function flattenObject<T>(
+  obj: Record<string, any> | output<T>,
   prefix = '',
   schema?: ZodObject<any>,
 ): Record<string, any> {
@@ -128,10 +127,10 @@ function createZodErrorFromPaths(
   disallowedPaths: string[],
   errorMessage: string,
 ): ZodError {
-  const errors: ZodIssue[] = []
+  const errors: z.core.$ZodIssue[] = []
   for (const path of disallowedPaths) {
     errors.push({
-      code: ZodIssueCode.custom,
+      code: 'custom',
       message: `${errorMessage} '${path}'`,
       path: path.split('.'),
     })

package/src/generator.ts

@@ -2,22 +2,9 @@ import { generatorHandler, GeneratorOptions } from '@prisma/generator-helper'
 import { logger } from '@prisma/sdk'
 import { GENERATOR_NAME } from './constants'
 import { writeFileSafely } from './utils/writeFileSafely'
-import { generateFindUniqueFunction } from './helpers/generateFindUnique'
 import { generateImportPrismaStatement } from './helpers/generateImportPrismaStatement'
-import { generateFindManyFunction } from './helpers/generateFindMany'
-import { generateFindFirstFunction } from './helpers/generateFindFirst'
-import { generateCreateFunction } from './helpers/generateCreate'
 import { generateRouterFunction } from './helpers/generateRouteFile'
-import { generateCreateManyFunction } from './helpers/generateCreateMany'
-import { generateUpdateFunction } from './helpers/generateUpdate'
-import { generateUpdateManyFunction } from './helpers/generateUpdateMany'
-import { generateUpsertFunction } from './helpers/generateUpsert'
-import { generateDeleteFunction } from './helpers/generateDelete'
-import { generateDeleteManyFunction } from './helpers/generateDeleteMany'
-import { generateAggregateFunction } from './helpers/generateAggregate'
-import { generateCountFunction } from './helpers/generateCount'
-import { generateGroupByFunction } from './helpers/generateGroupBy'
-
+import { generateOperationFunction, OPERATION_CONFIGS } from './helpers/generateOperation'
 import { copyFiles } from './utils/copyFiles'
 
 const { version } = require('../package.json')
@@ -45,135 +32,14 @@ generatorHandler({
         continue
       }
 
-      await writeFileSafely({
-        content: generateFindUniqueFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'FindUnique',
-      })
-
-      await writeFileSafely({
-        content: generateFindFirstFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'FindFirst',
-      })
-
-      await writeFileSafely({
-        content: generateFindManyFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'FindMany',
-      })
-
-      await writeFileSafely({
-        content: generateCreateFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'Create',
-      })
-
-      await writeFileSafely({
-        content: generateCreateManyFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'CreateMany',
-      })
-
-      await writeFileSafely({
-        content: generateUpdateFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'Update',
-      })
-
-      await writeFileSafely({
-        content: generateUpdateManyFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'UpdateMany',
-      })
-
-      await writeFileSafely({
-        content: generateUpsertFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'Upsert',
-      })
-
-      await writeFileSafely({
-        content: generateDeleteFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'Delete',
-      })
-
-      await writeFileSafely({
-        content: generateDeleteManyFunction({
+      for (const cfg of OPERATION_CONFIGS) {
+        await writeFileSafely({
+          content: generateOperationFunction(cfg, model, prismaImportStatement),
+          options,
           model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'DeleteMany',
-      })
-
-      await writeFileSafely({
-        content: generateAggregateFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'Aggregate',
-      })
-
-      await writeFileSafely({
-        content: generateCountFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'Count',
-      })
-
-      await writeFileSafely({
-        content: generateGroupByFunction({
-          model,
-          prismaImportStatement,
-        }),
-        options,
-        model,
-        operation: 'GroupBy',
-      })
+          operation: cfg.operation,
+        })
+      }
 
       await writeFileSafely({
         content: generateRouterFunction({ model }),
@@ -185,4 +51,4 @@ generatorHandler({
 
     await copyFiles(options)
   },
-})
+})