prisma-generator-express 1.18.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

@@ -1,27 +1,134 @@
 import { GeneratorOptions } from '@prisma/generator-helper'
-import fs from 'fs/promises'
-import path from 'path'
+import * as fs from 'fs'
+import * as path from 'path'
 
-export const copyFiles = async (
+export interface CopyFilesConfig {
+  includeCacheUtils?: boolean
+  includeValidatorUtils?: boolean
+}
+
+export async function copyFiles(
   options: GeneratorOptions,
-  destPath?: string,
-) => {
-  const sourceDir = path.join(__dirname.replace('dist', 'src'), '..', 'copy')
-  const destinationDir = destPath || options.generator.output?.value!
+  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',
+  ]
 
-  const files = await fs.readdir(sourceDir)
+  let allCopied = true
 
-  for (const file of files) {
-    if (file.endsWith('.spec.ts')) {
-      continue
+  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
+ */
 
-    const sourceFile = path.join(sourceDir, file)
-    const destinationFile = path.join(destinationDir, file)
+`
 
-    await fs.mkdir(path.dirname(destinationFile), { recursive: true })
-    await fs.copyFile(sourceFile, destinationFile)
+  if (!content.startsWith('/**')) {
+    content = header + content
   }
 
-  console.log(`Files copied from ${sourceDir} to ${destinationDir}`)
+  fs.writeFileSync(destPath, content)
+  console.log(`  ✓ Copied: ${filename}`)
+  return true
 }
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/src/utils/writeFileSafely.ts

@@ -1,29 +1,83 @@
-import fs from 'fs/promises'
-import path from 'path'
-import { formatFile } from './formatFile'
-import { DMMF, GeneratorOptions } from '@prisma/generator-helper'
+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'
 
-export const writeFileSafely = async ({
-  model,
-  operation,
-  options,
-  content,
-}: {
+interface WriteFileOptions {
+  content: string
+  options: GeneratorOptions
   model?: DMMF.Model
   operation: string
-  options: GeneratorOptions
-  content: string
-}) => {
-  const fileName =
-    operation === 'index' ? 'index' : `${model?.name || ''}${operation}`
-  const filePath = path.join(
-    options.generator.output?.value!,
-    model ? `${model?.name}/${fileName}.ts` : `/${fileName}.ts`,
-  )
-  console.log('filePath :>> ', filePath)
-  await fs.mkdir(path.dirname(filePath), {
-    recursive: true,
-  })
-
-  await fs.writeFile(filePath, await formatFile(content))
+}
+
+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)
 }

package/dist/generator.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const generator_helper_1 = require("@prisma/generator-helper");
-const sdk_1 = require("@prisma/sdk");
-const constants_1 = require("./constants");
-const writeFileSafely_1 = require("./utils/writeFileSafely");
-const generateImportPrismaStatement_1 = require("./helpers/generateImportPrismaStatement");
-const generateRouteFile_1 = require("./helpers/generateRouteFile");
-const generateOperation_1 = require("./helpers/generateOperation");
-const copyFiles_1 = require("./utils/copyFiles");
-const { version } = require('../package.json');
-(0, generator_helper_1.generatorHandler)({
-    onManifest() {
-        sdk_1.logger.info(`${constants_1.GENERATOR_NAME}:Registered`);
-        return {
-            version,
-            defaultOutput: '../generated',
-            prettyName: constants_1.GENERATOR_NAME,
-        };
-    },
-    onGenerate: async (options) => {
-        const prismaImportStatement = (0, generateImportPrismaStatement_1.generateImportPrismaStatement)(options);
-        for await (const model of options.dmmf.datamodel.models) {
-            if (model.documentation &&
-                model.documentation.includes('generator off')) {
-                sdk_1.logger.info(`Skipping generation for model ${model.name} as it is marked with 'generator off'.`);
-                continue;
-            }
-            for (const cfg of generateOperation_1.OPERATION_CONFIGS) {
-                await (0, writeFileSafely_1.writeFileSafely)({
-                    content: (0, generateOperation_1.generateOperationFunction)(cfg, model, prismaImportStatement),
-                    options,
-                    model,
-                    operation: cfg.operation,
-                });
-            }
-            await (0, writeFileSafely_1.writeFileSafely)({
-                content: (0, generateRouteFile_1.generateRouterFunction)({ model }),
-                options,
-                model,
-                operation: 'index',
-            });
-        }
-        await (0, copyFiles_1.copyFiles)(options);
-    },
-});
-//# sourceMappingURL=generator.js.map

package/dist/generator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generator.js","sourceRoot":"","sources":["../src/generator.ts"],"names":[],"mappings":";;AAAA,+DAA6E;AAC7E,qCAAoC;AACpC,2CAA4C;AAC5C,6DAAyD;AACzD,2FAAuF;AACvF,mEAAoE;AACpE,mEAA0F;AAC1F,iDAA6C;AAE7C,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAA;AAE9C,IAAA,mCAAgB,EAAC;IACf,UAAU;QACR,YAAM,CAAC,IAAI,CAAC,GAAG,0BAAc,aAAa,CAAC,CAAA;QAC3C,OAAO;YACL,OAAO;YACP,aAAa,EAAE,cAAc;YAC7B,UAAU,EAAE,0BAAc;SAC3B,CAAA;IACH,CAAC;IACD,UAAU,EAAE,KAAK,EAAE,OAAyB,EAAE,EAAE;QAC9C,MAAM,qBAAqB,GAAG,IAAA,6DAA6B,EAAC,OAAO,CAAC,CAAA;QAEpE,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;YACxD,IACE,KAAK,CAAC,aAAa;gBACnB,KAAK,CAAC,aAAa,CAAC,QAAQ,CAAC,eAAe,CAAC,EAC7C,CAAC;gBACD,YAAM,CAAC,IAAI,CACT,iCAAiC,KAAK,CAAC,IAAI,wCAAwC,CACpF,CAAA;gBACD,SAAQ;YACV,CAAC;YAED,KAAK,MAAM,GAAG,IAAI,qCAAiB,EAAE,CAAC;gBACpC,MAAM,IAAA,iCAAe,EAAC;oBACpB,OAAO,EAAE,IAAA,6CAAyB,EAAC,GAAG,EAAE,KAAK,EAAE,qBAAqB,CAAC;oBACrE,OAAO;oBACP,KAAK;oBACL,SAAS,EAAE,GAAG,CAAC,SAAS;iBACzB,CAAC,CAAA;YACJ,CAAC;YAED,MAAM,IAAA,iCAAe,EAAC;gBACpB,OAAO,EAAE,IAAA,0CAAsB,EAAC,EAAE,KAAK,EAAE,CAAC;gBAC1C,OAAO;gBACP,KAAK;gBACL,SAAS,EAAE,OAAO;aACnB,CAAC,CAAA;QACJ,CAAC;QAED,MAAM,IAAA,qBAAS,EAAC,OAAO,CAAC,CAAA;IAC1B,CAAC;CACF,CAAC,CAAA"}

package/dist/helpers/generateImportPrismaStatement.js

@@ -1,25 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportPrismaStatement = generateImportPrismaStatement;
-const path_1 = __importDefault(require("path"));
-function getImportGeneratorOptions(options) {
-    var _a, _b;
-    const clientGenerator = options.otherGenerators.find((gen) => gen.name === 'client');
-    if (!clientGenerator || !((_a = clientGenerator.output) === null || _a === void 0 ? void 0 : _a.value)) {
-        throw new Error('Prisma client generator not found.');
-    }
-    const modelDirPath = path_1.default.join((_b = options.generator.output) === null || _b === void 0 ? void 0 : _b.value, 'modelFolder');
-    const clientOutputPath = clientGenerator.output.value;
-    const relativeImportPath = path_1.default.relative(modelDirPath, clientOutputPath);
-    return {
-        outputPath: relativeImportPath.split(path_1.default.sep).join(path_1.default.posix.sep),
-    };
-}
-function generateImportPrismaStatement(generatorOptions) {
-    const options = getImportGeneratorOptions(generatorOptions);
-    return `import type { Prisma } from '${options.outputPath}';\nimport type { PrismaClient } from '${options.outputPath}';\n`;
-}
-//# sourceMappingURL=generateImportPrismaStatement.js.map

package/dist/helpers/generateImportPrismaStatement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateImportPrismaStatement.js","sourceRoot":"","sources":["../../src/helpers/generateImportPrismaStatement.ts"],"names":[],"mappings":";;;;;AA+BA,sEAMC;AApCD,gDAAuB;AAMvB,SAAS,yBAAyB,CAChC,OAAyB;;IAEzB,MAAM,eAAe,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,CAClD,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,KAAK,QAAQ,CAC/B,CAAA;IAED,IAAI,CAAC,eAAe,IAAI,CAAC,CAAA,MAAA,eAAe,CAAC,MAAM,0CAAE,KAAK,CAAA,EAAE,CAAC;QACvD,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAA;IACvD,CAAC;IAED,MAAM,YAAY,GAAG,cAAI,CAAC,IAAI,CAC5B,MAAA,OAAO,CAAC,SAAS,CAAC,MAAM,0CAAE,KAAM,EAChC,aAAa,CACd,CAAA;IACD,MAAM,gBAAgB,GAAG,eAAe,CAAC,MAAM,CAAC,KAAK,CAAA;IAErD,MAAM,kBAAkB,GAAG,cAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,gBAAgB,CAAC,CAAA;IAExE,OAAO;QACL,UAAU,EAAE,kBAAkB,CAAC,KAAK,CAAC,cAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,cAAI,CAAC,KAAK,CAAC,GAAG,CAAC;KACpE,CAAA;AACH,CAAC;AAED,SAAgB,6BAA6B,CAC3C,gBAAkC;IAElC,MAAM,OAAO,GAAG,yBAAyB,CAAC,gBAAgB,CAAC,CAAA;IAE3D,OAAO,gCAAgC,OAAO,CAAC,UAAU,0CAA0C,OAAO,CAAC,UAAU,MAAM,CAAA;AAC7H,CAAC"}