prisma-generator-express 1.12.0 → 1.14.0

package/src/copy/createOutputValidatorMiddleware.ts

@@ -0,0 +1,44 @@
+import { NextFunction } from 'express'
+import { allow, forbid } from './transformZod'
+import { ValidatorOptions } from './createValidatorMiddleware'
+
+/**
+ * Creates a middleware for validating response data using a Zod schema.
+ * @param {ValidatorOptions} options - The validation options.
+ * @param {ZodSchema<any>} options.schema - The Zod schema to validate the response data.
+ * @param {string[]} [options.allowedPaths] - Paths that are allowed in the response data.
+ * @param {string[]} [options.forbiddenPaths] - Paths that are forbidden in the response data.
+ * @returns {function} Express middleware function.
+ */
+export function createOutputValidatorMiddleware({
+  schema,
+  allowedPaths,
+  forbiddenPaths,
+}: ValidatorOptions) {
+  if (allowedPaths) {
+    schema = allow(schema, allowedPaths)
+  }
+
+  if (forbiddenPaths) {
+    schema = forbid(schema, forbiddenPaths)
+  }
+
+  return (req: Request, res: Response, next: NextFunction) => {
+    const originalSend = res.send
+
+    res.send = function (data) {
+      const validationResult = schema.safeParse(data)
+      if (!validationResult.success) {
+        const errors = validationResult.error.errors
+        return next({
+          status: 400,
+          message: 'Output validation failed',
+          errors,
+        })
+      }
+      return originalSend.call(this, data)
+    }
+
+    next()
+  }
+}

package/src/copy/createValidatorMiddleware.ts

@@ -0,0 +1,55 @@
+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.errors
+      return next({
+        status: 400,
+        message: 'Validation failed',
+        errors,
+      })
+    }
+
+    next()
+  }
+}

package/src/copy/encodeQueryParams.spec.ts

@@ -0,0 +1,303 @@
+import { encodeQueryParams } from './encodeQueryParams'
+
+describe('Query Params Encoding', () => {
+  it('should encode simple key-value pairs correctly', () => {
+    const params = {
+      id: 1,
+      name: 'test',
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('id=1&name=test')
+  })
+
+  it('should encode nested objects correctly', () => {
+    const params = {
+      select: {
+        id: true,
+        name: true,
+      },
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('select%5Bid%5D=true&select%5Bname%5D=true')
+  })
+
+  it('should encode arrays correctly', () => {
+    const params = {
+      ids: [1, 2, 3],
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('ids%5B0%5D=1&ids%5B1%5D=2&ids%5B2%5D=3')
+  })
+
+  it('should encode complex nested objects correctly', () => {
+    const params = {
+      select: {
+        id: true,
+        project_id: true,
+        list_id: true,
+        user_assignments: {
+          select: {
+            user: true,
+          },
+        },
+        tags_mappings: {
+          select: {
+            tag: true,
+          },
+        },
+        attachments: {
+          select: {
+            attachment: true,
+          },
+          where: {
+            is_image: true,
+          },
+          take: 100,
+          orderBy: {
+            created_at: 'desc',
+          },
+        },
+        rendered_description: true,
+        description: true,
+        created_at: true,
+        start_date: true,
+        reactions: true,
+        intervals: true,
+        column_id: true,
+        priority: true,
+        due_date: true,
+        column: true,
+        title: true,
+        order: true,
+        color: true,
+      },
+      where: {
+        id: 'task_id',
+        AND: [
+          {
+            OR: [{ to_delete: false }, { to_delete: null }],
+          },
+        ],
+      },
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'select%5Bid%5D=true&select%5Bproject_id%5D=true&select%5Blist_id%5D=true&select%5Buser_assignments%5D%5Bselect%5D%5Buser%5D=true&select%5Btags_mappings%5D%5Bselect%5D%5Btag%5D=true&select%5Battachments%5D%5Bselect%5D%5Battachment%5D=true&select%5Battachments%5D%5Bwhere%5D%5Bis_image%5D=true&select%5Battachments%5D%5Btake%5D=100&select%5Battachments%5D%5BorderBy%5D%5Bcreated_at%5D=desc&select%5Brendered_description%5D=true&select%5Bdescription%5D=true&select%5Bcreated_at%5D=true&select%5Bstart_date%5D=true&select%5Breactions%5D=true&select%5Bintervals%5D=true&select%5Bcolumn_id%5D=true&select%5Bpriority%5D=true&select%5Bdue_date%5D=true&select%5Bcolumn%5D=true&select%5Btitle%5D=true&select%5Border%5D=true&select%5Bcolor%5D=true&where%5Bid%5D=task_id&where%5BAND%5D%5B0%5D%5BOR%5D%5B0%5D%5Bto_delete%5D=false&where%5BAND%5D%5B0%5D%5BOR%5D%5B1%5D%5Bto_delete%5D=null',
+    )
+  })
+
+  it('should handle empty objects correctly', () => {
+    const params = {}
+    const result = encodeQueryParams(params)
+    expect(result).toBe('')
+  })
+
+  it('should handle null values correctly', () => {
+    const params = {
+      id: null,
+      name: 'test',
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('id=null&name=test')
+  })
+
+  it('should handle boolean values correctly', () => {
+    const params = {
+      isActive: true,
+      isDeleted: false,
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('isActive=true&isDeleted=false')
+  })
+
+  it('should handle nested arrays correctly', () => {
+    const params = {
+      filters: [
+        {
+          key: 'age',
+          values: [20, 30, 40],
+        },
+      ],
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'filters%5B0%5D%5Bkey%5D=age&filters%5B0%5D%5Bvalues%5D%5B0%5D=20&filters%5B0%5D%5Bvalues%5D%5B1%5D=30&filters%5B0%5D%5Bvalues%5D%5B2%5D=40',
+    )
+  })
+
+  it('should handle complex nested arrays and objects', () => {
+    const params = {
+      select: {
+        id: true,
+        name: true,
+        details: {
+          address: {
+            street: 'Main St',
+            city: 'Metropolis',
+          },
+          phoneNumbers: [
+            {
+              type: 'home',
+              number: '123-456-7890',
+            },
+            {
+              type: 'work',
+              number: '098-765-4321',
+            },
+          ],
+        },
+      },
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'select%5Bid%5D=true&select%5Bname%5D=true&select%5Bdetails%5D%5Baddress%5D%5Bstreet%5D=Main%20St&select%5Bdetails%5D%5Baddress%5D%5Bcity%5D=Metropolis&select%5Bdetails%5D%5BphoneNumbers%5D%5B0%5D%5Btype%5D=home&select%5Bdetails%5D%5BphoneNumbers%5D%5B0%5D%5Bnumber%5D=123-456-7890&select%5Bdetails%5D%5BphoneNumbers%5D%5B1%5D%5Btype%5D=work&select%5Bdetails%5D%5BphoneNumbers%5D%5B1%5D%5Bnumber%5D=098-765-4321',
+    )
+  })
+
+  it('should handle edge cases correctly', () => {
+    const params = {
+      select: {
+        id: '',
+        name: null,
+        details: {
+          address: {
+            street: undefined,
+            city: 'Metropolis',
+          },
+        },
+      },
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'select%5Bid%5D=&select%5Bname%5D=null&select%5Bdetails%5D%5Baddress%5D%5Bcity%5D=Metropolis',
+    )
+  })
+
+  it('should handle multiple nested levels correctly', () => {
+    const params = {
+      level1: {
+        level2: {
+          level3: {
+            level4: {
+              key: 'value',
+            },
+          },
+        },
+      },
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'level1%5Blevel2%5D%5Blevel3%5D%5Blevel4%5D%5Bkey%5D=value',
+    )
+  })
+
+  it('should handle empty strings and null values correctly', () => {
+    const params = {
+      key1: '',
+      key2: null,
+      key3: 'value',
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('key1=&key2=null&key3=value')
+  })
+
+  it('should encode special characters correctly', () => {
+    const params = {
+      name: "O'Reilly & Sons",
+      description: '20% discount!',
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'name=O%27Reilly%20%26%20Sons&description=20%25%20discount%21',
+    )
+  })
+
+  it('should handle empty arrays correctly', () => {
+    const params = {
+      filters: [],
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('filters%5B%5D=')
+  })
+
+  it('should encode only special characters correctly', () => {
+    const params = {
+      special: '!@#$%^&*()_+{}|:"<>?[]\\;\',./`~',
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'special=%21%40%23%24%25%5E%26%2A%28%29_%2B%7B%7D%7C%3A%22%3C%3E%3F%5B%5D%5C%3B%27%2C.%2F%60%7E',
+    )
+  })
+
+  it('should encode repeated special characters correctly', () => {
+    const params = {
+      special: '!!!@@@###$$$',
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('special=%21%21%21%40%40%40%23%23%23%24%24%24')
+  })
+
+  it('should encode special characters in keys correctly', () => {
+    const params = {
+      'sp!ci@l': 'value',
+      'key&with=special?chars': 'another value',
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'sp%21ci%40l=value&key%26with%3Dspecial%3Fchars=another%20value',
+    )
+  })
+
+  it('should handle arrays with mixed types correctly', () => {
+    const params = {
+      mixedArray: [1, 'two', { three: 3 }],
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'mixedArray%5B0%5D=1&mixedArray%5B1%5D=two&mixedArray%5B2%5D%5Bthree%5D=3',
+    )
+  })
+
+  it('should handle boolean and null values in nested objects correctly', () => {
+    const params = {
+      nested: {
+        flag: true,
+        notSet: null,
+      },
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe('nested%5Bflag%5D=true&nested%5BnotSet%5D=null')
+  })
+
+  it('should handle empty strings in nested objects correctly', () => {
+    const params = {
+      nested: {
+        emptyString: '',
+        validString: 'value',
+      },
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'nested%5BemptyString%5D=&nested%5BvalidString%5D=value',
+    )
+  })
+
+  it('should handle deeply nested structures correctly', () => {
+    const params = {
+      level1: {
+        level2: {
+          level3: {
+            level4: {
+              level5: 'value',
+            },
+          },
+        },
+      },
+    }
+    const result = encodeQueryParams(params)
+    expect(result).toBe(
+      'level1%5Blevel2%5D%5Blevel3%5D%5Blevel4%5D%5Blevel5%5D=value',
+    )
+  })
+})

package/src/copy/encodeQueryParams.ts

@@ -0,0 +1,44 @@
+import { isObject } from './misc'
+
+/**
+ * Encodes query parameters recursively, skipping undefined values.
+ * @param {Record<string, unknown>} params - The query parameters to encode.
+ * @returns {string} The encoded query string.
+ */
+export const encodeQueryParams = (params: Record<string, unknown>): string => {
+  const customEncodeURIComponent = (str: string): string => {
+    return encodeURIComponent(str)
+      .replace(
+        /[!'()*~]/g,
+        (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,
+      )
+      .replace(/%20/g, '%20') // Encode spaces as %20
+  }
+
+  const encode = (key: string, value: unknown): string => {
+    if (value === undefined) {
+      return ''
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        return `${customEncodeURIComponent(key)}%5B%5D=`
+      }
+      return value
+        .map((v, i) => encode(`${key}[${i}]`, v))
+        .filter(Boolean)
+        .join('&')
+    }
+    if (isObject(value)) {
+      return Object.entries(value)
+        .map(([k, v]) => encode(`${key}[${k}]`, v))
+        .filter(Boolean)
+        .join('&')
+    }
+    return `${customEncodeURIComponent(key)}=${customEncodeURIComponent(String(value))}`
+  }
+
+  return Object.entries(params)
+    .map(([k, v]) => encode(k, v))
+    .filter(Boolean)
+    .join('&')
+}

package/src/copy/misc.spec.ts

@@ -0,0 +1,62 @@
+import { isJsonString, safeJSONparse, isObject } from './misc'
+
+describe('misc.ts', () => {
+  describe('isJsonString', () => {
+    it('should return true for valid JSON string', () => {
+      expect(isJsonString('{"name":"John"}')).toBe(true)
+    })
+
+    it('should return false for invalid JSON string', () => {
+      expect(isJsonString('{"name": "John"')).toBe(false) // Missing closing brace
+    })
+
+    it('should return false for non-string input', () => {
+      expect(isJsonString(123)).toBe(false)
+      expect(isJsonString({ name: 'John' })).toBe(false)
+      expect(isJsonString(null)).toBe(false)
+      expect(isJsonString(undefined)).toBe(false)
+    })
+  })
+  describe('safeJSONparse', () => {
+    it('should parse valid JSON string', () => {
+      expect(safeJSONparse('{"name":"John"}')).toEqual({ name: 'John' })
+    })
+
+    it('should return false for string "false"', () => {
+      expect(safeJSONparse('false')).toBe(false)
+    })
+
+    it('should return undefined for string "undefined"', () => {
+      expect(safeJSONparse('undefined')).toBeUndefined()
+    })
+
+    it('should return null for string "null"', () => {
+      expect(safeJSONparse('null')).toBeNull()
+    })
+
+    it('should return original data for non-JSON string', () => {
+      expect(safeJSONparse('Hello World')).toBe('Hello World')
+    })
+
+    it('should return original data for non-string input', () => {
+      expect(safeJSONparse(123)).toBe(123)
+      expect(safeJSONparse({ name: 'John' })).toEqual({ name: 'John' })
+      expect(safeJSONparse(null)).toBe(null)
+      expect(safeJSONparse(undefined)).toBe(undefined)
+    })
+  })
+  describe('isObject', () => {
+    it('should return true for objects', () => {
+      expect(isObject({})).toBe(true)
+      expect(isObject({ name: 'John' })).toBe(true)
+    })
+
+    it('should return false for non-objects', () => {
+      expect(isObject('Hello World')).toBe(false)
+      expect(isObject(123)).toBe(false)
+      expect(isObject(null)).toBe(false)
+      expect(isObject(undefined)).toBe(false)
+      expect(isObject([])).toBe(false) // Arrays are not considered objects in this context
+    })
+  })
+})

package/src/copy/misc.ts

@@ -0,0 +1,25 @@
+export function isJsonString(str: string | unknown): boolean {
+  if (typeof str !== 'string') {
+    return false
+  }
+
+  try {
+    JSON.parse(str)
+  } catch (e: unknown) {
+    return false
+  }
+  return true
+}
+
+export function safeJSONparse<T>(
+  data: unknown,
+): T | boolean | undefined | null {
+  if (data === 'false') return false
+  if (data === 'undefined') return undefined
+  if (data === 'null') return null
+  return isJsonString(data) ? JSON.parse(data as string) : data
+}
+
+export const isObject = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}