prisma-generator-express 1.12.0 → 1.13.0

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

package/src/copy/parseQueryParams.spec.ts

@@ -0,0 +1,187 @@
+import { parseQueryParams } from './parseQueryParams'
+
+describe('parseQueryParams', () => {
+  it('should parse basic field selection correctly', () => {
+    const params = {
+      select: {
+        id: 'true',
+        name: 'true',
+      },
+    }
+    const result = parseQueryParams(params)
+    expect(result).toEqual({
+      select: {
+        id: true,
+        name: true,
+      },
+    })
+  })
+
+  it('should parse nested field selection correctly', () => {
+    const params = {
+      select: {
+        user: {
+          select: {
+            profile: 'true',
+          },
+        },
+      },
+    }
+    const result = parseQueryParams(params)
+    expect(result).toEqual({
+      select: {
+        user: {
+          select: {
+            profile: true,
+          },
+        },
+      },
+    })
+  })
+
+  it('should handle deeply nested logical operators correctly', () => {
+    const params = {
+      where: {
+        AND: [
+          { id: '123' },
+          {
+            OR: [{ active: 'true' }, { active: 'false' }],
+          },
+        ],
+      },
+    }
+    const result = parseQueryParams(params)
+    expect(result).toEqual({
+      where: {
+        AND: [
+          { id: 123 },
+          {
+            OR: [{ active: true }, { active: false }],
+          },
+        ],
+      },
+    })
+  })
+
+  it('should handle complex nested arrays correctly', () => {
+    const params = {
+      where: {
+        id: 'Vxdu42',
+        AND: [
+          {
+            OR: [{ to_delete: 'false' }, { to_delete: 'null' }],
+          },
+        ],
+      },
+    }
+    const result = parseQueryParams(params)
+    expect(result).toEqual({
+      where: {
+        id: 'Vxdu42',
+        AND: [
+          {
+            OR: [{ to_delete: false }, { to_delete: null }],
+          },
+        ],
+      },
+    })
+  })
+
+  it('should handle mixed types and conditions', () => {
+    const params = {
+      select: {
+        id: 'true',
+        project_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',
+          },
+        },
+      },
+      where: {
+        id: 'Vxdu42',
+        AND: [
+          {
+            OR: [{ to_delete: 'false' }, { to_delete: 'null' }],
+          },
+        ],
+      },
+    }
+    const result = parseQueryParams(params)
+    expect(result).toEqual({
+      select: {
+        id: true,
+        project_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',
+          },
+        },
+      },
+      where: {
+        id: 'Vxdu42',
+        AND: [
+          {
+            OR: [{ to_delete: false }, { to_delete: null }],
+          },
+        ],
+      },
+    })
+  })
+
+  it('should handle special cases correctly', () => {
+    const params = {
+      emptyObject: {},
+      emptyArray: [],
+      unexpectedType: '123',
+    }
+    const result = parseQueryParams(params)
+    expect(result).toEqual({
+      emptyObject: {},
+      emptyArray: [],
+      unexpectedType: 123,
+    })
+  })
+
+  it('should parse string values correctly', () => {
+    expect(parseQueryParams('true')).toBe(true)
+    expect(parseQueryParams('false')).toBe(false)
+    expect(parseQueryParams('null')).toBe(null)
+    expect(parseQueryParams('123')).toBe(123)
+    expect(parseQueryParams('test')).toBe('test')
+  })
+})

package/src/copy/parseQueryParams.ts

@@ -0,0 +1,42 @@
+import { isObject } from './misc'
+import { ParsedQs } from 'qs'
+
+/**
+ * Type definition for possible query parameter types.
+ */
+type QueryParams = string | ParsedQs | string[] | ParsedQs[] | undefined
+
+/**
+ * Parses a query value to convert strings to their respective types.
+ * @param {string} value - The query value to parse.
+ * @returns {unknown} The parsed value.
+ */
+const parseQueryValue = (value: string): unknown => {
+  if (value === 'true') return true
+  if (value === 'false') return false
+  if (value === 'null') return null
+  if (!isNaN(Number(value))) return Number(value)
+  return value
+}
+
+/**
+ * Recursively parses query parameters to convert strings to their respective types.
+ * @param {QueryParams} params - The query parameters to parse.
+ * @returns {unknown} The parsed query parameters.
+ */
+export const parseQueryParams = (params: QueryParams): unknown => {
+  if (typeof params === 'string') {
+    return parseQueryValue(params)
+  }
+  if (Array.isArray(params)) {
+    return params.map(parseQueryParams)
+  }
+  if (isObject(params)) {
+    const parsedParams: Record<string, unknown> = {}
+    for (const key in params) {
+      parsedParams[key] = parseQueryParams(params[key])
+    }
+    return parsedParams
+  }
+  return params
+}

package/src/copy/routeConfig.ts

@@ -0,0 +1,34 @@
+import { RequestHandler } from 'express'
+import { ZodTypeAny } from 'zod'
+
+export interface ValidatorConfig {
+  allow?: string[]
+  forbid?: string[]
+  schema: ZodTypeAny
+}
+
+interface MiddlewareConfig<M> {
+  before?: M[]
+  after?: RequestHandler[]
+  input?: ValidatorConfig
+  output?: ValidatorConfig
+}
+
+export interface RouteConfig<M> {
+  findFirst?: MiddlewareConfig<M>
+  findMany?: MiddlewareConfig<M>
+  findUnique?: MiddlewareConfig<M>
+  create?: MiddlewareConfig<M>
+  createMany?: MiddlewareConfig<M>
+  update?: MiddlewareConfig<M>
+  updateMany?: MiddlewareConfig<M>
+  upsert?: MiddlewareConfig<M>
+  delete?: MiddlewareConfig<M>
+  deleteMany?: MiddlewareConfig<M>
+  aggregate?: MiddlewareConfig<M>
+  count?: MiddlewareConfig<M>
+  groupBy?: MiddlewareConfig<M>
+  addModelPrefix?: boolean
+  enableAll?: boolean
+  customUrlPrefix?: string
+}