prisma-generator-express 1.16.7 → 1.19.0

package/dist/generators/generateRouter.js

@@ -0,0 +1,340 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRouterFunction = generateRouterFunction;
+function generateRouterFunction({ model, enums, relativeClientPath, }) {
+    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
+}
+`;
+}
+//# sourceMappingURL=generateRouter.js.map

package/dist/generators/generateRouter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateRouter.js","sourceRoot":"","sources":["../../src/generators/generateRouter.ts"],"names":[],"mappings":";;AAEA,wDA6VC;AA7VD,SAAgB,sBAAsB,CAAC,EACrC,KAAK,EACL,KAAK,EACL,kBAAkB,GAKnB;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,cAAc,GAAG,SAAS,CAAC,WAAW,EAAE,CAAA;IAC9C,MAAM,kBAAkB,GAAG,GAAG,SAAS,QAAQ,CAAA;IAE/C,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC1C,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,MAAM,EAAE,CAAC,CAAC,MAAM;QAChB,UAAU,EAAE,CAAC,CAAC,UAAU;QACxB,eAAe,EAAE,CAAC,CAAC,eAAe;QAClC,WAAW,EAAE,CAAC,CAAC,WAAW,IAAI,KAAK;QACnC,aAAa,EAAE,CAAC,CAAC,aAAa;QAC9B,kBAAkB,EAAE,CAAC,CAAC,kBAAkB;KACzC,CAAC,CAAC,CAAA;IAEH,MAAM,mBAAmB,GAAG,IAAI,GAAG,CACjC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CACjE,CAAA;IAED,MAAM,SAAS,GAAG,KAAK;SACpB,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;SAC9C,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACX,IAAI,EAAE,CAAC,CAAC,IAAI;QACZ,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;KAChD,CAAC,CAAC,CAAA;IAEL,OAAO;qCAC4B,kBAAkB;;IAEnD,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;IACT,SAAS;YACD,SAAS;;;;;;;uBAOE,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;;sBAEpC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsDtC,kBAAkB;;;;;;4DAMwB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAgE/D,SAAS;;;;;;;;;;;WAWT,SAAS;;;;;;;;;;;;;;kEAc8C,SAAS;;;;;;;kEAOT,SAAS;;;;;;;kEAOT,SAAS;;;;;;;kEAOT,SAAS;;;;;;;kEAOT,SAAS;;;;;;;kEAOT,SAAS;;;;;;;kEAOT,SAAS;;;;;;;kEAOT,SAAS;;;;;;;kEAOT,SAAS;;;;;;;uDAOpB,SAAS;;;;;;;uDAOT,SAAS;;;;;;;uDAOT,SAAS;;;;;;;sDAOV,SAAS;;;;;;;sDAOT,SAAS;;;;;;;sDAOT,SAAS;;;;;;;wDAOP,SAAS;;;;;;;yDAOR,SAAS;;;;;;;yDAOT,SAAS;;;;;;;;;;;;;;CAcjE,CAAA;AACD,CAAC"}

package/dist/generators/generateUnifiedDocs.d.ts

@@ -0,0 +1 @@
+export declare function generateUnifiedDocs(models: string[]): string;

package/dist/generators/generateUnifiedDocs.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUnifiedDocs = generateUnifiedDocs;
+function generateUnifiedDocs(models) {
+    const imports = models
+        .map((model) => `import { ${model}Docs } from './${model}/${model}Docs'`)
+        .join('\n');
+    return `${imports}
+import { Request, Response, RequestHandler } from 'express'
+import type { RouteConfig } from './routeConfig'
+
+const _env = typeof process !== 'undefined' && process.env ? process.env : {} as Record<string, string | undefined>
+
+const docsHandlers: Record<string, (config: any) => (req: Request, res: Response) => any> = {
+${models.map((model) => `  ${model}: ${model}Docs`).join(',\n')}
+}
+
+type DocsUI = 'docs' | 'scalar' | 'json' | 'yaml' | 'playground'
+
+interface ModelDocsConfig extends RouteConfig {
+  docsTitle?: string
+  docsUi?: DocsUI
+}
+
+export interface CombinedDocsConfig {
+  disableOpenApi?: boolean
+  title?: string
+  description?: string
+  basePath?: string
+  version?: string
+  modelConfigs: {
+    [modelName: string]: ModelDocsConfig
+  }
+}
+
+function escapeHtml(input: string) {
+  return input
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#039;')
+}
+
+function removeTrailingSlash(p: string): string {
+  if (p === '/') return ''
+  return p.endsWith('/') ? p.slice(0, -1) : p
+}
+
+function isOpenApiDisabled(disableOpenApi?: boolean) {
+  if (disableOpenApi === true) return true
+  if (disableOpenApi === false) return false
+  return _env.DISABLE_OPENAPI === 'true' || _env.NODE_ENV === 'production'
+}
+
+function isPlaygroundAvailable(config?: ModelDocsConfig) {
+  if (_env.NODE_ENV === 'production') return false
+  if (!config) return true
+  if (config.queryBuilder === false) return false
+  if (typeof config.queryBuilder === 'object' && config.queryBuilder.enabled === false) return false
+  return true
+}
+
+export function generateCombinedDocs(config: CombinedDocsConfig) {
+  const title = config.title || 'API Documentation'
+  const description = config.description || ''
+  const version = config.version || ''
+
+  return (req: Request, res: Response) => {
+    const registeredModels = Object.keys(config.modelConfigs).filter((m) => {
+      const cfg = config.modelConfigs[m]
+      return m in docsHandlers && !isOpenApiDisabled(cfg?.disableOpenApi ?? config.disableOpenApi)
+    })
+
+    if (registeredModels.length === 0) {
+      return res.status(404).send('OpenAPI documentation is disabled')
+    }
+
+    const basePath = removeTrailingSlash(config.basePath || '/docs')
+    const generatedAt = new Date().toISOString()
+
+    const html = \`<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>\${escapeHtml(title)}</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="m-0 bg-white text-gray-900 font-serif leading-normal">
+  <div class="max-w-[980px] mx-auto px-7 pt-10 pb-16">
+    <div class="border-b-2 border-gray-900 pb-3.5 mb-[18px]">
+      <div class="text-[28px] font-bold tracking-wide">\${escapeHtml(title)}</div>
+      \${description ? '<div class="mt-1.5 text-gray-500 text-sm">' + escapeHtml(description) + '</div>' : ''}
+      <div class="mt-3 flex gap-x-5 text-[13px] text-gray-500">
+        \${version ? '<div>Version: ' + escapeHtml(version) + '</div>' : ''}
+        <div>Generated: \${escapeHtml(generatedAt)}</div>
+      </div>
+    </div>
+
+    <div class="mt-[22px]">
+      <h2 class="m-0 mb-2.5 text-lg border-t border-gray-300 pt-3.5">Models</h2>
+      <table class="w-full border-collapse text-[13px]">
+        <thead>
+          <tr>
+            <th class="text-left py-2 px-2 border-b border-gray-300 align-top font-bold">Model</th>
+            <th class="text-left py-2 px-2 border-b border-gray-300 align-top font-bold">Documentation</th>
+            <th class="text-left py-2 px-2 border-b border-gray-300 align-top font-bold">Views</th>
+          </tr>
+        </thead>
+        <tbody>
+          \${registeredModels.map((m) => {
+            const lower = m.toLowerCase()
+            const docsUrl = \\\`\\\${basePath}/\\\${lower}\\\`
+            const scalarUrl = \\\`\\\${basePath}/\\\${lower}?ui=scalar\\\`
+            const jsonUrl = \\\`\\\${basePath}/\\\${lower}?ui=json\\\`
+            const yamlUrl = \\\`\\\${basePath}/\\\${lower}?ui=yaml\\\`
+            const playgroundUrl = \\\`\\\${basePath}/\\\${lower}?ui=playground\\\`
+            const modelCfg = config.modelConfigs[m]
+            const modelPlayground = isPlaygroundAvailable(modelCfg)
+            const playgroundLink = modelPlayground
+              ? \\\`, <a href="\\\${playgroundUrl}" class="text-inherit underline">playground</a>\\\`
+              : ''
+            return \\\`
+              <tr>
+                <td class="text-left py-2 px-2 border-b border-gray-300 align-top">\\\${escapeHtml(m)}</td>
+                <td class="text-left py-2 px-2 border-b border-gray-300 align-top"><a href="\\\${docsUrl}" class="text-inherit underline">\\\${escapeHtml(docsUrl)}</a></td>
+                <td class="text-left py-2 px-2 border-b border-gray-300 align-top">
+                  <a href="\\\${scalarUrl}" class="text-inherit underline">scalar</a>,
+                  <a href="\\\${jsonUrl}" class="text-inherit underline">json</a>,
+                  <a href="\\\${yamlUrl}" class="text-inherit underline">yaml</a>\\\${playgroundLink}
+                </td>
+              </tr>
+            \\\`
+          }).join('')}
+        </tbody>
+      </table>
+    </div>
+  </div>
+</body>
+</html>\`
+
+    res.type('html').send(html)
+  }
+}
+
+export function registerModelDocs(
+  app: any,
+  basePath: string = '/docs',
+  configs: CombinedDocsConfig['modelConfigs'] = {},
+  options?: { disableOpenApi?: boolean }
+) {
+  const normalizedBase = removeTrailingSlash(basePath)
+  const registeredModels = Object.keys(configs).filter((m) => {
+    const cfg = configs[m]
+    return m in docsHandlers && !isOpenApiDisabled(cfg?.disableOpenApi ?? options?.disableOpenApi)
+  })
+
+  if (registeredModels.length === 0) return
+
+  registeredModels.forEach((model) => {
+    const handler = docsHandlers[model]
+    const cfg = configs[model] || {}
+    const path = \\\`\\\${normalizedBase}/\\\${model.toLowerCase()}\\\`
+    console.log(\\\`  Registered docs: \\\${path}\\\`)
+    app.get(path, handler(cfg))
+  })
+}
+`;
+}
+//# sourceMappingURL=generateUnifiedDocs.js.map

package/dist/generators/generateUnifiedDocs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateUnifiedDocs.js","sourceRoot":"","sources":["../../src/generators/generateUnifiedDocs.ts"],"names":[],"mappings":";;AAAA,kDAuKC;AAvKD,SAAgB,mBAAmB,CAAC,MAAgB;IAClD,MAAM,OAAO,GAAG,MAAM;SACnB,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,KAAK,kBAAkB,KAAK,IAAI,KAAK,OAAO,CAAC;SACxE,IAAI,CAAC,IAAI,CAAC,CAAA;IAEb,OAAO,GAAG,OAAO;;;;;;;EAOjB,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,KAAK,KAAK,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0J9D,CAAA;AACD,CAAC"}

package/dist/generators/generateUnifiedHandler.d.ts

@@ -0,0 +1,6 @@
+import { DMMF } from '@prisma/generator-helper';
+export interface UnifiedHandlerOptions {
+    model: DMMF.Model;
+    prismaImportStatement: string;
+}
+export declare function generateUnifiedHandler(options: UnifiedHandlerOptions): string;