prisma-generator-express 1.19.0 → 1.20.0

package/src/index.ts

@@ -0,0 +1,100 @@
+import {
+  generatorHandler,
+  GeneratorOptions,
+  DMMF,
+} from '@prisma/generator-helper'
+import { generateUnifiedHandler } from './generators/generateUnifiedHandler'
+import { generateRouterFunction } from './generators/generateRouter'
+import { generateScalarUIHandler } from './generators/generateUnifiedScalarUI'
+import { generateUnifiedDocs } from './generators/generateUnifiedDocs'
+import { generateQueryBuilderHelper } from './generators/generateQueryBuilderHelper'
+import {
+  generateImportPrismaStatement,
+  getRelativeClientPath,
+} from './generators/generateImportPrismaStatement'
+import { writeFileSafely } from './utils/writeFileSafely'
+import { copyFiles } from './utils/copyFiles'
+import { GENERATOR_NAME } from './constants'
+
+generatorHandler({
+  onManifest() {
+    return {
+      version: require('../package.json').version,
+      defaultOutput: '../generated',
+      prettyName: GENERATOR_NAME,
+    }
+  },
+
+  async onGenerate(options: GeneratorOptions) {
+    const prismaImportStatement = generateImportPrismaStatement(options)
+
+    console.log('\n═══ Prisma Generator Express ═══')
+
+    await copyFiles(options)
+
+    const modelNames: string[] = []
+
+    for (const model of options.dmmf.datamodel.models) {
+      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)
+
+      await writeFileSafely({
+        content: generateUnifiedHandler({
+          model: model as DMMF.Model,
+          prismaImportStatement,
+        }),
+        options,
+        model: model as DMMF.Model,
+        operation: 'Handlers',
+      })
+
+      await writeFileSafely({
+        content: generateRouterFunction({
+          model: model as DMMF.Model,
+          enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
+          relativeClientPath,
+        }),
+        options,
+        model: model as DMMF.Model,
+        operation: 'Router',
+      })
+
+      await writeFileSafely({
+        content: generateScalarUIHandler({
+          model: model as DMMF.Model,
+          enums: options.dmmf.datamodel.enums as DMMF.DatamodelEnum[],
+        }),
+        options,
+        model: model as DMMF.Model,
+        operation: 'Docs',
+      })
+    }
+
+    await writeFileSafely({
+      content: generateUnifiedDocs(modelNames),
+      options,
+      operation: 'combinedDocs',
+    })
+
+    await writeFileSafely({
+      content: generateQueryBuilderHelper(options),
+      options,
+      operation: 'queryBuilder',
+    })
+
+    console.log('\n═══ Generation Complete ═══')
+    console.log(`✓ ${modelNames.length} models`)
+    console.log(`✓ OpenAPI documentation generated`)
+    console.log(`✓ Query builder helper generated`)
+    console.log('')
+  },
+})

package/src/utils/copyFiles.ts

@@ -0,0 +1,134 @@
+import { GeneratorOptions } from '@prisma/generator-helper'
+import * as fs from 'fs'
+import * as path from 'path'
+
+export interface CopyFilesConfig {
+  includeCacheUtils?: boolean
+  includeValidatorUtils?: boolean
+}
+
+export async function copyFiles(
+  options: GeneratorOptions,
+  config?: CopyFilesConfig,
+): Promise<void> {
+  const copyConfig = config || {}
+  const outputPath = options.generator.output?.value
+  if (!outputPath) return
+
+  const srcDir = path.join(__dirname, '..', '..', 'src', 'copy')
+
+  const baseFiles = [
+    'routeConfig.ts',
+    'parseQueryParams.ts',
+    'buildModelOpenApi.ts',
+    'operationDefinitions.ts',
+    'misc.ts',
+  ]
+
+  let allCopied = true
+
+  console.log(`Copying utility files to: ${outputPath}`)
+
+  for (const file of baseFiles) {
+    const ok = await copyFile(srcDir, outputPath, file, { required: true })
+    if (!ok) allCopied = false
+  }
+
+  if (copyConfig.includeCacheUtils) {
+    const ok = await copyFile(srcDir, outputPath, 'cacheManager.ts', {
+      required: true,
+    })
+    if (!ok) allCopied = false
+  }
+
+  if (copyConfig.includeValidatorUtils) {
+    const ok = await copyFile(srcDir, outputPath, 'inputValidator.ts', {
+      required: true,
+    })
+    if (!ok) allCopied = false
+  }
+
+  const clientDir = path.join(outputPath, 'client')
+  if (!fs.existsSync(clientDir)) {
+    fs.mkdirSync(clientDir, { recursive: true })
+  }
+
+  const clientSrcDir = path.join(__dirname, '..', '..', 'src', 'client')
+  const clientOk = await copyFile(
+    clientSrcDir,
+    clientDir,
+    'encodeQueryParams.ts',
+    {
+      required: true,
+      importRewrites: [{ from: '../copy/misc', to: '../misc' }],
+    },
+  )
+  if (!clientOk) allCopied = false
+
+  if (allCopied) {
+    console.log(`✓ Utility files copied successfully`)
+  } else {
+    throw new Error(
+      'One or more required utility files could not be copied. Generation aborted.',
+    )
+  }
+}
+
+interface CopyFileOptions {
+  required?: boolean
+  importRewrites?: Array<{ from: string; to: string }>
+}
+
+async function copyFile(
+  srcDir: string,
+  destDir: string,
+  filename: string,
+  options?: CopyFileOptions,
+): Promise<boolean> {
+  const srcPath = path.join(srcDir, filename)
+  const destPath = path.join(destDir, filename)
+
+  if (!fs.existsSync(srcPath)) {
+    if (options?.required) {
+      console.error(`✗ Required source file not found: ${srcPath}`)
+      return false
+    }
+    console.warn(`⚠️  Source file not found: ${srcPath}`)
+    return true
+  }
+
+  const destDirPath = path.dirname(destPath)
+  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}'`,
+      )
+    }
+  }
+
+  const header = `/**
+ * Auto-generated by prisma-generator-express
+ * DO NOT EDIT MANUALLY
+ */
+
+`
+
+  if (!content.startsWith('/**')) {
+    content = header + content
+  }
+
+  fs.writeFileSync(destPath, content)
+  console.log(`  ✓ Copied: ${filename}`)
+  return true
+}
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/src/utils/strings.ts

@@ -0,0 +1,7 @@
+export const capitalize = (str: string) =>
+  str.charAt(0).toUpperCase() + str.slice(1)
+
+export function toPascalCase(str: string) {
+  if (!str) return str
+  return str.charAt(0).toLowerCase() + str.slice(1)
+}

package/src/utils/writeFileSafely.ts

@@ -0,0 +1,83 @@
+import { GeneratorOptions } from '@prisma/generator-helper'
+import { DMMF } from '@prisma/generator-helper'
+import * as fs from 'fs'
+import * as path from 'path'
+import prettier from 'prettier'
+
+interface WriteFileOptions {
+  content: string
+  options: GeneratorOptions
+  model?: DMMF.Model
+  operation: string
+}
+
+let _prettierOptions: prettier.Options | null | undefined
+
+async function getPrettierOptions(): Promise<prettier.Options | null> {
+  if (_prettierOptions !== undefined) return _prettierOptions
+  _prettierOptions = await prettier.resolveConfig(process.cwd())
+  return _prettierOptions
+}
+
+export async function writeFileSafely({
+  content,
+  options,
+  model,
+  operation,
+}: WriteFileOptions): Promise<void> {
+  const outputPath = options.generator.output?.value
+  if (!outputPath) {
+    throw new Error('Output path not defined')
+  }
+
+  let filePath: string
+
+  switch (operation) {
+    case 'cacheConfig':
+      filePath = path.join(outputPath, 'cacheConfig.ts')
+      break
+
+    case 'types/inputs':
+      filePath = path.join(outputPath, 'types', 'inputs.ts')
+      break
+
+    case 'combinedDocs':
+      filePath = path.join(outputPath, 'combinedDocs.ts')
+      break
+
+    case 'queryBuilder':
+      filePath = path.join(outputPath, 'queryBuilder.ts')
+      break
+
+    default:
+      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 })
+  }
+
+  let formattedContent: string
+  try {
+    const resolvedOptions = await getPrettierOptions()
+    formattedContent = await prettier.format(content, {
+      ...resolvedOptions,
+      parser: 'typescript',
+    })
+  } catch (error) {
+    console.warn(
+      `⚠️  Prettier formatting failed for ${path.basename(filePath)}, writing unformatted`,
+    )
+    formattedContent = content
+  }
+
+  fs.writeFileSync(filePath, formattedContent)
+}