prisma-generator-express 1.40.0 → 1.41.0

package/src/generators/generateUnifiedDocs.ts

@@ -1,11 +1,16 @@
 import { Target } from '../constants'
+import { ImportStyle } from '../utils/resolveImportStyle'
+import { importExt } from '../utils/importExt'
 
 export function generateUnifiedDocs(
   models: string[],
   target: Target = 'express',
+  importStyle: ImportStyle = 'none',
 ): string {
+  const ext = importExt(importStyle)
+
   const imports = models
-    .map((model) => `import { ${model}Docs } from './${model}/${model}Docs'`)
+    .map((model) => `import { ${model}Docs } from './${model}/${model}Docs${ext}'`)
     .join('\n')
 
   const handlersEntries = models
@@ -17,9 +22,9 @@ export function generateUnifiedDocs(
       ? `import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify'`
       : target === 'hono'
         ? `import type { Hono, Context } from 'hono'`
-        : `import { Request, Response } from 'express'`
+        : `import type { Request, Response } from 'express'`
 
-  const routeConfigImport = `import type { RouteConfig } from './routeConfig.target'`
+  const routeConfigImport = `import type { RouteConfig } from './routeConfig.target${ext}'`
 
   const handlerType =
     target === 'fastify'

package/src/index.ts

@@ -1,8 +1,4 @@
-import {
-  generatorHandler,
-  GeneratorOptions,
-  DMMF,
-} from '@prisma/generator-helper'
+import { generatorHandler, GeneratorOptions, DMMF } from '@prisma/generator-helper'
 import path from 'path'
 import { generateUnifiedHandler } from './generators/generateUnifiedHandler'
 import { generateFastifyHandler } from './generators/generateFastifyHandler'
@@ -13,26 +9,17 @@ import { generateHonoRouterFunction } from './generators/generateRouterHono'
 import { generateScalarUIHandler } from './generators/generateUnifiedScalarUI'
 import { generateUnifiedDocs } from './generators/generateUnifiedDocs'
 import { generateQueryBuilderHelper } from './generators/generateQueryBuilderHelper'
-import {
-  generateOperationRuntime,
-  generateModelCore,
-} from './generators/generateOperationCore'
-import {
-  getRelativeClientPath,
-  getGuardShapesImport,
-} from './generators/generateImportPrismaStatement'
+import { generateOperationRuntime, generateModelCore } from './generators/generateOperationCore'
+import { getRelativeClientPath, getGuardShapesImport } from './generators/generateImportPrismaStatement'
 import { writeFileSafely } from './utils/writeFileSafely'
 import { copyFiles } from './utils/copyFiles'
+import { resolveImportStyle } from './utils/resolveImportStyle'
 import { GENERATOR_NAME, Target } from './constants'
 
 function getTarget(options: GeneratorOptions): Target {
-  const raw = String(
-    (options.generator.config as Record<string, unknown>).target ?? 'express',
-  ).toLowerCase()
+  const raw = String((options.generator.config as Record<string, unknown>).target ?? 'express').toLowerCase()
   if (raw === 'express' || raw === 'fastify' || raw === 'hono') return raw
-  throw new Error(
-    `Invalid target "${raw}". Expected "express", "fastify", or "hono".`,
-  )
+  throw new Error(`Invalid target "${raw}". Expected "express", "fastify", or "hono".`)
 }
 
 generatorHandler({
@@ -46,7 +33,6 @@ generatorHandler({
 
   async onGenerate(options: GeneratorOptions) {
     const target = getTarget(options)
-
     const hasExplicitOutput = !!options.generator.output?.fromEnvVar
       || (options.generator.config as Record<string, unknown>).output !== undefined
 
@@ -56,52 +42,46 @@ generatorHandler({
       options.generator.output = { value: outputPath, fromEnvVar: null }
     }
 
+    const importStyle = resolveImportStyle(options)
+
     console.log(`\n═══ Prisma Generator (${target.toUpperCase()}) ═══`)
     console.log(`  Target: ${target}`)
     console.log(`  Output: ${options.generator.output?.value}`)
+    console.log(`  Import style: ${importStyle}`)
 
-    await copyFiles(options, target)
+    await copyFiles(options, target, importStyle)
 
     await writeFileSafely({
-      content: generateOperationRuntime(),
+      content: generateOperationRuntime(importStyle),
       options,
       operation: 'operationRuntime',
     })
 
     const modelNames: string[] = []
-
     const generateHandler =
-      target === 'fastify'
-        ? generateFastifyHandler
-        : target === 'hono'
-          ? generateHonoHandler
-          : generateUnifiedHandler
+      target === 'fastify' ? generateFastifyHandler :
+      target === 'hono' ? generateHonoHandler :
+      generateUnifiedHandler
 
     for (const model of options.dmmf.datamodel.models) {
-      if (
-        model.documentation &&
-        model.documentation.includes('generator off')
-      ) {
+      if (model.documentation && model.documentation.includes('generator off')) {
         console.log(`  Skipping: ${model.name} (generator off)`)
         continue
       }
-
       modelNames.push(model.name)
 
       const relativeClientPath = getRelativeClientPath(options, model.name)
       const guardShapesImport = getGuardShapesImport(options, model.name)
 
       await writeFileSafely({
-        content: generateModelCore({ model: model as DMMF.Model }),
+        content: generateModelCore({ model: model as DMMF.Model, importStyle }),
         options,
         model: model as DMMF.Model,
         operation: 'Core',
       })
 
       await writeFileSafely({
-        content: generateHandler({
-          model: model as DMMF.Model,
-        }),
+        content: generateHandler({ model: model as DMMF.Model, importStyle } as any),
         options,
         model: model as DMMF.Model,
         operation: 'Handlers',
@@ -113,18 +93,21 @@ generatorHandler({
               model: model as DMMF.Model,
               enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
               guardShapesImport,
-            })
+              importStyle,
+            } as any)
           : target === 'hono'
             ? generateHonoRouterFunction({
                 model: model as DMMF.Model,
                 enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
                 guardShapesImport,
-              })
+                importStyle,
+              } as any)
             : generateRouterFunction({
                 model: model as DMMF.Model,
                 enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
                 relativeClientPath,
                 guardShapesImport,
+                importStyle,
               })
 
       await writeFileSafely({
@@ -139,7 +122,8 @@ generatorHandler({
           model: model as DMMF.Model,
           enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
           target,
-        }),
+          importStyle,
+        } as any),
         options,
         model: model as DMMF.Model,
         operation: 'Docs',
@@ -147,7 +131,7 @@ generatorHandler({
     }
 
     await writeFileSafely({
-      content: generateUnifiedDocs(modelNames, target),
+      content: generateUnifiedDocs(modelNames, target, importStyle),
       options,
       operation: 'combinedDocs',
     })
@@ -160,12 +144,6 @@ generatorHandler({
 
     console.log('\n═══ Generation Complete ═══')
     console.log(`✓ ${modelNames.length} models (${target})`)
-    console.log(`✓ OpenAPI documentation generated`)
-    if (target === 'hono') {
-      console.log(`✓ Query builder helper generated (not auto-started for Hono)`)
-    } else {
-      console.log(`✓ Query builder helper generated`)
-    }
     console.log('')
   },
 })

package/src/utils/copyFiles.ts

@@ -2,6 +2,8 @@ import { GeneratorOptions } from '@prisma/generator-helper'
 import * as fs from 'fs'
 import * as path from 'path'
 import { Target } from '../constants'
+import { ImportStyle } from './resolveImportStyle'
+import { importExt } from './importExt'
 
 const SHARED_FILES = [
   'parseQueryParams.ts',
@@ -21,17 +23,11 @@ interface CopyFileOptions {
 function resolveTemplateDir(subpath: string): string {
   const fromSrc = path.join(__dirname, '..', '..', 'src', subpath)
   if (fs.existsSync(fromSrc)) return fromSrc
-
   const fromDist = path.join(__dirname, '..', subpath)
   if (fs.existsSync(fromDist)) return fromDist
-
   throw new Error(
-    `Template directory "${subpath}" not found.\n` +
-    `  Searched:\n` +
-    `    ${fromSrc}\n` +
-    `    ${fromDist}\n` +
-    `  __dirname: ${__dirname}\n` +
-    `  Ensure template files are included in the published package.`,
+    'Template directory "' + subpath + '" not found.\n  Searched:\n    ' +
+    fromSrc + '\n    ' + fromDist + '\n  __dirname: ' + __dirname,
   )
 }
 
@@ -39,10 +35,26 @@ function escapeRegex(str: string): string {
   return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }
 
+const RELATIVE_IMPORT_RE =
+  /(\b(?:import|export)\b[^'"\n;]*?\bfrom\s+|\bimport\s+|\bimport\s*\(\s*)(['"])(\.{1,2}\/[^'"\n]+)\2/g
+
+const SKIP_EXTENSION_RE = /\.(m?[jt]sx?|json|css|svg|png|jpe?g|gif|webp|wasm)$/i
+
+function applyExtension(content: string, style: ImportStyle): string {
+  if (style === 'none') return content
+  const ext = importExt(style)
+  if (!ext) return content
+  return content.replace(RELATIVE_IMPORT_RE, (_match, prefix, quote, spec) => {
+    if (SKIP_EXTENSION_RE.test(spec)) return prefix + quote + spec + quote
+    return prefix + quote + spec + ext + quote
+  })
+}
+
 function copyFileSync(
   srcDir: string,
   destDir: string,
   filename: string,
+  importStyle: ImportStyle,
   options?: CopyFileOptions,
 ): string | null {
   const srcPath = path.join(srcDir, filename)
@@ -50,38 +62,33 @@ function copyFileSync(
   const destPath = path.join(destDir, destFilename)
 
   if (!fs.existsSync(srcPath)) {
-    if (options?.required) {
-      return `Required file not found: ${srcPath}`
-    }
+    if (options?.required) return 'Required file not found: ' + srcPath
     return null
   }
 
   const destDirPath = path.dirname(destPath)
-  if (!fs.existsSync(destDirPath)) {
-    fs.mkdirSync(destDirPath, { recursive: true })
-  }
+  if (!fs.existsSync(destDirPath)) fs.mkdirSync(destDirPath, { recursive: true })
 
   let content = fs.readFileSync(srcPath, 'utf-8')
 
   if (options?.importRewrites) {
     for (const rewrite of options.importRewrites) {
       content = content.replace(
-        new RegExp(`from ['"]${escapeRegex(rewrite.from)}['"]`, 'g'),
-        `from '${rewrite.to}'`,
+        new RegExp('from [\'"]' + escapeRegex(rewrite.from) + '[\'"]', 'g'),
+        "from '" + rewrite.to + "'",
       )
     }
   }
 
-  const header = `/**
- * Auto-generated by prisma-generator-express
- * DO NOT EDIT MANUALLY
- */
+  const header =
+    '/**\n' +
+    ' * Auto-generated by prisma-generator-express\n' +
+    ' * DO NOT EDIT MANUALLY\n' +
+    ' */\n\n'
 
-`
+  if (!content.startsWith('/**')) content = header + content
 
-  if (!content.startsWith('/**')) {
-    content = header + content
-  }
+  content = applyExtension(content, importStyle)
 
   fs.writeFileSync(destPath, content)
   return null
@@ -90,6 +97,7 @@ function copyFileSync(
 export async function copyFiles(
   options: GeneratorOptions,
   target: Target,
+  importStyle: ImportStyle,
 ): Promise<void> {
   const outputPath = options.generator.output?.value
   if (!outputPath) return
@@ -97,15 +105,15 @@ export async function copyFiles(
   const copyBase = resolveTemplateDir('copy')
   const errors: string[] = []
 
-  console.log(`  Copying utility files to: ${outputPath} (target: ${target})`)
+  console.log('  Copying utility files to: ' + outputPath + ' (target: ' + target + ')')
 
   for (const file of SHARED_FILES) {
-    const err = copyFileSync(copyBase, outputPath, file, { required: true })
+    const err = copyFileSync(copyBase, outputPath, file, importStyle, { required: true })
     if (err) errors.push(err)
   }
 
-  const targetConfigFile = `routeConfig.${target}.ts`
-  const err = copyFileSync(copyBase, outputPath, targetConfigFile, {
+  const targetConfigFile = 'routeConfig.' + target + '.ts'
+  const err = copyFileSync(copyBase, outputPath, targetConfigFile, importStyle, {
     required: true,
     destFilename: 'routeConfig.target.ts',
     importRewrites: [{ from: './routeConfig', to: './routeConfig' }],
@@ -113,30 +121,22 @@ export async function copyFiles(
   if (err) errors.push(err)
 
   const clientDir = path.join(outputPath, 'client')
-  if (!fs.existsSync(clientDir)) {
-    fs.mkdirSync(clientDir, { recursive: true })
-  }
+  if (!fs.existsSync(clientDir)) fs.mkdirSync(clientDir, { recursive: true })
 
   const clientSrcDir = resolveTemplateDir('client')
-  const clientErr = copyFileSync(
-    clientSrcDir,
-    clientDir,
-    'encodeQueryParams.ts',
-    {
-      required: true,
-      importRewrites: [{ from: '../copy/misc', to: '../misc' }],
-    },
-  )
+  const clientErr = copyFileSync(clientSrcDir, clientDir, 'encodeQueryParams.ts', importStyle, {
+    required: true,
+    importRewrites: [{ from: '../copy/misc', to: '../misc' }],
+  })
   if (clientErr) errors.push(clientErr)
 
   if (errors.length > 0) {
     throw new Error(
-      `Failed to copy ${errors.length} required file(s):\n` +
-      errors.map((e) => `  - ${e}`).join('\n') +
-      `\n  copyBase: ${copyBase}` +
-      `\n  __dirname: ${__dirname}`,
+      'Failed to copy ' + errors.length + ' required file(s):\n' +
+      errors.map((e) => '  - ' + e).join('\n') +
+      '\n  copyBase: ' + copyBase + '\n  __dirname: ' + __dirname,
     )
   }
 
-  console.log(`  ✓ Utility files copied successfully`)
+  console.log('  ✓ Utility files copied successfully')
 }

package/src/utils/importExt.ts

@@ -0,0 +1,7 @@
+import { ImportStyle } from './resolveImportStyle'
+
+export function importExt(style: ImportStyle): string {
+  if (style === 'js') return '.js'
+  if (style === 'ts') return '.ts'
+  return ''
+}

package/src/utils/resolveImportStyle.ts

@@ -0,0 +1,187 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import type { GeneratorOptions } from '@prisma/generator-helper'
+
+export type ImportStyle = 'none' | 'js' | 'ts'
+
+const VALID_OVERRIDES = new Set(['auto', 'none', 'js', 'ts'])
+const NODE_MODULE_KEYWORDS = new Set(['node16', 'node18', 'nodenext'])
+
+function stripJsonComments(input: string): string {
+  let out = ''
+  let i = 0
+  let inString = false
+  let stringChar = ''
+  while (i < input.length) {
+    const c = input[i]
+    const next = input[i + 1]
+    if (inString) {
+      out += c
+      if (c === '\\' && i + 1 < input.length) {
+        out += input[i + 1]
+        i += 2
+        continue
+      }
+      if (c === stringChar) inString = false
+      i++
+      continue
+    }
+    if (c === '"' || c === "'") {
+      inString = true
+      stringChar = c
+      out += c
+      i++
+      continue
+    }
+    if (c === '/' && next === '/') {
+      while (i < input.length && input[i] !== '\n') i++
+      continue
+    }
+    if (c === '/' && next === '*') {
+      i += 2
+      while (i < input.length && !(input[i] === '*' && input[i + 1] === '/')) i++
+      i += 2
+      continue
+    }
+    out += c
+    i++
+  }
+  return out.replace(/,\s*(?=[\]}])/g, '')
+}
+
+function findUpwards(startDir: string, filename: string): string | null {
+  let dir = path.resolve(startDir)
+  const root = path.parse(dir).root
+  let result: string | null = null
+  let stop = false
+  while (!stop) {
+    const candidate = path.join(dir, filename)
+    if (fs.existsSync(candidate)) {
+      result = candidate
+      stop = true
+      break
+    }
+    if (dir === root) {
+      stop = true
+      break
+    }
+    const parent = path.dirname(dir)
+    if (parent === dir) {
+      stop = true
+      break
+    }
+    dir = parent
+  }
+  return result
+}
+
+function resolveExtendsTarget(extendsValue: string, fromFile: string): string | null {
+  const fromDir = path.dirname(fromFile)
+  if (extendsValue.startsWith('.') || path.isAbsolute(extendsValue)) {
+    const direct = path.resolve(fromDir, extendsValue)
+    if (fs.existsSync(direct) && fs.statSync(direct).isFile()) return direct
+    const withExt = direct + '.json'
+    if (fs.existsSync(withExt)) return withExt
+    const asIndex = path.join(direct, 'tsconfig.json')
+    if (fs.existsSync(asIndex)) return asIndex
+    return null
+  }
+  try {
+    return require.resolve(extendsValue, { paths: [fromDir] })
+  } catch {
+    try {
+      return require.resolve(extendsValue + '/tsconfig.json', { paths: [fromDir] })
+    } catch {
+      return null
+    }
+  }
+}
+
+type TsConfigRaw = {
+  extends?: string | string[]
+  compilerOptions?: Record<string, unknown>
+}
+
+function readTsConfig(filePath: string, seen: Set<string> = new Set()): Record<string, unknown> {
+  const abs = path.resolve(filePath)
+  if (seen.has(abs)) return {}
+  seen.add(abs)
+
+  let parsed: TsConfigRaw
+  try {
+    const raw = fs.readFileSync(abs, 'utf-8')
+    parsed = JSON.parse(stripJsonComments(raw)) as TsConfigRaw
+  } catch {
+    return {}
+  }
+
+  const extendsList: string[] = Array.isArray(parsed.extends)
+    ? parsed.extends
+    : parsed.extends
+      ? [parsed.extends]
+      : []
+
+  let merged: Record<string, unknown> = {}
+  for (const ext of extendsList) {
+    const target = resolveExtendsTarget(ext, abs)
+    if (target) merged = { ...merged, ...readTsConfig(target, seen) }
+  }
+  if (parsed.compilerOptions) merged = { ...merged, ...parsed.compilerOptions }
+  return merged
+}
+
+function readPackageType(startDir: string): string | null {
+  const pkgPath = findUpwards(startDir, 'package.json')
+  if (!pkgPath) return null
+  try {
+    const json = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'))
+    return typeof json.type === 'string' ? json.type : null
+  } catch {
+    return null
+  }
+}
+
+export function resolveImportStyle(options: GeneratorOptions): ImportStyle {
+  const config = (options.generator.config || {}) as Record<string, string>
+  const raw = typeof config.importStyle === 'string'
+    ? config.importStyle.toLowerCase()
+    : 'auto'
+
+  if (!VALID_OVERRIDES.has(raw)) {
+    console.warn(
+      '[prisma-generator-express] Invalid importStyle "' + config.importStyle +
+      '". Expected one of: auto, none, js, ts. Falling back to auto.',
+    )
+  } else if (raw !== 'auto') {
+    return raw as ImportStyle
+  }
+
+  const outputPath = options.generator.output?.value
+  const schemaDir = options.schemaPath ? path.dirname(options.schemaPath) : process.cwd()
+  const startDir = outputPath ? path.dirname(outputPath) : schemaDir
+
+  const tsconfigPath =
+    findUpwards(startDir, 'tsconfig.json') ||
+    findUpwards(schemaDir, 'tsconfig.json')
+
+  const compilerOptions: Record<string, unknown> = tsconfigPath
+    ? readTsConfig(tsconfigPath)
+    : {}
+
+  if (compilerOptions.allowImportingTsExtensions === true) return 'ts'
+
+  const moduleVal = String(compilerOptions.module ?? '').toLowerCase()
+  const moduleResolution = String(compilerOptions.moduleResolution ?? '').toLowerCase()
+
+  if (NODE_MODULE_KEYWORDS.has(moduleVal) || NODE_MODULE_KEYWORDS.has(moduleResolution)) {
+    return 'js'
+  }
+  if (moduleResolution === 'bundler' || moduleResolution === 'classic' || moduleResolution === 'node') {
+    return 'none'
+  }
+
+  const pkgType = readPackageType(startDir) || readPackageType(schemaDir)
+  if (pkgType === 'module') return 'js'
+
+  return 'none'
+}

package/src/utils/writeFileSafely.ts

@@ -26,40 +26,26 @@ export async function writeFileSafely({
   operation,
 }: WriteFileOptions): Promise<void> {
   const outputPath = options.generator.output?.value
-  if (!outputPath) {
-    throw new Error('Output path not defined')
-  }
+  if (!outputPath) throw new Error('Output path not defined')
 
   let filePath: string
-
   switch (operation) {
     case 'combinedDocs':
       filePath = path.join(outputPath, 'combinedDocs.ts')
       break
-
     case 'queryBuilder':
       filePath = path.join(outputPath, 'queryBuilder.ts')
       break
-
     case 'operationRuntime':
       filePath = path.join(outputPath, 'operationRuntime.ts')
       break
-
     default:
-      if (!model) {
-        throw new Error(`Model required for operation: ${operation}`)
-      }
-      filePath = path.join(
-        outputPath,
-        model.name,
-        `${model.name}${operation}.ts`,
-      )
+      if (!model) throw new Error('Model required for operation: ' + operation)
+      filePath = path.join(outputPath, model.name, `${model.name}${operation}.ts`)
   }
 
   const dirPath = path.dirname(filePath)
-  if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true })
-  }
+  if (!fs.existsSync(dirPath)) fs.mkdirSync(dirPath, { recursive: true })
 
   let formattedContent: string
   try {
@@ -68,10 +54,8 @@ export async function writeFileSafely({
       ...resolvedOptions,
       parser: 'typescript',
     })
-  } catch (error) {
-    console.warn(
-      `⚠️  Prettier formatting failed for ${path.basename(filePath)}, writing unformatted`,
-    )
+  } catch {
+    console.warn('⚠️  Prettier formatting failed for ' + path.basename(filePath) + ', writing unformatted')
     formattedContent = content
   }