prisma-generator-express 1.66.0 → 1.68.0

package/src/copy/buildModelOpenApi.ts

@@ -1,5 +1,9 @@
 import { stringify as yamlStringify } from 'yaml'
-import type { RouteConfig, WriteStrategy } from './routeConfig'
+import type {
+  RouteConfig,
+  WriteStrategy,
+  OpenApiSecuritySchemeConfig,
+} from './routeConfig'
 import { OPERATION_BY_NAME, isOperationEnabled } from './operationDefinitions'
 import { normalizePrefix, removeTrailingSlash } from './misc'
 import { NUMERIC_SCALAR_TYPES, STRING_NUMERIC_TYPES } from './scalarTypes'
@@ -20,14 +24,51 @@ type SchemaObject = {
 
 type RefObject = { $ref: string; description?: string }
 
+type ContentObject = {
+  'application/json'?: { schema: SchemaObject | RefObject }
+  'application/yaml'?: { schema: SchemaObject | RefObject }
+}
+
+type ResponseObject = {
+  description: string
+  content?: ContentObject
+}
+
+type RequestBodyObject = {
+  required?: boolean
+  content: ContentObject
+}
+
+type ParameterSchema = Record<string, string | string[]>
+
+type ParameterObject = {
+  name: string
+  in: 'query' | 'header'
+  schema?: ParameterSchema
+  description?: string
+  required?: boolean
+}
+
+type OperationObject = {
+  tags?: string[]
+  summary?: string
+  operationId?: string
+  description?: string
+  parameters?: ParameterObject[]
+  requestBody?: RequestBodyObject
+  responses: Record<string, ResponseObject>
+}
+
+type PathItem = Record<string, OperationObject>
+
 type OpenApiSpec = {
   openapi: string
   info: { title: string; description: string; version: string }
   servers?: Array<{ url: string; description?: string }>
-  paths: Record<string, any>
+  paths: Record<string, PathItem>
   components: {
     schemas: Record<string, SchemaObject>
-    securitySchemes?: Record<string, any>
+    securitySchemes?: Record<string, OpenApiSecuritySchemeConfig>
   }
   security?: Array<Record<string, string[]>>
 }
@@ -55,22 +96,59 @@ type BuildOptions = {
   description?: string
   version?: string
   writeStrategy?: WriteStrategy
+  pathSegment?: string
 }
 
-const WHERE_PROP: SchemaObject = { type: 'object', description: 'Filter conditions' }
-const TAKE_PROP: SchemaObject = { type: 'integer', description: 'Limit results' }
+const WHERE_PROP: SchemaObject = {
+  type: 'object',
+  description: 'Filter conditions',
+}
+const TAKE_PROP: SchemaObject = {
+  type: 'integer',
+  description: 'Limit results',
+}
 const SKIP_PROP: SchemaObject = { type: 'integer', description: 'Skip results' }
-const CURSOR_PROP: SchemaObject = { type: 'object', description: 'Cursor for pagination' }
-const ORDERBY_PROP: SchemaObject = { description: 'Sort order (object or array of objects)' }
-const SELECT_PROP: SchemaObject = { type: 'object', description: 'Select fields' }
-const INCLUDE_PROP: SchemaObject = { type: 'object', description: 'Include relations' }
-const OMIT_PROP: SchemaObject = { type: 'object', description: 'Omit fields from response' }
-const DISTINCT_PROP: SchemaObject = { description: 'Distinct fields (string or array of strings)' }
-const AGG_COUNT: SchemaObject = { description: 'Count aggregate (true or field selection object)' }
-const AGG_AVG: SchemaObject = { type: 'object', description: 'Average aggregate (field selection object)' }
-const AGG_SUM: SchemaObject = { type: 'object', description: 'Sum aggregate (field selection object)' }
-const AGG_MIN: SchemaObject = { type: 'object', description: 'Min aggregate (field selection object)' }
-const AGG_MAX: SchemaObject = { type: 'object', description: 'Max aggregate (field selection object)' }
+const CURSOR_PROP: SchemaObject = {
+  type: 'object',
+  description: 'Cursor for pagination',
+}
+const ORDERBY_PROP: SchemaObject = {
+  description: 'Sort order (object or array of objects)',
+}
+const SELECT_PROP: SchemaObject = {
+  type: 'object',
+  description: 'Select fields',
+}
+const INCLUDE_PROP: SchemaObject = {
+  type: 'object',
+  description: 'Include relations',
+}
+const OMIT_PROP: SchemaObject = {
+  type: 'object',
+  description: 'Omit fields from response',
+}
+const DISTINCT_PROP: SchemaObject = {
+  description: 'Distinct fields (string or array of strings)',
+}
+const AGG_COUNT: SchemaObject = {
+  description: 'Count aggregate (true or field selection object)',
+}
+const AGG_AVG: SchemaObject = {
+  type: 'object',
+  description: 'Average aggregate (field selection object)',
+}
+const AGG_SUM: SchemaObject = {
+  type: 'object',
+  description: 'Sum aggregate (field selection object)',
+}
+const AGG_MIN: SchemaObject = {
+  type: 'object',
+  description: 'Min aggregate (field selection object)',
+}
+const AGG_MAX: SchemaObject = {
+  type: 'object',
+  description: 'Max aggregate (field selection object)',
+}
 
 const PROJECTION_PROPS: Record<string, SchemaObject> = {
   select: SELECT_PROP,
@@ -88,7 +166,7 @@ const AGGREGATE_PROPS: Record<string, SchemaObject> = {
 
 function opEnabled(config: RouteConfig, name: string): boolean {
   const meta = OPERATION_BY_NAME[name]
-  return meta ? isOperationEnabled(config as Record<string, any>, meta) : false
+  return meta ? isOperationEnabled(config, meta) : false
 }
 
 function opPath(basePath: string, name: string): string {
@@ -123,7 +201,10 @@ const COMMON_ERRORS: Record<number, string> = {
   503: 'Service unavailable — database connection pool timeout',
 }
 
-function addErrorResponses(operation: any, codes: readonly number[]): void {
+function addErrorResponses(
+  operation: OperationObject,
+  codes: readonly number[],
+): void {
   for (const code of codes) {
     operation.responses[String(code)] = errorResponse(
       COMMON_ERRORS[code] || 'Error',
@@ -137,7 +218,7 @@ function queryParam(
   schema: Record<string, string> = { type: 'string' },
   required?: boolean,
 ) {
-  const param: any = { name, in: 'query' as const, schema, description }
+  const param: ParameterObject = { name, in: 'query', schema, description }
   if (required) param.required = true
   return param
 }
@@ -182,101 +263,7 @@ function listScalarUpdateOperations(
   }
 }
 
-function findManyBodySchema(): SchemaObject {
-  return {
-    type: 'object',
-    properties: {
-      where: WHERE_PROP,
-      orderBy: ORDERBY_PROP,
-      take: TAKE_PROP,
-      skip: SKIP_PROP,
-      ...PROJECTION_PROPS,
-      cursor: CURSOR_PROP,
-      distinct: DISTINCT_PROP,
-    },
-  }
-}
-
-function findUniqueBodySchema(): SchemaObject {
-  return {
-    type: 'object',
-    properties: {
-      where: { type: 'object', description: 'Unique selector' },
-      ...PROJECTION_PROPS,
-    },
-    required: ['where'],
-  }
-}
-
-function countBodySchema(): SchemaObject {
-  return {
-    type: 'object',
-    properties: {
-      where: WHERE_PROP,
-      orderBy: { description: 'Sort order' },
-      take: TAKE_PROP,
-      skip: SKIP_PROP,
-      cursor: CURSOR_PROP,
-      select: {
-        description:
-          'Count specific fields. When provided, returns per-field counts as an object instead of a single integer.',
-      },
-    },
-  }
-}
-
-function aggregateBodySchema(): SchemaObject {
-  return {
-    type: 'object',
-    properties: {
-      where: WHERE_PROP,
-      orderBy: { description: 'Sort order' },
-      cursor: CURSOR_PROP,
-      take: TAKE_PROP,
-      skip: SKIP_PROP,
-      ...AGGREGATE_PROPS,
-    },
-  }
-}
-
-function groupByBodySchema(): SchemaObject {
-  return {
-    type: 'object',
-    properties: {
-      by: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Fields to group by',
-      },
-      where: WHERE_PROP,
-      orderBy: { description: 'Sort order. Required when using skip or take.' },
-      having: {
-        type: 'object',
-        description: 'Having conditions (filter object)',
-      },
-      take: TAKE_PROP,
-      skip: SKIP_PROP,
-      ...AGGREGATE_PROPS,
-    },
-    required: ['by'],
-  }
-}
-
-const POST_READ_BODY_SCHEMAS: Record<string, () => SchemaObject> = {
-  findMany: findManyBodySchema,
-  findFirst: findManyBodySchema,
-  findFirstOrThrow: findManyBodySchema,
-  findManyPaginated: findManyBodySchema,
-  findUnique: findUniqueBodySchema,
-  findUniqueOrThrow: findUniqueBodySchema,
-  count: countBodySchema,
-  aggregate: aggregateBodySchema,
-  groupBy: groupByBodySchema,
-}
-
-function getPostReadBodySchema(opName: string): SchemaObject {
-  return (POST_READ_BODY_SCHEMAS[opName] ?? findManyBodySchema)()
-}
+import { getPostReadBodySchema } from './operationSchemas'
 
 function applyWriteStrategy(
   spec: OpenApiSpec,
@@ -304,14 +291,14 @@ function applyWriteStrategy(
   }
 
   const injectProjectionAndArrayResponse = (
-    op: any,
+    op: OperationObject,
     successCode: '200' | '201',
     summary: string,
     description: string,
   ): void => {
     op.summary = summary
     op.description = description
-    const r = op.responses?.[successCode]
+    const r = op.responses[successCode]
     if (r?.content?.['application/json']) {
       r.content['application/json'].schema = {
         type: 'array',
@@ -319,7 +306,7 @@ function applyWriteStrategy(
       }
     }
     const reqSchema = op.requestBody?.content?.['application/json']?.schema
-    if (reqSchema && reqSchema.properties) {
+    if (reqSchema && !('$ref' in reqSchema) && reqSchema.properties) {
       Object.assign(reqSchema.properties, PROJECTION_PROPS)
     }
   }
@@ -330,8 +317,18 @@ function applyWriteStrategy(
     verb: string
     targetOp: string
   }> = [
-    { method: 'post', successCode: '201', verb: 'Create', targetOp: 'createManyAndReturn' },
-    { method: 'put',  successCode: '200', verb: 'Update', targetOp: 'updateManyAndReturn' },
+    {
+      method: 'post',
+      successCode: '201',
+      verb: 'Create',
+      targetOp: 'createManyAndReturn',
+    },
+    {
+      method: 'put',
+      successCode: '200',
+      verb: 'Update',
+      targetOp: 'updateManyAndReturn',
+    },
   ]
 
   for (const entry of forceReturnOps) {
@@ -341,9 +338,11 @@ function applyWriteStrategy(
       target,
       entry.successCode,
       entry.verb + ' many ' + modelName + ' (forceReturn)',
-      'writeStrategy="forceReturn": this endpoint silently invokes ' + entry.targetOp +
-      ' and returns the ' + (entry.verb === 'Create' ? 'created' : 'updated') +
-      ' records instead of { count }.',
+      'writeStrategy="forceReturn": this endpoint silently invokes ' +
+        entry.targetOp +
+        ' and returns the ' +
+        (entry.verb === 'Create' ? 'created' : 'updated') +
+        ' records instead of { count }.',
     )
   }
 }
@@ -382,7 +381,9 @@ export function buildModelOpenApi(
   const basePath =
     normalizePrefix(prefixSource) +
     removeTrailingSlash(
-      config.addModelPrefix !== false ? `/${modelName.toLowerCase()}` : '',
+      config.addModelPrefix !== false
+        ? `/${options.pathSegment ?? modelName.toLowerCase()}`
+        : '',
     )
 
   const referencedEnumTypes = new Set(
@@ -757,11 +758,11 @@ function addPostReadOperation(
   modelName: string,
   opName: string,
   summary: string,
-  responseSchema: any,
+  responseSchema: SchemaObject | RefObject,
   errorCodes: readonly number[],
   description?: string,
 ) {
-  const op: any = {
+  const op: OperationObject = {
     tags: [modelName],
     summary: summary + ' (POST)',
     operationId: `${modelName}${opName.charAt(0).toUpperCase() + opName.slice(1)}Post`,
@@ -794,24 +795,51 @@ function generatePaths(
   config: RouteConfig,
   fields: ModelField[],
 ) {
-  const postReads = !config.disablePostReads
+  const postReadsFor = (op: string): boolean => {
+    const raw: unknown = (config as Record<string, unknown>)[op]
+    const opValue =
+      raw && typeof raw === 'object'
+        ? (raw as { disablePostReads?: boolean }).disablePostReads
+        : undefined
+    return !(opValue ?? config.disablePostReads ?? false)
+  }
 
-  const createInputRef = { $ref: `#/components/schemas/${modelName}CreateInput` }
-  const updateInputRef = { $ref: `#/components/schemas/${modelName}UpdateInput` }
-  const createManyInputRef = { $ref: `#/components/schemas/${modelName}CreateManyInput` }
-  const updateManyMutationRef = { $ref: `#/components/schemas/${modelName}UpdateManyMutationInput` }
+  const createInputRef = {
+    $ref: `#/components/schemas/${modelName}CreateInput`,
+  }
+  const updateInputRef = {
+    $ref: `#/components/schemas/${modelName}UpdateInput`,
+  }
+  const createManyInputRef = {
+    $ref: `#/components/schemas/${modelName}CreateManyInput`,
+  }
+  const updateManyMutationRef = {
+    $ref: `#/components/schemas/${modelName}UpdateManyMutationInput`,
+  }
   const responseRef = { $ref: `#/components/schemas/${modelName}Response` }
-  const nullableResponseSchema = { oneOf: [responseRef, { type: 'null' as const }] }
-  const batchCountRef = { $ref: `#/components/schemas/${modelName}BatchCountResponse` }
+  const nullableResponseSchema = {
+    oneOf: [responseRef, { type: 'null' as const }],
+  }
+  const batchCountRef = {
+    $ref: `#/components/schemas/${modelName}BatchCountResponse`,
+  }
   const listRef = { $ref: `#/components/schemas/${modelName}ListResponse` }
-  const aggregateRef = { $ref: `#/components/schemas/${modelName}AggregateResponse` }
-  const groupByItemRef = { $ref: `#/components/schemas/${modelName}GroupByItem` }
-  const updateEachItemRef = { $ref: `#/components/schemas/${modelName}UpdateEachItemInput` }
-  const updateEachResponseRef = { $ref: `#/components/schemas/${modelName}UpdateEachResponse` }
+  const aggregateRef = {
+    $ref: `#/components/schemas/${modelName}AggregateResponse`,
+  }
+  const groupByItemRef = {
+    $ref: `#/components/schemas/${modelName}GroupByItem`,
+  }
+  const updateEachItemRef = {
+    $ref: `#/components/schemas/${modelName}UpdateEachItemInput`,
+  }
+  const updateEachResponseRef = {
+    $ref: `#/components/schemas/${modelName}UpdateEachResponse`,
+  }
 
   if (opEnabled(config, 'findMany')) {
     const meta = OPERATION_BY_NAME['findMany']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `List ${modelName}`,
       operationId: `${modelName}FindMany`,
@@ -830,7 +858,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findMany'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findMany')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findMany'),
@@ -845,7 +873,7 @@ function generatePaths(
 
   if (opEnabled(config, 'findUnique')) {
     const meta = OPERATION_BY_NAME['findUnique']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Get ${modelName} by unique constraint`,
       operationId: `${modelName}FindUnique`,
@@ -862,7 +890,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findUnique'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findUnique')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findUnique'),
@@ -878,7 +906,7 @@ function generatePaths(
 
   if (opEnabled(config, 'findUniqueOrThrow')) {
     const meta = OPERATION_BY_NAME['findUniqueOrThrow']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Get ${modelName} by unique constraint (throws if not found)`,
       operationId: `${modelName}FindUniqueOrThrow`,
@@ -893,7 +921,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findUniqueOrThrow'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findUniqueOrThrow')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findUniqueOrThrow'),
@@ -908,7 +936,7 @@ function generatePaths(
 
   if (opEnabled(config, 'findFirst')) {
     const meta = OPERATION_BY_NAME['findFirst']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Get first ${modelName}`,
       operationId: `${modelName}FindFirst`,
@@ -924,7 +952,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findFirst'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findFirst')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findFirst'),
@@ -940,7 +968,7 @@ function generatePaths(
 
   if (opEnabled(config, 'findFirstOrThrow')) {
     const meta = OPERATION_BY_NAME['findFirstOrThrow']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Get first ${modelName} (throws if not found)`,
       operationId: `${modelName}FindFirstOrThrow`,
@@ -955,7 +983,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findFirstOrThrow'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findFirstOrThrow')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findFirstOrThrow'),
@@ -970,7 +998,7 @@ function generatePaths(
 
   if (opEnabled(config, 'findManyPaginated')) {
     const meta = OPERATION_BY_NAME['findManyPaginated']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `List ${modelName} with pagination`,
       operationId: `${modelName}FindManyPaginated`,
@@ -987,7 +1015,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findManyPaginated'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findManyPaginated')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findManyPaginated'),
@@ -1003,7 +1031,7 @@ function generatePaths(
 
   if (opEnabled(config, 'create')) {
     const meta = OPERATION_BY_NAME['create']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Create ${modelName}`,
       operationId: `${modelName}Create`,
@@ -1035,7 +1063,7 @@ function generatePaths(
 
   if (opEnabled(config, 'createMany')) {
     const meta = OPERATION_BY_NAME['createMany']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Create many ${modelName}`,
       operationId: `${modelName}CreateMany`,
@@ -1071,7 +1099,7 @@ function generatePaths(
 
   if (opEnabled(config, 'createManyAndReturn')) {
     const meta = OPERATION_BY_NAME['createManyAndReturn']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Create many ${modelName} and return records`,
       operationId: `${modelName}CreateManyAndReturn`,
@@ -1112,7 +1140,7 @@ function generatePaths(
 
   if (opEnabled(config, 'update')) {
     const meta = OPERATION_BY_NAME['update']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Update ${modelName}`,
       operationId: `${modelName}Update`,
@@ -1145,7 +1173,7 @@ function generatePaths(
 
   if (opEnabled(config, 'updateMany')) {
     const meta = OPERATION_BY_NAME['updateMany']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Update many ${modelName}`,
       operationId: `${modelName}UpdateMany`,
@@ -1177,7 +1205,7 @@ function generatePaths(
 
   if (opEnabled(config, 'updateManyAndReturn')) {
     const meta = OPERATION_BY_NAME['updateManyAndReturn']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Update many ${modelName} and return records`,
       operationId: `${modelName}UpdateManyAndReturn`,
@@ -1214,7 +1242,7 @@ function generatePaths(
 
   if (opEnabled(config, 'upsert')) {
     const meta = OPERATION_BY_NAME['upsert']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Upsert ${modelName}`,
       operationId: `${modelName}Upsert`,
@@ -1248,7 +1276,7 @@ function generatePaths(
 
   if (opEnabled(config, 'delete')) {
     const meta = OPERATION_BY_NAME['delete']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Delete ${modelName}`,
       operationId: `${modelName}Delete`,
@@ -1280,7 +1308,7 @@ function generatePaths(
 
   if (opEnabled(config, 'deleteMany')) {
     const meta = OPERATION_BY_NAME['deleteMany']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Delete many ${modelName}`,
       operationId: `${modelName}DeleteMany`,
@@ -1309,7 +1337,7 @@ function generatePaths(
 
   if (opEnabled(config, 'count')) {
     const meta = OPERATION_BY_NAME['count']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Count ${modelName}`,
       operationId: `${modelName}Count`,
@@ -1327,7 +1355,8 @@ function generatePaths(
                   },
                   {
                     type: 'object',
-                    description: 'Per-field count object when select is provided',
+                    description:
+                      'Per-field count object when select is provided',
                   },
                 ],
               },
@@ -1339,7 +1368,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'count'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('count')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'count'),
@@ -1365,7 +1394,7 @@ function generatePaths(
 
   if (opEnabled(config, 'aggregate')) {
     const meta = OPERATION_BY_NAME['aggregate']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Aggregate ${modelName}`,
       operationId: `${modelName}Aggregate`,
@@ -1380,7 +1409,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'aggregate'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('aggregate')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'aggregate'),
@@ -1395,7 +1424,7 @@ function generatePaths(
 
   if (opEnabled(config, 'groupBy')) {
     const meta = OPERATION_BY_NAME['groupBy']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Group ${modelName}`,
       operationId: `${modelName}GroupBy`,
@@ -1416,7 +1445,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'groupBy'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('groupBy')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'groupBy'),
@@ -1432,7 +1461,7 @@ function generatePaths(
 
   if (opEnabled(config, 'updateEach')) {
     const meta = OPERATION_BY_NAME['updateEach']
-    const op: any = {
+    const op: OperationObject = {
       tags: [modelName],
       summary: `Update each ${modelName} (batch)`,
       operationId: `${modelName}UpdateEach`,
@@ -1479,7 +1508,7 @@ function addPath(
   spec: OpenApiSpec,
   path: string,
   method: string,
-  operation: any,
+  operation: OperationObject,
 ) {
   if (!spec.paths[path]) {
     spec.paths[path] = {}
@@ -1581,12 +1610,30 @@ function mapFieldToSchema(field: ModelField): SchemaObject | RefObject {
 }
 
 function nestedListRelationOps(fieldType: string): SchemaObject {
-  const createInput: SchemaObject = { type: 'object', description: `${fieldType} create input` }
-  const uniqueId: SchemaObject = { type: 'object', description: 'Unique identifier' }
-  const uniqueConnect: SchemaObject = { type: 'object', description: 'Unique identifier to connect' }
-  const uniqueDisconnect: SchemaObject = { type: 'object', description: 'Unique identifier to disconnect' }
-  const uniqueDelete: SchemaObject = { type: 'object', description: 'Unique identifier to delete' }
-  const whereFilter: SchemaObject = { type: 'object', description: 'Where filter' }
+  const createInput: SchemaObject = {
+    type: 'object',
+    description: `${fieldType} create input`,
+  }
+  const uniqueId: SchemaObject = {
+    type: 'object',
+    description: 'Unique identifier',
+  }
+  const uniqueConnect: SchemaObject = {
+    type: 'object',
+    description: 'Unique identifier to connect',
+  }
+  const uniqueDisconnect: SchemaObject = {
+    type: 'object',
+    description: 'Unique identifier to disconnect',
+  }
+  const uniqueDelete: SchemaObject = {
+    type: 'object',
+    description: 'Unique identifier to delete',
+  }
+  const whereFilter: SchemaObject = {
+    type: 'object',
+    description: 'Where filter',
+  }
   const whereCreatePair: SchemaObject = {
     type: 'object',
     description: '{ where, create } pair',
@@ -1648,12 +1695,16 @@ function nestedSingleRelationOps(fieldType: string): SchemaObject {
         description: '{ where, create } pair',
         properties: { where: { type: 'object' }, create: { type: 'object' } },
       },
-      disconnect: { type: 'boolean', description: 'Disconnect the related record' },
+      disconnect: {
+        type: 'boolean',
+        description: 'Disconnect the related record',
+      },
       delete: { type: 'boolean', description: 'Delete the related record' },
       update: { type: 'object', description: `${fieldType} update input` },
       upsert: {
         type: 'object',
-        description: '{ create, update } pair — create if not exists, update if exists',
+        description:
+          '{ create, update } pair — create if not exists, update if exists',
         properties: {
           create: { type: 'object', description: `${fieldType} create input` },
           update: { type: 'object', description: `${fieldType} update input` },
@@ -1668,7 +1719,9 @@ function mapFieldToWriteSchema(
   mode: 'create' | 'update',
 ): SchemaObject | RefObject {
   if (field.kind === 'object') {
-    return field.isList ? nestedListRelationOps(field.type) : nestedSingleRelationOps(field.type)
+    return field.isList
+      ? nestedListRelationOps(field.type)
+      : nestedSingleRelationOps(field.type)
   }
 
   let baseSchema: SchemaObject | RefObject
@@ -1733,4 +1786,4 @@ function mapScalarType(type: string): SchemaObject {
     },
   }
   return typeMap[type] || { type: 'string' }
-}
+}