prisma-generator-express 1.18.0 → 1.20.0

package/src/copy/misc.ts

@@ -23,3 +23,24 @@ export function safeJSONparse<T>(
 export const isObject = (value: unknown): value is Record<string, unknown> => {
   return typeof value === 'object' && value !== null && !Array.isArray(value)
 }
+
+const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype'])
+
+export function isSafeKey(key: string): boolean {
+  return !UNSAFE_KEYS.has(key)
+}
+
+export function sanitizeKeys<T>(value: T): T {
+  if (Array.isArray(value)) {
+    return value.map(sanitizeKeys) as T
+  }
+  if (isObject(value)) {
+    const result: Record<string, unknown> = {}
+    for (const key of Object.keys(value)) {
+      if (!isSafeKey(key)) continue
+      result[key] = sanitizeKeys((value as Record<string, unknown>)[key])
+    }
+    return result as T
+  }
+  return value
+}

package/src/copy/operationDefinitions.ts

@@ -0,0 +1,96 @@
+export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete'
+
+export interface OperationDef {
+  name: string
+  method: HttpMethod
+  pathSuffix: string
+  configKey: string
+}
+
+export const OPERATION_DEFS: OperationDef[] = [
+  { name: 'findMany', method: 'get', pathSuffix: '', configKey: 'findMany' },
+  {
+    name: 'findUnique',
+    method: 'get',
+    pathSuffix: '/unique',
+    configKey: 'findUnique',
+  },
+  {
+    name: 'findUniqueOrThrow',
+    method: 'get',
+    pathSuffix: '/unique/strict',
+    configKey: 'findUniqueOrThrow',
+  },
+  {
+    name: 'findFirst',
+    method: 'get',
+    pathSuffix: '/first',
+    configKey: 'findFirst',
+  },
+  {
+    name: 'findFirstOrThrow',
+    method: 'get',
+    pathSuffix: '/first/strict',
+    configKey: 'findFirstOrThrow',
+  },
+  {
+    name: 'findManyPaginated',
+    method: 'get',
+    pathSuffix: '/paginated',
+    configKey: 'findManyPaginated',
+  },
+  { name: 'create', method: 'post', pathSuffix: '', configKey: 'create' },
+  {
+    name: 'createMany',
+    method: 'post',
+    pathSuffix: '/many',
+    configKey: 'createMany',
+  },
+  {
+    name: 'createManyAndReturn',
+    method: 'post',
+    pathSuffix: '/many/return',
+    configKey: 'createManyAndReturn',
+  },
+  { name: 'update', method: 'put', pathSuffix: '', configKey: 'update' },
+  {
+    name: 'updateMany',
+    method: 'put',
+    pathSuffix: '/many',
+    configKey: 'updateMany',
+  },
+  {
+    name: 'updateManyAndReturn',
+    method: 'put',
+    pathSuffix: '/many/return',
+    configKey: 'updateManyAndReturn',
+  },
+  { name: 'upsert', method: 'patch', pathSuffix: '', configKey: 'upsert' },
+  { name: 'delete', method: 'delete', pathSuffix: '', configKey: 'delete' },
+  {
+    name: 'deleteMany',
+    method: 'delete',
+    pathSuffix: '/many',
+    configKey: 'deleteMany',
+  },
+  { name: 'count', method: 'get', pathSuffix: '/count', configKey: 'count' },
+  {
+    name: 'aggregate',
+    method: 'get',
+    pathSuffix: '/aggregate',
+    configKey: 'aggregate',
+  },
+  {
+    name: 'groupBy',
+    method: 'get',
+    pathSuffix: '/groupby',
+    configKey: 'groupBy',
+  },
+]
+
+export function isOperationEnabled(
+  config: Record<string, any>,
+  def: OperationDef,
+): boolean {
+  return !!(config.enableAll || config[def.configKey])
+}

package/src/copy/parseQueryParams.ts

@@ -1,29 +1,38 @@
-import { isObject } from './misc'
-import { ParsedQs } from 'qs'
+import { isObject, isSafeKey, sanitizeKeys } from './misc'
 
-/**
- * Type definition for possible query parameter types.
- */
-type QueryParams = string | ParsedQs | string[] | ParsedQs[] | Array<string | ParsedQs> | undefined
+type QueryParams =
+  | string
+  | Record<string, unknown>
+  | string[]
+  | Record<string, unknown>[]
+  | 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 => {
+const NUMERIC_KEYS = new Set(['take', 'skip'])
+
+const parseQueryValue = (value: string, key?: string): unknown => {
+  if (value.startsWith('{') || value.startsWith('[') || value.startsWith('"')) {
+    try {
+      const parsed = JSON.parse(value)
+      return sanitizeKeys(parsed)
+    } catch {
+      // fall through
+    }
+  }
   if (value === 'true') return true
   if (value === 'false') return false
   if (value === 'null') return null
-  if (!isNaN(Number(value))) return Number(value)
+  if (
+    key &&
+    NUMERIC_KEYS.has(key) &&
+    value !== '' &&
+    !isNaN(Number(value)) &&
+    isFinite(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)
@@ -33,10 +42,16 @@ export const parseQueryParams = (params: QueryParams): unknown => {
   }
   if (isObject(params)) {
     const parsedParams: Record<string, unknown> = {}
-    for (const key in params) {
-      parsedParams[key] = parseQueryParams(params[key])
+    for (const key of Object.keys(params)) {
+      if (!isSafeKey(key)) continue
+      const raw = params[key]
+      if (typeof raw === 'string') {
+        parsedParams[key] = parseQueryValue(raw, key)
+      } else {
+        parsedParams[key] = raw
+      }
     }
     return parsedParams
   }
   return params
-}
+}

package/src/copy/routeConfig.ts

@@ -1,36 +1,76 @@
-import { RequestHandler } from 'express'
-import { ZodType } from 'zod'
+import { RequestHandler, Request } from 'express'
 
-export interface ValidatorConfig {
-  allow?: string[]
-  forbid?: string[]
-  schema: ZodType
+export interface OperationConfig {
+  before?: RequestHandler[]
+  after?: RequestHandler[]
+  shape?: Record<string, any>
 }
 
-interface MiddlewareConfig<M> {
-  before?: M[]
-  after?: RequestHandler[]
-  inputValidator?: ValidatorConfig
-  outputValidator?: ValidatorConfig
+export interface QueryBuilderConfig {
+  enabled?: boolean
+  port?: number
+  host?: string
+  schemaPath?: string
+  databaseUrl?: string
 }
 
-export interface RouteConfig<M> {
-  findFirst?: MiddlewareConfig<M>
-  findMany?: MiddlewareConfig<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>
-  aggregate?: MiddlewareConfig<M>
-  count?: MiddlewareConfig<M>
-  groupBy?: MiddlewareConfig<M>
-  addModelPrefix?: boolean
+export interface OpenApiServerConfig {
+  url: string
+  description?: string
+}
+
+export interface OpenApiSecuritySchemeConfig {
+  type: string
+  scheme?: string
+  bearerFormat?: string
+  name?: string
+  in?: string
+  description?: string
+}
+
+export interface RouteConfig {
   enableAll?: boolean
+  addModelPrefix?: boolean
   customUrlPrefix?: string
+  specBasePath?: string
+  disableOpenApi?: boolean
+  scalarCdnUrl?: string
+
+  openApiTitle?: string
+  openApiDescription?: string
+  openApiVersion?: string
+  openApiServers?: OpenApiServerConfig[]
+  openApiSecuritySchemes?: Record<string, OpenApiSecuritySchemeConfig>
+  openApiSecurity?: Record<string, string[]>[]
+
+  guard?: {
+    resolveVariant?: (req: Request) => string | undefined
+    variantHeader?: string
+  }
+
+  queryBuilder?: QueryBuilderConfig | false
+
+  pagination?: {
+    defaultLimit?: number
+    maxLimit?: number
+  }
+
+  findUnique?: OperationConfig
+  findUniqueOrThrow?: OperationConfig
+  findFirst?: OperationConfig
+  findFirstOrThrow?: OperationConfig
+  findMany?: OperationConfig
+  findManyPaginated?: OperationConfig
+  create?: OperationConfig
+  createMany?: OperationConfig
+  createManyAndReturn?: OperationConfig
+  update?: OperationConfig
+  updateMany?: OperationConfig
+  updateManyAndReturn?: OperationConfig
+  upsert?: OperationConfig
+  delete?: OperationConfig
+  deleteMany?: OperationConfig
+  aggregate?: OperationConfig
+  count?: OperationConfig
+  groupBy?: OperationConfig
 }

package/src/generators/generateImportPrismaStatement.ts

@@ -0,0 +1,78 @@
+import { GeneratorOptions } from '@prisma/generator-helper'
+import path from 'path'
+
+function findClientGenerator(options: GeneratorOptions) {
+  const byName = options.otherGenerators.find((gen) => gen.name === 'client')
+  if (byName) return byName
+
+  const byProvider = options.otherGenerators.find(
+    (gen) =>
+      gen.provider.value === 'prisma-client-js' ||
+      gen.provider.value === '@prisma/client' ||
+      gen.provider.value === 'prisma-client',
+  )
+  if (byProvider) return byProvider
+
+  const withOutput = options.otherGenerators.find(
+    (gen) =>
+      gen.output?.value?.includes('prisma') ||
+      gen.output?.value?.includes('client'),
+  )
+  return withOutput || null
+}
+
+function getRelativeImportPath(
+  fromDir: string,
+  clientOutputPath: string,
+): string {
+  let relativeImportPath = path.relative(fromDir, clientOutputPath)
+  relativeImportPath = relativeImportPath.split(path.sep).join(path.posix.sep)
+  if (!relativeImportPath.startsWith('.')) {
+    relativeImportPath = './' + relativeImportPath
+  }
+  return relativeImportPath
+}
+
+export function generateImportPrismaStatement(
+  generatorOptions: GeneratorOptions,
+): string {
+  const clientGenerator = findClientGenerator(generatorOptions)
+
+  if (!clientGenerator || !clientGenerator.output?.value) {
+    throw new Error(
+      'Prisma client generator not found. Ensure a generator with provider "prisma-client-js" exists in your schema.',
+    )
+  }
+
+  const outputValue = generatorOptions.generator.output?.value
+  if (!outputValue) {
+    throw new Error('Generator output path not defined.')
+  }
+
+  const subDir = path.join(outputValue, '_relative')
+  const outputPath = getRelativeImportPath(subDir, clientGenerator.output.value)
+
+  return `import { Prisma, PrismaClient } from '${outputPath}';\n`
+}
+
+export function getRelativeClientPath(
+  generatorOptions: GeneratorOptions,
+  modelName: string,
+): string {
+  const clientGenerator = findClientGenerator(generatorOptions)
+
+  if (!clientGenerator || !clientGenerator.output?.value) {
+    throw new Error(
+      'Prisma client generator not found. Ensure a generator with provider "prisma-client-js" exists in your schema.',
+    )
+  }
+
+  const outputValue = generatorOptions.generator.output?.value
+  if (!outputValue) {
+    throw new Error('Generator output path not defined.')
+  }
+
+  const routerDirPath = path.join(outputValue, modelName)
+
+  return getRelativeImportPath(routerDirPath, clientGenerator.output.value)
+}

package/src/generators/generateQueryBuilderHelper.ts

@@ -0,0 +1,138 @@
+import { GeneratorOptions } from '@prisma/generator-helper'
+
+export function generateQueryBuilderHelper(options: GeneratorOptions): string {
+  const schemaPath = options.schemaPath
+    ? JSON.stringify(options.schemaPath)
+    : "require('path').resolve(process.cwd(), 'prisma/schema.prisma')"
+
+  return `import { spawn } from 'child_process'
+import { resolve, join, dirname } from 'path'
+import { existsSync, readFileSync } from 'fs'
+import { createRequire } from 'module'
+import type { ChildProcess } from 'child_process'
+
+let _process: ChildProcess | null = null
+let _stopping = false
+let _cleanupRegistered = false
+
+export interface QueryBuilderOptions {
+  port?: number
+  host?: string
+  schemaPath?: string
+  databaseUrl?: string
+}
+
+function findCliPath(): string | null {
+  try {
+    const req = createRequire(resolve(process.cwd(), 'package.json'))
+    const pkgJsonPath = req.resolve('prisma-query-builder-ui/package.json')
+    const pkgDir = dirname(pkgJsonPath)
+    const cliPath = join(pkgDir, 'bin', 'cli.js')
+    if (existsSync(cliPath)) return cliPath
+  } catch {}
+
+  let dir = process.cwd()
+  const root = resolve(dir, '/')
+  while (dir !== root) {
+    const candidate = join(dir, 'node_modules', 'prisma-query-builder-ui', 'bin', 'cli.js')
+    if (existsSync(candidate)) return candidate
+    dir = dirname(dir)
+  }
+
+  return null
+}
+
+export function startQueryBuilder(options: QueryBuilderOptions = {}): void {
+  if (_process) return
+
+  const env = typeof process !== 'undefined' && process.env ? process.env : {} as Record<string, string | undefined>
+
+  if (env.NODE_ENV === 'production') return
+
+  const cliPath = findCliPath()
+  if (!cliPath) {
+    console.warn('[query-builder] prisma-query-builder-ui not found. Install: npm install prisma-query-builder-ui')
+    return
+  }
+
+  const port = options.port || 5173
+  const host = options.host || 'localhost'
+  const schemaPath = options.schemaPath || ${schemaPath}
+  const databaseUrl = options.databaseUrl || env.DATABASE_URL || ''
+
+  if (!existsSync(schemaPath)) {
+    console.error('[query-builder] Schema file not found: ' + schemaPath)
+    return
+  }
+
+  let schemaContent: string
+  try {
+    schemaContent = readFileSync(schemaPath, 'utf-8')
+  } catch (err) {
+    console.error('[query-builder] Failed to read schema:', err)
+    return
+  }
+
+  const schemaCwd = dirname(resolve(schemaPath))
+
+  _process = spawn(process.execPath, [cliPath], {
+    stdio: 'inherit',
+    env: {
+      ...env,
+      PORT: String(port),
+      HOST: host,
+      PRISMA_QUERY_BUILDER_MODE: 'embedded',
+      DISABLE_PERSISTENCE: 'true',
+      PRISMA_QUERY_BUILDER_SCHEMA_CONTENT: schemaContent,
+      PRISMA_QUERY_BUILDER_CWD: schemaCwd,
+      DATABASE_URL: databaseUrl,
+    },
+  })
+
+  _process.on('error', (err) => {
+    console.error('[query-builder] Failed to start:', err.message)
+    _process = null
+  })
+
+  _process.on('exit', (code) => {
+    const wasStopping = _stopping
+    _stopping = false
+    _process = null
+    if (!wasStopping && code !== 0) {
+      console.warn('[query-builder] Process exited with code ' + code)
+    }
+  })
+
+  if (!_cleanupRegistered) {
+    _cleanupRegistered = true
+
+    process.on('exit', () => {
+      stopQueryBuilder()
+    })
+
+    const handleSigint = () => {
+      stopQueryBuilder()
+      process.removeListener('SIGINT', handleSigint)
+      process.kill(process.pid, 'SIGINT')
+    }
+
+    const handleSigterm = () => {
+      stopQueryBuilder()
+      process.removeListener('SIGTERM', handleSigterm)
+      process.kill(process.pid, 'SIGTERM')
+    }
+
+    process.on('SIGINT', handleSigint)
+    process.on('SIGTERM', handleSigterm)
+  }
+
+  console.log('[query-builder] Starting on http://' + host + ':' + port)
+}
+
+export function stopQueryBuilder(): void {
+  if (!_process || _process.killed) return
+  _stopping = true
+  _process.kill()
+}
+`
+}