prisma-generator-express 1.66.0 → 1.67.0

package/src/copy/autoIncludeRuntimeGuarded.ts

@@ -90,7 +90,10 @@ function guarded(
   return d.guard(shape, caller) as GuardedDelegate
 }
 
-function createClientGoneChecker(res: Response, signal?: AbortSignal): () => boolean {
+function createClientGoneChecker(
+  res: Response,
+  signal?: AbortSignal,
+): () => boolean {
   return () => signal?.aborted === true || res.writableEnded || res.destroyed
 }
 
@@ -178,7 +181,10 @@ async function runStage(
 
   const targetModel = models[rel.type]
   if (!targetModel) {
-    throw new HttpError(500, 'Target model not in relation metadata: ' + rel.type)
+    throw new HttpError(
+      500,
+      'Target model not in relation metadata: ' + rel.type,
+    )
   }
 
   const stageArgs: Record<string, unknown> = { ...stage.stageArgs }
@@ -289,14 +295,24 @@ async function runGuardedAutoIncludeSingle(
         if (!okField) return
       } catch (err) {
         if (isAborted()) return
-        console.error(LOG_PREFIX, 'guarded stage failed:', stage.relationPath, err)
+        console.error(
+          LOG_PREFIX,
+          'guarded stage failed:',
+          stage.relationPath,
+          err,
+        )
         stageErrorMessage = mapError(err).message
         return
       }
 
       if (isAborted()) return
       completed++
-      const okProg = sendSSEProgress(res, stage.relationPath, completed, plan.stages.length)
+      const okProg = sendSSEProgress(
+        res,
+        stage.relationPath,
+        completed,
+        plan.stages.length,
+      )
       if (!okProg) return
     })
 
@@ -336,7 +352,8 @@ export async function runGuardedAutoIncludeProgressive(
   } catch (err) {
     return handleGuardedFallback(
       options,
-      'guarded auto-progressive fallback: getExtendedClient failed: ' + mapError(err).message,
+      'guarded auto-progressive fallback: getExtendedClient failed: ' +
+        mapError(err).message,
     )
   }
 
@@ -352,7 +369,8 @@ export async function runGuardedAutoIncludeProgressive(
   } catch (err) {
     return handleGuardedFallback(
       options,
-      'guarded auto-progressive fallback: resolve failed: ' + mapError(err).message,
+      'guarded auto-progressive fallback: resolve failed: ' +
+        mapError(err).message,
     )
   }
 
@@ -376,4 +394,4 @@ export async function runGuardedAutoIncludeProgressive(
   }
 
   return runGuardedAutoIncludeSingle(options, plan, extended)
-}
+}

package/src/copy/buildModelOpenApi.ts

@@ -55,22 +55,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,
@@ -330,8 +367,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 +388,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 +431,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(
@@ -794,20 +845,47 @@ 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']
@@ -830,7 +908,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findMany'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findMany')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findMany'),
@@ -862,7 +940,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findUnique'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findUnique')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findUnique'),
@@ -893,7 +971,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findUniqueOrThrow'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findUniqueOrThrow')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findUniqueOrThrow'),
@@ -924,7 +1002,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findFirst'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findFirst')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findFirst'),
@@ -955,7 +1033,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findFirstOrThrow'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findFirstOrThrow')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findFirstOrThrow'),
@@ -987,7 +1065,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'findManyPaginated'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('findManyPaginated')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'findManyPaginated'),
@@ -1327,7 +1405,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 +1418,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'count'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('count')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'count'),
@@ -1380,7 +1459,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'aggregate'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('aggregate')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'aggregate'),
@@ -1416,7 +1495,7 @@ function generatePaths(
     addErrorResponses(op, meta.errors)
     addPath(spec, opPath(basePath, 'groupBy'), 'get', op)
 
-    if (postReads) {
+    if (postReadsFor('groupBy')) {
       addPostReadOperation(
         spec,
         postReadPath(basePath, 'groupBy'),
@@ -1581,12 +1660,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 +1745,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 +1769,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 +1836,4 @@ function mapScalarType(type: string): SchemaObject {
     },
   }
   return typeMap[type] || { type: 'string' }
-}
+}

package/src/copy/concurrency.ts

@@ -8,13 +8,15 @@ export async function mapLimited<T>(
   const workerCount = Math.min(limit, items.length)
   const workers: Promise<void>[] = []
   for (let w = 0; w < workerCount; w++) {
-    workers.push((async () => {
-      for (;;) {
-        const i = index++
-        if (i >= items.length) return
-        await fn(items[i], i)
-      }
-    })())
+    workers.push(
+      (async () => {
+        for (;;) {
+          const i = index++
+          if (i >= items.length) return
+          await fn(items[i], i)
+        }
+      })(),
+    )
   }
   await Promise.all(workers)
-}
+}

package/src/copy/errorMapper.ts

@@ -36,10 +36,19 @@ const PRISMA_ERROR_MAP: Record<string, { status: number; message: string }> = {
   P2023: { status: 500, message: 'Inconsistent column data' },
   P2024: { status: 503, message: 'Connection pool timeout' },
   P2025: { status: 404, message: 'Record not found' },
-  P2026: { status: 501, message: 'Feature not supported by the current database provider' },
-  P2027: { status: 400, message: 'Multiple errors occurred during transaction execution' },
+  P2026: {
+    status: 501,
+    message: 'Feature not supported by the current database provider',
+  },
+  P2027: {
+    status: 400,
+    message: 'Multiple errors occurred during transaction execution',
+  },
   P2028: { status: 500, message: 'Transaction API error' },
-  P2030: { status: 400, message: 'Cannot find a fulltext index for the search' },
+  P2030: {
+    status: 400,
+    message: 'Cannot find a fulltext index for the search',
+  },
   P2033: { status: 400, message: 'Number out of range for the field type' },
   P2034: { status: 409, message: 'Transaction conflict, please retry' },
 }
@@ -59,11 +68,20 @@ function asErrorShape(error: unknown): ErrorShape {
 }
 
 function isProduction(): boolean {
-  return typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'production'
+  return (
+    typeof process !== 'undefined' &&
+    process.env &&
+    process.env.NODE_ENV === 'production'
+  )
 }
 
 function isHttpStatus(value: unknown): value is number {
-  return typeof value === 'number' && Number.isInteger(value) && value >= 400 && value <= 599
+  return (
+    typeof value === 'number' &&
+    Number.isInteger(value) &&
+    value >= 400 &&
+    value <= 599
+  )
 }
 
 export function mapError(error: unknown): HttpError {
@@ -77,18 +95,27 @@ export function mapError(error: unknown): HttpError {
       ? e.statusCode
       : null
   if (duckStatus !== null) {
-    const detail = typeof e.message === 'string' && e.message ? e.message : 'Internal server error'
+    const detail =
+      typeof e.message === 'string' && e.message
+        ? e.message
+        : 'Internal server error'
     return new HttpError(duckStatus, detail)
   }
 
-  if (e.name === 'ShapeError') return new HttpError(400, e.message || 'Shape validation failed')
-  if (e.name === 'CallerError') return new HttpError(400, e.message || 'Caller validation failed')
-  if (e.name === 'PolicyError') return new HttpError(403, e.message || 'Policy denied')
+  if (e.name === 'ShapeError')
+    return new HttpError(400, e.message || 'Shape validation failed')
+  if (e.name === 'CallerError')
+    return new HttpError(400, e.message || 'Caller validation failed')
+  if (e.name === 'PolicyError')
+    return new HttpError(403, e.message || 'Policy denied')
   if (e.name === 'ZodError') {
     const issues = e.issues
     const message = Array.isArray(issues)
-      ? (issues as Array<{ message?: string }>).map((i) => i.message ?? '').filter(Boolean).join('; ')
-      : (e.message || 'Validation failed')
+      ? (issues as Array<{ message?: string }>)
+          .map((i) => i.message ?? '')
+          .filter(Boolean)
+          .join('; ')
+      : e.message || 'Validation failed'
     return new HttpError(400, message)
   }
   if (typeof e.code === 'string') {
@@ -98,7 +125,9 @@ export function mapError(error: unknown): HttpError {
       const shouldStripDetail = isProd && mapped.status >= 500
       return new HttpError(
         mapped.status,
-        !shouldStripDetail && detail ? mapped.message + ': ' + detail : mapped.message,
+        !shouldStripDetail && detail
+          ? mapped.message + ': ' + detail
+          : mapped.message,
       )
     }
     if (e.code.startsWith('P')) {
@@ -108,19 +137,39 @@ export function mapError(error: unknown): HttpError {
     }
   }
   if (typeof e.name === 'string') {
-    if (e.name === 'PrismaClientValidationError') return new HttpError(400, e.message || 'Invalid query parameters')
-    if (e.name === 'PrismaClientKnownRequestError') return new HttpError(400, e.message || 'Database request error')
+    if (e.name === 'PrismaClientValidationError')
+      return new HttpError(400, e.message || 'Invalid query parameters')
+    if (e.name === 'PrismaClientKnownRequestError')
+      return new HttpError(400, e.message || 'Database request error')
     if (e.name === 'PrismaClientInitializationError') {
-      return new HttpError(503, isProd ? 'Service unavailable' : (e.message || 'Database connection failed'))
+      return new HttpError(
+        503,
+        isProd
+          ? 'Service unavailable'
+          : e.message || 'Database connection failed',
+      )
     }
     if (e.name === 'PrismaClientRustPanicError') {
-      return new HttpError(500, isProd ? 'Internal server error' : (e.message || 'Internal database engine error'))
+      return new HttpError(
+        500,
+        isProd
+          ? 'Internal server error'
+          : e.message || 'Internal database engine error',
+      )
     }
     if (e.name === 'PrismaClientUnknownRequestError') {
-      return new HttpError(500, isProd ? 'Internal server error' : (e.message || 'Unknown database error'))
+      return new HttpError(
+        500,
+        isProd
+          ? 'Internal server error'
+          : e.message || 'Unknown database error',
+      )
     }
   }
   const msg = error instanceof Error ? error.message : String(error)
   console.error(LOG_PREFIX, 'Unhandled error:', error)
-  return new HttpError(500, isProd ? 'Internal server error' : (msg || 'Internal server error'))
-}
+  return new HttpError(
+    500,
+    isProd ? 'Internal server error' : msg || 'Internal server error',
+  )
+}

package/src/copy/guardHelpers.ts

@@ -3,12 +3,17 @@ import { HttpError } from './errorMapper'
 export type PrismaDelegateLike = {
   count: (args?: unknown) => Promise<unknown>
   findMany: (args?: unknown) => Promise<unknown>
-  guard?: (shape: Record<string, unknown>, caller?: string) => PrismaDelegateLike
+  guard?: (
+    shape: Record<string, unknown>,
+    caller?: string,
+  ) => PrismaDelegateLike
 }
 
-export function assertGuard(
-  delegate: PrismaDelegateLike,
-): asserts delegate is PrismaDelegateLike & { guard: NonNullable<PrismaDelegateLike['guard']> } {
+export function assertGuard<T extends PrismaDelegateLike>(
+  delegate: T,
+): asserts delegate is T & {
+  guard: NonNullable<T['guard']>
+} {
   if (typeof delegate.guard !== 'function') {
     throw new HttpError(
       500,
@@ -18,9 +23,24 @@ export function assertGuard(
 }
 
 export const GUARD_SHAPE_CONFIG_KEYS = new Set([
-  'data', 'create', 'update', 'where', 'include', 'select', 'orderBy',
-  'cursor', 'take', 'skip', 'distinct', 'having', '_count', '_avg',
-  '_sum', '_min', '_max', 'by',
+  'data',
+  'create',
+  'update',
+  'where',
+  'include',
+  'select',
+  'orderBy',
+  'cursor',
+  'take',
+  'skip',
+  'distinct',
+  'having',
+  '_count',
+  '_avg',
+  '_sum',
+  '_min',
+  '_max',
+  'by',
 ])
 
 function keepWhereOnly(obj: Record<string, unknown>): Record<string, unknown> {
@@ -39,7 +59,8 @@ export function buildCountShape(
     return (...args: unknown[]) => keepWhereOnly(fn(...args))
   }
   const keys = Object.keys(shape)
-  const isSingleShape = keys.length === 0 || keys.every((k) => GUARD_SHAPE_CONFIG_KEYS.has(k))
+  const isSingleShape =
+    keys.length === 0 || keys.every((k) => GUARD_SHAPE_CONFIG_KEYS.has(k))
   if (isSingleShape) return keepWhereOnly(shape)
   const result: Record<string, unknown> = {}
   for (const [key, variant] of Object.entries(shape)) {
@@ -53,4 +74,4 @@ export function buildCountShape(
     }
   }
   return result
-}
+}