prisma-generator-express 1.66.0 → 1.67.0

package/src/generators/generateFastifyHandler.ts

@@ -1,5 +1,5 @@
-import { DMMF } from '@prisma/generator-helper'
-import { ImportStyle } from '../utils/resolveImportStyle'
+import type { DMMF } from '@prisma/generator-helper'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
@@ -12,12 +12,14 @@ export function generateFastifyHandler(options: {
 
   const readOps = OPERATION_METADATA.filter((m) => m.kind === 'read')
   const writeOps = OPERATION_METADATA.filter(
-    (m) => (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
+    (m) =>
+      (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
   )
 
-  const readHandlers = readOps.map((meta) => {
-    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
-    return `
+  const readHandlers = readOps
+    .map((meta) => {
+      const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
+      return `
 export async function ${exportName}(
   request: FastifyRequest,
   _reply: FastifyReply,
@@ -25,11 +27,13 @@ export async function ${exportName}(
   const data = await core.${meta.coreName}(buildContext(request))
   ;(request as FastifyExtended).resultData = data
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
-  const writeHandlers = writeOps.map((meta) => {
-    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
-    return `
+  const writeHandlers = writeOps
+    .map((meta) => {
+      const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
+      return `
 export async function ${exportName}(
   request: FastifyRequest,
   _reply: FastifyReply,
@@ -39,7 +43,8 @@ export async function ${exportName}(
   ext.resultData = data
   ext.resultStatus = ${meta.successStatus}
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
   const updateEachExportName = `${modelName}UpdateEach`
   const updateEachHandler = `
@@ -54,7 +59,7 @@ export async function ${updateEachExportName}(
 
   return `import type { FastifyRequest, FastifyReply } from 'fastify'
 import * as core from './${modelName}Core${ext}'
-import type { OperationContext, FindManyPaginatedMode } from '../operationRuntime${ext}'
+import type { RuntimeOperationOverride, OperationContext, FindManyPaginatedMode } from '../operationRuntime${ext}'
 
 type FastifyExtended = FastifyRequest & {
   prisma?: unknown
@@ -64,6 +69,9 @@ type FastifyExtended = FastifyRequest & {
   routeConfig?: { pagination?: OperationContext['paginationConfig'] }
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  guardVariantKey?: string
+  operationOverride?: RuntimeOperationOverride
+  resolveOperationContext?: () => unknown | Promise<unknown>
   findManyPaginatedMode?: FindManyPaginatedMode
   resultData?: unknown
   resultStatus?: number
@@ -72,6 +80,8 @@ type FastifyExtended = FastifyRequest & {
 function buildContext(request: FastifyRequest): OperationContext {
   const req = request as FastifyExtended
   return {
+    operationOverride: req.operationOverride,
+    resolveOperationContext: req.resolveOperationContext,
     prisma: req.prisma,
     postgres: req.postgres,
     sqlite: req.sqlite,
@@ -79,6 +89,7 @@ function buildContext(request: FastifyRequest): OperationContext {
     body: request.body,
     guardShape: req.guardShape,
     guardCaller: req.guardCaller,
+    guardVariantKey: req.guardVariantKey,
     paginationConfig: req.routeConfig?.pagination,
     findManyPaginatedMode: req.findManyPaginatedMode,
   }
@@ -87,4 +98,4 @@ ${readHandlers}
 ${writeHandlers}
 ${updateEachHandler}
 `
-}
+}

package/src/generators/generateHonoHandler.ts

@@ -1,5 +1,5 @@
-import { DMMF } from '@prisma/generator-helper'
-import { ImportStyle } from '../utils/resolveImportStyle'
+import type { DMMF } from '@prisma/generator-helper'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
 import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
@@ -12,27 +12,32 @@ export function generateHonoHandler(options: {
 
   const readOps = OPERATION_METADATA.filter((m) => m.kind === 'read')
   const writeOps = OPERATION_METADATA.filter(
-    (m) => (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
+    (m) =>
+      (m.kind === 'write' || m.kind === 'batch') && m.name !== 'updateEach',
   )
 
-  const readHandlers = readOps.map((meta) => {
-    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
-    return `
+  const readHandlers = readOps
+    .map((meta) => {
+      const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
+      return `
 export async function ${exportName}(c: HandlerContext): Promise<void> {
   const data = await core.${meta.coreName}(buildContext(c))
   c.set('resultData', data)
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
-  const writeHandlers = writeOps.map((meta) => {
-    const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
-    return `
+  const writeHandlers = writeOps
+    .map((meta) => {
+      const exportName = `${modelName}${meta.name.charAt(0).toUpperCase() + meta.name.slice(1)}`
+      return `
 export async function ${exportName}(c: HandlerContext): Promise<void> {
   const data = await core.${meta.coreName}(buildContext(c))
   c.set('resultData', data)
   c.set('resultStatus', ${meta.successStatus})
 }`
-  }).join('\n')
+    })
+    .join('\n')
 
   const updateEachExportName = `${modelName}UpdateEach`
   const updateEachHandler = `
@@ -44,13 +49,15 @@ export async function ${updateEachExportName}(c: HandlerContext): Promise<void>
 
   return `import type { Context } from 'hono'
 import * as core from './${modelName}Core${ext}'
-import type { OperationContext } from '../operationRuntime${ext}'
+import type { RuntimeOperationOverride, OperationContext } from '../operationRuntime${ext}'
 import type { HonoInternalVariables } from '../routeConfig.target${ext}'
 
 type HandlerContext = Context<{ Variables: HonoInternalVariables }>
 
 function buildContext(c: HandlerContext): OperationContext {
   return {
+    operationOverride: c.get('operationOverride'),
+    resolveOperationContext: c.get('resolveOperationContext'),
     prisma: c.get('prisma'),
     postgres: c.get('postgres'),
     sqlite: c.get('sqlite'),
@@ -58,6 +65,7 @@ function buildContext(c: HandlerContext): OperationContext {
     body: c.get('body'),
     guardShape: c.get('guardShape'),
     guardCaller: c.get('guardCaller'),
+    guardVariantKey: c.get('guardVariantKey'),
     paginationConfig: c.get('routeConfig')?.pagination,
   }
 }
@@ -65,4 +73,4 @@ ${readHandlers}
 ${writeHandlers}
 ${updateEachHandler}
 `
-}
+}

package/src/generators/generateImportPrismaStatement.ts

@@ -1,81 +1,93 @@
-import { GeneratorOptions } from '@prisma/generator-helper'
-import * as fs from 'fs'
-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',
-  )
-  return byProvider || 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 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 block exists with name "client" or provider one of: prisma-client-js, @prisma/client, prisma-client.',
-    )
-  }
-
-  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)
-}
-
-function findGuardGenerator(options: GeneratorOptions) {
-  const byProvider = options.otherGenerators.find(
-    (gen) =>
-      !!gen.provider?.value && gen.provider.value.includes('prisma-guard'),
-  )
-  if (byProvider) return byProvider
-
-  const byConfig = options.otherGenerators.find(
-    (gen) =>
-      !!gen.config &&
-      ('typedGuardShapes' in gen.config ||
-        'onInvalidZod' in gen.config ||
-        'findUniqueMode' in gen.config),
-  )
-  return byConfig || null
-}
-
-export function getGuardShapesImport(
-  options: GeneratorOptions,
-  modelName: string,
-): string | null {
-  const guard = findGuardGenerator(options)
-  if (!guard || !guard.output?.value) return null
-
-  if (guard.config?.typedGuardShapes === 'false') return null
-
-  const outputValue = options.generator.output?.value
-  if (!outputValue) return null
-
-  const fromDir = path.join(outputValue, modelName)
-  const shapesPath = path.join(guard.output.value, 'shapes')
-  return getRelativeImportPath(fromDir, shapesPath)
-}
+import { GeneratorOptions } from '@prisma/generator-helper'
+import * as fs from 'fs'
+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',
+  )
+  return byProvider || 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 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 block exists with name "client" or provider one of: prisma-client-js, @prisma/client, prisma-client.',
+    )
+  }
+
+  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)
+}
+
+function findGuardGenerator(options: GeneratorOptions) {
+  const byProvider = options.otherGenerators.find(
+    (gen) =>
+      !!gen.provider?.value && gen.provider.value.includes('prisma-guard'),
+  )
+  if (byProvider) return byProvider
+
+  const byConfig = options.otherGenerators.find(
+    (gen) =>
+      !!gen.config &&
+      ('typedGuardShapes' in gen.config ||
+        'onInvalidZod' in gen.config ||
+        'findUniqueMode' in gen.config),
+  )
+  return byConfig || null
+}
+
+export function getGuardShapesImport(
+  options: GeneratorOptions,
+  modelName: string,
+): string | null {
+  const guard = findGuardGenerator(options)
+  if (!guard || !guard.output?.value) return null
+
+  if (guard.config?.typedGuardShapes === 'false') return null
+
+  const outputValue = options.generator.output?.value
+  if (!outputValue) return null
+
+  const fromDir = path.join(outputValue, modelName)
+  const shapesPath = path.join(guard.output.value, 'shapes')
+  return getRelativeImportPath(fromDir, shapesPath)
+}
+
+export function getRelativeClientTypeImport(
+  options: GeneratorOptions,
+  modelName: string,
+): string {
+  const client = findClientGenerator(options)
+  const entry = client?.provider.value === 'prisma-client' ? 'client' : 'index'
+  return getRelativeClientPath(options, modelName) + '/' + entry
+}

package/src/generators/generateModelMetadata.ts

@@ -4,16 +4,26 @@ import { importExt } from '../utils/importExt'
 
 function exampleValueForType(fieldType: string): unknown {
   switch (fieldType) {
-    case 'String': return 'example'
-    case 'Int': return 1
-    case 'BigInt': return '1'
-    case 'Float': return 1.0
-    case 'Decimal': return '1.0'
-    case 'Boolean': return true
-    case 'DateTime': return '2025-01-01T00:00:00.000Z'
-    case 'Json': return {}
-    case 'Bytes': return 'base64data'
-    default: return 'example'
+    case 'String':
+      return 'example'
+    case 'Int':
+      return 1
+    case 'BigInt':
+      return '1'
+    case 'Float':
+      return 1.0
+    case 'Decimal':
+      return '1.0'
+    case 'Boolean':
+      return true
+    case 'DateTime':
+      return '2025-01-01T00:00:00.000Z'
+    case 'Json':
+      return {}
+    case 'Bytes':
+      return 'base64data'
+    default:
+      return 'example'
   }
 }
 
@@ -23,7 +33,9 @@ export interface GenerateModelMetadataOptions {
   importStyle: ImportStyle
 }
 
-export function generateModelMetadata(options: GenerateModelMetadataOptions): string {
+export function generateModelMetadata(
+  options: GenerateModelMetadataOptions,
+): string {
   const ext = importExt(options.importStyle)
   const { model, enums } = options
   const modelName = model.name
@@ -89,4 +101,4 @@ export const COMPOUND_UNIQUES: { name: string; fields: string[] }[] = ${JSON.str
 
 export const EXAMPLE_VALUES: Record<string, unknown> = ${JSON.stringify(exampleValues, null, 2)}
 `
-}
+}

package/src/generators/generateOperationCore.ts

@@ -1,7 +1,8 @@
-import { DMMF } from '@prisma/generator-helper'
-import { ImportStyle } from '../utils/resolveImportStyle'
+import { OPERATION_METADATA } from '../copy/operationDefinitions'
+import type { DMMF } from '@prisma/generator-helper'
+import type { ImportStyle } from '../utils/resolveImportStyle'
 import { importExt } from '../utils/importExt'
-import { WriteStrategy, FindManyPaginatedMode } from '../constants'
+import type { WriteStrategy, FindManyPaginatedMode } from '../constants'
 
 export interface ModelCoreOptions {
   model: DMMF.Model
@@ -17,7 +18,10 @@ function decideWriteOp(
   defaultMethod: string,
   strategy: WriteStrategy,
 ): WriteOpDecision {
-  if (strategy === 'throwOnNonReturning' && (name === 'createMany' || name === 'updateMany')) {
+  if (
+    strategy === 'throwOnNonReturning' &&
+    (name === 'createMany' || name === 'updateMany')
+  ) {
     return { throw: true, method: defaultMethod }
   }
   if (strategy === 'forceReturn') {
@@ -27,7 +31,10 @@ function decideWriteOp(
   return { method: defaultMethod }
 }
 
-function renderPaginatedBody(modelNameLower: string, mode: FindManyPaginatedMode): string {
+function renderPaginatedBody(
+  modelNameLower: string,
+  mode: FindManyPaginatedMode,
+): string {
   if (mode === 'transaction') {
     return `
   const txClient = extended as { $transaction?: <T>(fn: (tx: unknown) => Promise<T>) => Promise<T> }
@@ -69,16 +76,25 @@ export function generateModelCore(options: ModelCoreOptions): string {
   const modelName = options.model.name
   const modelNameLower = modelName.charAt(0).toLowerCase() + modelName.slice(1)
   const writeStrategy = options.writeStrategy
-  const paginatedBody = renderPaginatedBody(modelNameLower, options.findManyPaginatedMode)
+  const paginatedBody = renderPaginatedBody(
+    modelNameLower,
+    options.findManyPaginatedMode,
+  )
 
   const standardReadOps = [
-    'findFirst', 'findUnique', 'findUniqueOrThrow', 'findFirstOrThrow',
-    'count', 'aggregate', 'groupBy',
+    'findFirst',
+    'findUnique',
+    'findUniqueOrThrow',
+    'findFirstOrThrow',
+    'count',
+    'aggregate',
+    'groupBy',
   ]
 
   const standardReadHandlers = standardReadOps
-    .map((op) => `
-export async function ${op}(ctx: OperationContext): Promise<unknown> {
+    .map(
+      (op) => `
+async function default_${op}(ctx: OperationContext): Promise<unknown> {
   const query = ctx.parsedQuery || {}
   const extended = await getExtendedClient(ctx)
   const delegate = getDelegate(extended, '${modelNameLower}')
@@ -87,38 +103,56 @@ export async function ${op}(ctx: OperationContext): Promise<unknown> {
     return delegate.guard(ctx.guardShape, ctx.guardCaller).${op}(query)
   }
   return delegate.${op}(query)
-}`)
+}`,
+    )
     .join('\n')
 
   const writeOps = [
     { name: 'create', method: 'create', requiredFields: ['data'] },
     { name: 'createMany', method: 'createMany', requiredFields: ['data'] },
-    { name: 'createManyAndReturn', method: 'createManyAndReturn', requiredFields: ['data'] },
+    {
+      name: 'createManyAndReturn',
+      method: 'createManyAndReturn',
+      requiredFields: ['data'],
+    },
     { name: 'update', method: 'update', requiredFields: ['where', 'data'] },
-    { name: 'updateMany', method: 'updateMany', requiredFields: ['where', 'data'] },
-    { name: 'updateManyAndReturn', method: 'updateManyAndReturn', requiredFields: ['where', 'data'] },
+    {
+      name: 'updateMany',
+      method: 'updateMany',
+      requiredFields: ['where', 'data'],
+    },
+    {
+      name: 'updateManyAndReturn',
+      method: 'updateManyAndReturn',
+      requiredFields: ['where', 'data'],
+    },
     { name: 'deleteUnique', method: 'delete', requiredFields: ['where'] },
     { name: 'deleteMany', method: 'deleteMany', requiredFields: ['where'] },
-    { name: 'upsert', method: 'upsert', requiredFields: ['where', 'create', 'update'] },
+    {
+      name: 'upsert',
+      method: 'upsert',
+      requiredFields: ['where', 'create', 'update'],
+    },
   ]
 
-  const writeHandlers = writeOps.map((op) => {
-    const decision = decideWriteOp(op.name, op.method, writeStrategy)
+  const writeHandlers = writeOps
+    .map((op) => {
+      const decision = decideWriteOp(op.name, op.method, writeStrategy)
 
-    if (decision.throw) {
-      return `
-export async function ${op.name}(_ctx: OperationContext): Promise<unknown> {
+      if (decision.throw) {
+        return `
+async function default_${op.name}(_ctx: OperationContext): Promise<unknown> {
   throw new HttpError(501, '${op.name} is disabled by writeStrategy="${writeStrategy}"')
 }`
-    }
+      }
 
-    const method = decision.method
-    const validationLines = op.requiredFields
-      .map((field) => `  requireBodyField(body, '${field}')`)
-      .join('\n')
+      const method = decision.method
+      const validationLines = op.requiredFields
+        .map((field) => `  requireBodyField(body, '${field}')`)
+        .join('\n')
 
-    return `
-export async function ${op.name}(ctx: OperationContext): Promise<unknown> {
+      return `
+async function default_${op.name}(ctx: OperationContext): Promise<unknown> {
   const body = validateBody(ctx.body)
 ${validationLines}
   const extended = await getExtendedClient(ctx)
@@ -129,11 +163,24 @@ ${validationLines}
   }
   return delegate.${method}(body)
 }`
-  }).join('\n')
+    })
+    .join('\n')
+
+  const wrappers = OPERATION_METADATA.filter((op) => op.name !== 'updateEach')
+    .map(
+      (op) => `
+export async function ${op.coreName}(ctx: OperationContext): Promise<${op.name === 'findManyPaginated' ? '{ data: unknown[]; total: number; hasMore: boolean }' : 'unknown'}> {
+  const input = ${op.kind === 'read' ? 'ctx.parsedQuery || {}' : 'validateBody(ctx.body)'}
+${op.requiredBodyFields.map((field) => `  requireBodyField(input, '${field}')`).join('\n')}
+  return executeOperationOverride(ctx, '${modelNameLower}', '${op.name}', input, () => default_${op.coreName}(ctx))
+}`,
+    )
+    .join('\n')
 
   return `import {
-  OperationContext,
-  PrismaClientLike,
+  type OperationContext,
+  executeOperationOverride,
+  type PrismaClientLike,
   getExtendedClient,
   getDelegate,
   validateBody,
@@ -144,7 +191,7 @@ import { applyPaginationLimits, countForPagination } from '../pagination${ext}'
 import { assertGuard } from '../guardHelpers${ext}'
 import { mapLimited } from '../concurrency${ext}'
 
-export async function findMany(ctx: OperationContext): Promise<unknown> {
+async function default_findMany(ctx: OperationContext): Promise<unknown> {
   const rawQuery = ctx.parsedQuery || {}
   const query = applyPaginationLimits(rawQuery, ctx.paginationConfig, !!ctx.guardShape)
   const extended = await getExtendedClient(ctx)
@@ -155,10 +202,11 @@ export async function findMany(ctx: OperationContext): Promise<unknown> {
   }
   return delegate.findMany(query)
 }
+${wrappers}
 ${standardReadHandlers}
 ${writeHandlers}
 
-export async function findManyPaginated(
+async function default_findManyPaginated(
   ctx: OperationContext,
 ): Promise<{ data: unknown[]; total: number; hasMore: boolean }> {
   const rawQuery = ctx.parsedQuery || {}
@@ -252,4 +300,4 @@ export async function updateEach(
   return results
 }
 `
-}
+}

package/src/generators/generateRelationMeta.ts

@@ -32,13 +32,15 @@ function findOppositeField(
   const target = models.find((m) => m.name === targetModelName)
   if (!target) return null
   const isSelfRelation = targetModelName === selfModelName
-  return target.fields.find(
-    (f) =>
-      f.kind === 'object' &&
-      f.relationName === relationName &&
-      f.type === selfModelName &&
-      !(isSelfRelation && f.name === selfFieldName),
-  ) || null
+  return (
+    target.fields.find(
+      (f) =>
+        f.kind === 'object' &&
+        f.relationName === relationName &&
+        f.type === selfModelName &&
+        !(isSelfRelation && f.name === selfFieldName),
+    ) || null
+  )
 }
 
 function computeRelation(
@@ -61,7 +63,13 @@ function computeRelation(
     }
   }
 
-  const opposite = findOppositeField(models, field.type, field.relationName, selfModelName, field.name)
+  const opposite = findOppositeField(
+    models,
+    field.type,
+    field.relationName,
+    selfModelName,
+    field.name,
+  )
   if (opposite) {
     const oppFrom = (opposite.relationFromFields ?? []) as string[]
     const oppTo = (opposite.relationToFields ?? []) as string[]
@@ -118,7 +126,9 @@ export interface GenerateRelationMetaOptions {
   importStyle: ImportStyle
 }
 
-export function generateRelationMeta(options: GenerateRelationMetaOptions): string {
+export function generateRelationMeta(
+  options: GenerateRelationMetaOptions,
+): string {
   const ext = importExt(options.importStyle)
   const meta = buildModelMeta(options.model, options.allModels)
   return `import type { ModelRelationMap } from '../autoIncludePlanner${ext}'
@@ -132,7 +142,9 @@ export interface GenerateRelationModelsIndexOptions {
   importStyle: ImportStyle
 }
 
-export function generateRelationModelsIndex(options: GenerateRelationModelsIndexOptions): string {
+export function generateRelationModelsIndex(
+  options: GenerateRelationModelsIndexOptions,
+): string {
   const ext = importExt(options.importStyle)
   const imports = options.modelNames
     .map((n) => `import { ${n}Relations } from './${n}/${n}Relations${ext}'`)
@@ -147,4 +159,4 @@ export const relationModels: Record<string, ModelRelationMap> = {
 ${entries}
 }
 `
-}
+}