prisma-generator-express 1.45.1 → 1.46.0

package/src/copy/createValidatorMiddleware.ts

@@ -1,62 +0,0 @@
-import { Request, Response, NextFunction } from 'express'
-import { ZodSchema } from 'zod'
-import { allow, forbid } from './transformZod'
-
-export interface ValidatorOptions {
-  schema: ZodSchema<any>
-  allowedPaths?: string[]
-  forbiddenPaths?: string[]
-  target?: 'body' | 'query'
-}
-
-/**
- * Creates a middleware for validating request data using a Zod schema.
- * @param {ValidatorOptions} options - The validation options.
- * @param {ZodSchema<any>} options.schema - The Zod schema to validate the request data.
- * @param {string[]} [options.allowedPaths] - Paths that are allowed in the request data. For example [`where.user.id`, `select.id`]
- * @param {string[]} [options.forbiddenPaths] - Paths that are forbidden in the request data.
- * @param {'body' | 'query'} [options.target='body'] - The part of the request to validate ('body' or 'query').
- * @returns {function} Express middleware function.
- */
-export function createValidatorMiddleware({
-  schema,
-  allowedPaths,
-  forbiddenPaths,
-  target = 'body',
-}: ValidatorOptions) {
-  if (allowedPaths) {
-    schema = allow(schema, allowedPaths)
-  }
-
-  if (forbiddenPaths) {
-    schema = forbid(schema, forbiddenPaths)
-  }
-
-  return (req: Request, res: Response, next: NextFunction) => {
-    let validationResult
-
-    if (target === 'query') {
-      validationResult = schema.safeParse(req.query)
-    } else {
-      validationResult = schema.safeParse(req.body)
-    }
-
-    if (!validationResult.success) {
-      const errors = validationResult.error.issues
-      return next({
-        status: 400,
-        message: 'Validation failed',
-        errors,
-      })
-    }
-
-    next()
-  }
-}
-
-export function removeTrailingSlash(path: string): string {
-  if (path === '/') {
-    return path
-  }
-  return path.replace(/\/+$/, '')
-}

package/src/copy/transformZod.ts

@@ -1,139 +0,0 @@
-import { get } from 'lodash'
-import {
-  output,
-  z,
-  ZodError,
-  ZodObject,
-  ZodType,
-} from 'zod'
-
-function startsWith(str: string, prefix: string): boolean {
-  return str.slice(0, prefix.length) === prefix
-}
-
-function every<T>(
-  array: T[],
-  callback: (value: T, index: number, array: T[]) => boolean,
-): boolean {
-  for (let i = 0; i < array.length; i++) {
-    if (!callback(array[i], i, array)) {
-      return false
-    }
-  }
-  return true
-}
-
-function isKeyAllowed(key: string, allowedPaths: string[]): boolean {
-  return !every(
-    allowedPaths,
-    (path) =>
-      !startsWith(key.replace(/\[\d+\]/g, ''), path.replace(/\[\d+\]/g, '')) &&
-      !startsWith(path.replace(/\[\d+\]/g, ''), key.replace(/\[\d+\]/g, '')),
-  )
-}
-
-export function allow<T extends ZodType>(
-  schema: T,
-  allowedPaths: string[],
-) {
-  const schemaToTransform = schema instanceof z.ZodObject ? schema.strict() : schema
-  const rootSchema = schemaToTransform instanceof z.ZodObject ? schemaToTransform : undefined
-
-  return schemaToTransform.transform((data) => {
-    const flatData = flattenObject(data, '', rootSchema)
-
-    const disallowedPaths: string[] = []
-
-    for (const key of Object.keys(flatData)) {
-      if (!isKeyAllowed(key, allowedPaths)) {
-        disallowedPaths.push(key)
-      }
-    }
-
-    if (disallowedPaths.length > 0) {
-      throw createZodErrorFromPaths(disallowedPaths, 'Field is not allowed:')
-    }
-
-    return data
-  })
-}
-
-export function forbid<T extends ZodType>(
-  schema: T,
-  forbiddenPaths: string[],
-) {
-  return schema.transform((data) => {
-    const forbiddenMatches: string[] = []
-
-    for (const forbiddenPath of forbiddenPaths) {
-      const value = get(data, forbiddenPath)
-
-      if (value !== undefined) {
-        forbiddenMatches.push(forbiddenPath)
-      }
-    }
-
-    if (forbiddenMatches.length > 0) {
-      throw createZodErrorFromPaths(forbiddenMatches, 'Field is forbidden:')
-    }
-    return data
-  })
-}
-
-export function flattenObject<T>(
-  obj: Record<string, any> | output<T>,
-  prefix = '',
-  schema?: ZodObject<any>,
-): Record<string, any> {
-  const result: Record<string, any> = {}
-
-  function flatten(current: any, prop: string, schema?: ZodObject<any>) {
-    if (Object(current) !== current) {
-      result[prop] = current
-    } else if (Array.isArray(current)) {
-      current.forEach((item, index) => {
-        flatten(item, `${prop}[]`, schema)
-      })
-    } else {
-      let isEmpty = true
-      for (const key in current) {
-        if (current.hasOwnProperty(key)) {
-          isEmpty = false
-          const currentSchema = schema?.shape[key]
-          if (
-            currentSchema instanceof z.ZodOptional &&
-            current[key] === undefined
-          ) {
-            continue
-          }
-          flatten(
-            current[key],
-            prop ? `${prop}.${key}` : key,
-            currentSchema instanceof ZodObject ? currentSchema : undefined,
-          )
-        }
-      }
-      if (isEmpty) {
-        result[prop] = {}
-      }
-    }
-  }
-
-  flatten(obj, prefix, schema)
-  return result
-}
-
-function createZodErrorFromPaths(
-  disallowedPaths: string[],
-  errorMessage: string,
-): ZodError {
-  const errors: z.core.$ZodIssue[] = []
-  for (const path of disallowedPaths) {
-    errors.push({
-      code: 'custom',
-      message: `${errorMessage} '${path}'`,
-      path: path.split('.'),
-    })
-  }
-  return new ZodError(errors)
-}