prisma-generator-express 1.19.0 → 1.20.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prisma-generator-express",
   "description": "Prisma generator for Hono CRUD API with OpenAPI documentation",
-  "version": "1.19.0",
+  "version": "1.20.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
@@ -71,11 +71,9 @@
   ],
   "files": [
     "dist/**/*",
-    "src/copy/**/*",
-    "src/client/**/*",
-    "!**/.DS_Store",
-    "README.md",
-    "LICENSE"
+    "src/**/*",
+    "../../README.md",
+    "../../LICENSE"
   ],
   "release": {
     "branches": [

package/src/bin.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '.'

package/src/constants.ts

@@ -0,0 +1 @@
+export const GENERATOR_NAME = 'prisma-generator-express'

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

package/src/generators/generateRouter.ts

@@ -0,0 +1,352 @@
+import { DMMF } from '@prisma/generator-helper'
+
+export function generateRouterFunction({
+  model,
+  enums,
+  relativeClientPath,
+}: {
+  model: DMMF.Model
+  enums: DMMF.DatamodelEnum[]
+  relativeClientPath: string
+}): string {
+  const modelName = model.name
+  const modelNameLower = modelName.toLowerCase()
+  const routerFunctionName = `${modelName}Router`
+
+  const fieldsMeta = model.fields.map((f) => ({
+    name: f.name,
+    kind: f.kind,
+    type: f.type,
+    isList: f.isList,
+    isRequired: f.isRequired,
+    hasDefaultValue: f.hasDefaultValue,
+    isUpdatedAt: f.isUpdatedAt ?? false,
+    documentation: f.documentation,
+    relationFromFields: f.relationFromFields,
+  }))
+
+  const referencedEnumTypes = new Set(
+    model.fields.filter((f) => f.kind === 'enum').map((f) => f.type),
+  )
+
+  const enumsMeta = enums
+    .filter((e) => referencedEnumTypes.has(e.name))
+    .map((e) => ({
+      name: e.name,
+      values: e.values.map((v) => ({ name: v.name })),
+    }))
+
+  return `import express, { Request, Response, NextFunction, RequestHandler } from 'express'
+import type { PrismaClient } from '${relativeClientPath}'
+import {
+  ${modelName}FindUnique,
+  ${modelName}FindUniqueOrThrow,
+  ${modelName}FindFirst,
+  ${modelName}FindFirstOrThrow,
+  ${modelName}FindMany,
+  ${modelName}FindManyPaginated,
+  ${modelName}Create,
+  ${modelName}CreateMany,
+  ${modelName}CreateManyAndReturn,
+  ${modelName}Update,
+  ${modelName}UpdateMany,
+  ${modelName}UpdateManyAndReturn,
+  ${modelName}Upsert,
+  ${modelName}Delete,
+  ${modelName}DeleteMany,
+  ${modelName}Aggregate,
+  ${modelName}Count,
+  ${modelName}GroupBy
+} from './${modelName}Handlers'
+import type { RouteConfig } from '../routeConfig'
+import { parseQueryParams } from '../parseQueryParams'
+import { buildModelOpenApi } from '../buildModelOpenApi'
+
+const _env = typeof process !== 'undefined' && process.env ? process.env : {} as Record<string, string | undefined>
+
+const MODEL_FIELDS = ${JSON.stringify(fieldsMeta, null, 2)} as const
+
+const MODEL_ENUMS = ${JSON.stringify(enumsMeta, null, 2)} as const
+
+const defaultOpConfig = {
+  before: [] as RequestHandler[],
+  after: [] as RequestHandler[],
+}
+
+function normalizePrefix(p: string): string {
+  if (!p) return ''
+  let result = p
+  if (!result.startsWith('/')) result = '/' + result
+  while (result.length > 1 && result.endsWith('/')) result = result.slice(0, -1)
+  if (result === '/') return ''
+  return result
+}
+
+function transformResult(value: unknown): unknown {
+  if (value === null || value === undefined) return value
+  if (typeof value === 'bigint') return value.toString()
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
+    return value.toString('base64')
+  }
+  if (value instanceof Uint8Array) {
+    let binary = ''
+    for (let i = 0; i < value.length; i++) binary += String.fromCharCode(value[i])
+    return btoa(binary)
+  }
+  if (value instanceof Date) return value
+  if (Array.isArray(value)) return value.map(transformResult)
+  if (typeof value === 'object') {
+    const proto = Object.getPrototypeOf(value)
+    if (proto !== Object.prototype && proto !== null) return value
+    const out: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = transformResult(v)
+    }
+    return out
+  }
+  return value
+}
+
+function isQueryBuilderEnabled(config: RouteConfig): boolean {
+  if (config.queryBuilder === false) return false
+  if (typeof config.queryBuilder === 'object' && config.queryBuilder.enabled === false) return false
+  if (_env.NODE_ENV === 'production') return false
+  return true
+}
+
+function getQueryBuilderConfig(config: RouteConfig) {
+  if (config.queryBuilder === false) return null
+  if (typeof config.queryBuilder === 'object') return config.queryBuilder
+  return {}
+}
+
+export function ${routerFunctionName}(config: RouteConfig = {}) {
+  const router = express.Router()
+
+  router.use(express.json())
+
+  const customPrefix = normalizePrefix(config.customUrlPrefix || '')
+  const modelPrefix = config.addModelPrefix !== false ? '/${modelNameLower}' : ''
+  const basePath = customPrefix + modelPrefix
+
+  const openApiDisabled = config.disableOpenApi === true
+    || (config.disableOpenApi !== false && (
+      _env.DISABLE_OPENAPI === 'true'
+      || _env.NODE_ENV === 'production'
+    ))
+
+  const qbEnabled = isQueryBuilderEnabled(config)
+
+  if (qbEnabled) {
+    const qbConfig = getQueryBuilderConfig(config)
+    if (qbConfig) {
+      import('../queryBuilder').then(mod => mod.startQueryBuilder(qbConfig)).catch(() => {})
+    }
+  }
+
+  const parseQuery: RequestHandler = (req, res, next) => {
+    const rawQuery = req.query
+    if (rawQuery && Object.keys(rawQuery).length > 0) {
+      res.locals.parsedQuery = parseQueryParams(rawQuery as Record<string, unknown>)
+    }
+    next()
+  }
+
+  const setShape = (opConfig: any): RequestHandler => {
+    return (req, res, next) => {
+      res.locals.routeConfig = config
+      if (opConfig.shape) {
+        res.locals.guardShape = opConfig.shape
+        const caller = config.guard?.resolveVariant?.(req)
+          ?? req.get(config.guard?.variantHeader || 'x-api-variant')
+          ?? undefined
+        if (caller) {
+          res.locals.guardCaller = caller
+        }
+      }
+      next()
+    }
+  }
+
+  const respond: RequestHandler = (_req, res) => {
+    const data = res.locals.data
+    if (data === undefined) {
+      return res.status(500).json({ message: 'No data set by handler' })
+    }
+    return res.json(transformResult(data))
+  }
+
+  const respondCreated: RequestHandler = (_req, res) => {
+    const data = res.locals.data
+    if (data === undefined) {
+      return res.status(500).json({ message: 'No data set by handler' })
+    }
+    return res.status(201).json(transformResult(data))
+  }
+
+  if (!openApiDisabled) {
+    const openapiJsonPath = basePath ? \`\${basePath}/openapi.json\` : '/openapi.json'
+    const openapiYamlPath = basePath ? \`\${basePath}/openapi.yaml\` : '/openapi.yaml'
+
+    router.get(openapiJsonPath, (_req, res) => {
+      const spec = buildModelOpenApi(
+        '${modelName}',
+        MODEL_FIELDS as any,
+        MODEL_ENUMS as any,
+        config,
+        { format: 'json' }
+      )
+      res.json(spec)
+    })
+
+    router.get(openapiYamlPath, (_req, res) => {
+      const spec = buildModelOpenApi(
+        '${modelName}',
+        MODEL_FIELDS as any,
+        MODEL_ENUMS as any,
+        config,
+        { format: 'yaml' }
+      )
+      res.type('application/yaml').send(spec as string)
+    })
+  }
+
+  if (config.enableAll || config.findFirst) {
+    const opConfig = config.findFirst || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/first\` : '/first'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}FindFirst as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.findFirstOrThrow) {
+    const opConfig = config.findFirstOrThrow || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/first/strict\` : '/first/strict'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}FindFirstOrThrow as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.findManyPaginated) {
+    const opConfig = config.findManyPaginated || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/paginated\` : '/paginated'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}FindManyPaginated as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.aggregate) {
+    const opConfig = config.aggregate || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/aggregate\` : '/aggregate'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}Aggregate as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.count) {
+    const opConfig = config.count || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/count\` : '/count'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}Count as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.groupBy) {
+    const opConfig = config.groupBy || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/groupby\` : '/groupby'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}GroupBy as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.findUniqueOrThrow) {
+    const opConfig = config.findUniqueOrThrow || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/unique/strict\` : '/unique/strict'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}FindUniqueOrThrow as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.findUnique) {
+    const opConfig = config.findUnique || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/unique\` : '/unique'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}FindUnique as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.findMany) {
+    const opConfig = config.findMany || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath || '/'
+    router.get(path, parseQuery, setShape(opConfig), ...before, ${modelName}FindMany as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.createManyAndReturn) {
+    const opConfig = config.createManyAndReturn || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
+    router.post(path, setShape(opConfig), ...before, ${modelName}CreateManyAndReturn as RequestHandler, ...after, respondCreated)
+  }
+
+  if (config.enableAll || config.createMany) {
+    const opConfig = config.createMany || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/many\` : '/many'
+    router.post(path, setShape(opConfig), ...before, ${modelName}CreateMany as RequestHandler, ...after, respondCreated)
+  }
+
+  if (config.enableAll || config.create) {
+    const opConfig = config.create || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath || '/'
+    router.post(path, setShape(opConfig), ...before, ${modelName}Create as RequestHandler, ...after, respondCreated)
+  }
+
+  if (config.enableAll || config.updateManyAndReturn) {
+    const opConfig = config.updateManyAndReturn || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/many/return\` : '/many/return'
+    router.put(path, setShape(opConfig), ...before, ${modelName}UpdateManyAndReturn as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.updateMany) {
+    const opConfig = config.updateMany || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/many\` : '/many'
+    router.put(path, setShape(opConfig), ...before, ${modelName}UpdateMany as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.update) {
+    const opConfig = config.update || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath || '/'
+    router.put(path, setShape(opConfig), ...before, ${modelName}Update as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.upsert) {
+    const opConfig = config.upsert || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath || '/'
+    router.patch(path, setShape(opConfig), ...before, ${modelName}Upsert as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.deleteMany) {
+    const opConfig = config.deleteMany || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath ? \`\${basePath}/many\` : '/many'
+    router.delete(path, setShape(opConfig), ...before, ${modelName}DeleteMany as RequestHandler, ...after, respond)
+  }
+
+  if (config.enableAll || config.delete) {
+    const opConfig = config.delete || defaultOpConfig
+    const { before = [], after = [] } = opConfig
+    const path = basePath || '/'
+    router.delete(path, setShape(opConfig), ...before, ${modelName}Delete as RequestHandler, ...after, respond)
+  }
+
+  router.use((err: any, _req: Request, res: Response, next: NextFunction) => {
+    const status = typeof err.status === 'number' ? err.status : 500
+    const message = err.message || 'Internal server error'
+    if (!res.headersSent) {
+      return res.status(status).json({ message })
+    }
+    next(err)
+  })
+
+  return router
+}
+`
+}