prisma-generator-express 1.59.0 → 1.60.0

package/src/copy/concurrency.ts

@@ -0,0 +1,20 @@
+export async function mapLimited<T>(
+  items: T[],
+  limit: number,
+  fn: (item: T, index: number) => Promise<void>,
+): Promise<void> {
+  if (items.length === 0) return
+  let index = 0
+  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)
+      }
+    })())
+  }
+  await Promise.all(workers)
+}

package/src/copy/docsRenderer.ts

@@ -1,10 +1,12 @@
 import type { RouteConfig, WriteStrategy } from './routeConfig'
 import {
-  OPERATION_DEFS,
+  OPERATION_METADATA,
+  OPERATION_BY_NAME,
   isOperationEnabled,
   READ_OPERATION_NAMES,
 } from './operationDefinitions'
 import { getEnv, normalizePrefix } from './misc'
+import { NUMERIC_SCALAR_TYPES } from './scalarTypes'
 
 const _env = getEnv()
 
@@ -44,10 +46,10 @@ export interface DocsModelContext {
 
 interface OpDetail {
   transport: string
-  required: string[]
+  required: readonly string[]
   optional: string[]
   responseDesc: string
-  errors: number[]
+  errors: readonly number[]
   supportsSelect: boolean
   supportsInclude: boolean
   supportsOmit: boolean
@@ -60,295 +62,27 @@ const PRISM_JS = 'https://cdn.jsdelivr.net/npm/prismjs@1/prism.min.js'
 const PRISM_JSON =
   'https://cdn.jsdelivr.net/npm/prismjs@1/components/prism-json.min.js'
 
-const OP_DETAIL_MAP: Record<string, OpDetail> = {
-  findMany: {
-    transport: 'GET query params',
-    required: [],
-    optional: [
-      'where',
-      'select',
-      'include',
-      'omit',
-      'orderBy',
-      'cursor',
-      'take',
-      'skip',
-      'distinct',
-    ],
-    responseDesc: 'Array of records',
-    errors: [400, 403, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes: 'Pagination limits may apply when configured.',
-  },
-  findUnique: {
-    transport: 'GET query params',
-    required: ['where'],
-    optional: ['select', 'include', 'omit'],
-    responseDesc: 'Single record or null',
-    errors: [400, 403, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes: 'Returns null (not 404) when no record matches.',
-  },
-  findUniqueOrThrow: {
-    transport: 'GET query params',
-    required: ['where'],
-    optional: ['select', 'include', 'omit'],
-    responseDesc: 'Single record',
-    errors: [400, 403, 404, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes: 'Returns 404 when no record matches.',
-  },
-  findFirst: {
-    transport: 'GET query params',
-    required: [],
-    optional: [
-      'where',
-      'select',
-      'include',
-      'omit',
-      'orderBy',
-      'cursor',
-      'take',
-      'skip',
-      'distinct',
-    ],
-    responseDesc: 'Single record or null',
-    errors: [400, 403, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes: 'Returns null (not 404) when no record matches.',
-  },
-  findFirstOrThrow: {
-    transport: 'GET query params',
-    required: [],
-    optional: [
-      'where',
-      'select',
-      'include',
-      'omit',
-      'orderBy',
-      'cursor',
-      'take',
-      'skip',
-      'distinct',
-    ],
-    responseDesc: 'Single record',
-    errors: [400, 403, 404, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes: 'Returns 404 when no record matches.',
-  },
-  findManyPaginated: {
-    transport: 'GET query params',
-    required: [],
-    optional: [
-      'where',
-      'select',
-      'include',
-      'omit',
-      'orderBy',
-      'cursor',
-      'take',
-      'skip',
-      'distinct',
-    ],
-    responseDesc: '{ data: Record[], total: number, hasMore: boolean }',
-    errors: [400, 403, 409, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes:
-      'Wraps findMany with total count. hasMore is reliable for forward offset pagination (skip + take) only. Distinct count over 100k falls back to approximate total. 409 possible on transaction conflict.',
-  },
-  create: {
-    transport: 'POST JSON body',
-    required: ['data'],
-    optional: ['select', 'include', 'omit'],
-    responseDesc: 'Created record (201)',
-    errors: [400, 403, 409, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes: '409 on unique constraint violation.',
-  },
-  createMany: {
-    transport: 'POST JSON body',
-    required: ['data'],
-    optional: ['skipDuplicates'],
-    responseDesc: '{ count: number } (201)',
-    errors: [400, 403, 409, 500, 501, 503],
-    supportsSelect: false,
-    supportsInclude: false,
-    supportsOmit: false,
-    notes:
-      'data is an array of scalar-only inputs. Nested relation writes are not supported. skipDuplicates silently ignores conflicts (not supported on all providers).',
-  },
-  createManyAndReturn: {
-    transport: 'POST JSON body',
-    required: ['data'],
-    optional: ['skipDuplicates', 'select', 'include', 'omit'],
-    responseDesc: 'Array of created records (201)',
-    errors: [400, 403, 409, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes:
-      'Like createMany but returns created records. data items are scalar-only. Requires Prisma 5.14.0+, PostgreSQL/CockroachDB/SQLite only. The order of returned records is not guaranteed.',
-  },
-  update: {
-    transport: 'PUT JSON body',
-    required: ['where', 'data'],
-    optional: ['select', 'include', 'omit'],
-    responseDesc: 'Updated record',
-    errors: [400, 403, 404, 409, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes:
-      '404 when the record to update is not found. 409 on unique constraint violation or transaction conflict.',
-  },
-  updateEach: {
-    transport: 'POST JSON body (array)',
-    required: ['array of { where, data }'],
-    optional: [],
-    responseDesc:
-      'Non-atomic: per-row { status, data } / { status, error } array. Atomic: array of records.',
-    errors: [400, 403, 409, 500, 501, 503],
-    supportsSelect: false,
-    supportsInclude: false,
-    supportsOmit: false,
-    notes:
-      'Internal batch endpoint. Bypasses guard shapes. Not enabled by enableAll. Non-atomic max 1000 items, atomic max 100 items. Header x-batch-atomic:true switches to transactional mode.',
-  },
-  updateMany: {
-    transport: 'PUT JSON body',
-    required: ['where', 'data'],
-    optional: [],
-    responseDesc: '{ count: number }',
-    errors: [400, 403, 409, 500, 501, 503],
-    supportsSelect: false,
-    supportsInclude: false,
-    supportsOmit: false,
-    notes:
-      'Updates all matching records with scalar-only data. Nested relation writes are not supported. Returns count, not records. 409 on unique constraint violation.',
-  },
-  updateManyAndReturn: {
-    transport: 'PUT JSON body',
-    required: ['where', 'data'],
-    optional: ['select', 'include', 'omit'],
-    responseDesc: 'Array of updated records',
-    errors: [400, 403, 409, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes:
-      'Like updateMany but returns updated records. data is scalar-only. Requires Prisma 6.2.0+, PostgreSQL/CockroachDB/SQLite only. 409 on unique constraint violation.',
-  },
-  upsert: {
-    transport: 'PATCH JSON body',
-    required: ['where', 'create', 'update'],
-    optional: ['select', 'include', 'omit'],
-    responseDesc: 'Created or updated record',
-    errors: [400, 403, 409, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes: 'Creates if not found, updates if found.',
-  },
-  delete: {
-    transport: 'DELETE JSON body',
-    required: ['where'],
-    optional: ['select', 'include', 'omit'],
-    responseDesc: 'Deleted record',
-    errors: [400, 403, 404, 500, 501, 503],
-    supportsSelect: true,
-    supportsInclude: true,
-    supportsOmit: true,
-    notes: '404 when the record to delete is not found.',
-  },
-  deleteMany: {
-    transport: 'DELETE JSON body',
-    required: ['where'],
-    optional: [],
-    responseDesc: '{ count: number }',
-    errors: [400, 403, 500, 501, 503],
-    supportsSelect: false,
-    supportsInclude: false,
-    supportsOmit: false,
-    notes: 'Deletes all matching records. Returns count, not records.',
-  },
-  count: {
-    transport: 'GET query params',
-    required: [],
-    optional: ['where', 'orderBy', 'cursor', 'take', 'skip', 'select'],
-    responseDesc: 'Integer, or per-field count object when select is provided',
-    errors: [400, 403, 500, 501, 503],
-    supportsSelect: false,
-    supportsInclude: false,
-    supportsOmit: false,
-    notes:
-      'select here means count-specific field selection, not record field selection.',
-  },
-  aggregate: {
-    transport: 'GET query params',
-    required: [],
-    optional: [
-      'where',
-      'orderBy',
-      'cursor',
-      'take',
-      'skip',
-      '_count',
-      '_avg',
-      '_sum',
-      '_min',
-      '_max',
-    ],
-    responseDesc:
-      'Object with requested aggregate fields (_count, _avg, _sum, _min, _max)',
-    errors: [400, 403, 500, 501, 503],
-    supportsSelect: false,
-    supportsInclude: false,
-    supportsOmit: false,
-    notes: '_avg, _sum only apply to numeric fields.',
-  },
-  groupBy: {
-    transport: 'GET query params',
-    required: ['by'],
-    optional: [
-      'where',
-      'orderBy',
-      'having',
-      'take',
-      'skip',
-      '_count',
-      '_avg',
-      '_sum',
-      '_min',
-      '_max',
-    ],
-    responseDesc:
-      'Array of objects, each with grouped field values and requested aggregates',
-    errors: [400, 403, 500, 501, 503],
-    supportsSelect: false,
-    supportsInclude: false,
-    supportsOmit: false,
-    notes:
-      'by is a JSON-encoded array of scalar field names. orderBy is required when using skip or take. Response contains only the by-fields plus requested aggregates.',
-  },
-}
+function detailForOp(
+  opName: string,
+  writeStrategy?: WriteStrategy,
+): OpDetail | null {
+  const meta = OPERATION_BY_NAME[opName]
+  if (!meta) return null
+
+  const optional = meta.argsSchema.filter((a) => !meta.requiredArgs.includes(a))
+
+  const base: OpDetail = {
+    transport: meta.transport,
+    required: meta.requiredArgs,
+    optional,
+    responseDesc: meta.responseDesc,
+    errors: meta.errors,
+    supportsSelect: meta.supportsProjection,
+    supportsInclude: meta.supportsProjection,
+    supportsOmit: meta.supportsProjection,
+    notes: meta.notes,
+  }
 
-function detailForOp(opName: string, writeStrategy?: WriteStrategy): OpDetail {
-  const base = OP_DETAIL_MAP[opName]
-  if (!base) return base
   if (writeStrategy === 'forceReturn') {
     if (opName === 'createMany') {
       return {
@@ -375,6 +109,7 @@ function detailForOp(opName: string, writeStrategy?: WriteStrategy): OpDetail {
       }
     }
   }
+
   return base
 }
 
@@ -570,14 +305,8 @@ function scalarFilterOperators(scalarType: string): string[] {
       'not',
     ]
   }
-  if (
-    scalarType === 'Int' ||
-    scalarType === 'BigInt' ||
-    scalarType === 'Float' ||
-    scalarType === 'Decimal'
-  ) {
+  if (NUMERIC_SCALAR_TYPES.has(scalarType))
     return ['equals', 'in', 'notIn', 'lt', 'lte', 'gt', 'gte', 'not']
-  }
   if (scalarType === 'DateTime')
     return ['equals', 'in', 'notIn', 'lt', 'lte', 'gt', 'gte', 'not']
   if (scalarType === 'Boolean') return ['equals', 'not']
@@ -696,19 +425,19 @@ export function renderDocs(
   const listRelations = relationFields.filter((f) => f.isList)
   const singleRelations = relationFields.filter((f) => !f.isList)
 
-  const getOps = OPERATION_DEFS.filter((d) =>
-    isOperationEnabled(config as Record<string, any>, d),
+  const getOps = OPERATION_METADATA.filter((meta) =>
+    isOperationEnabled(config as Record<string, any>, meta),
   )
-    .filter((d) => !isOpHiddenByStrategy(d.name, writeStrategy))
-    .map((d) => {
-      const detail = detailForOp(d.name, writeStrategy)
+    .filter((meta) => !isOpHiddenByStrategy(meta.name, writeStrategy))
+    .map((meta) => {
+      const detail = detailForOp(meta.name, writeStrategy)
       return {
-        op: d.name,
-        method: d.method.toUpperCase(),
-        path: buildFullPath(exampleBasePath, d.pathSuffix),
+        op: meta.name,
+        method: meta.method.toUpperCase(),
+        path: buildFullPath(exampleBasePath, meta.pathSuffix),
         transport: detail
           ? detail.transport
-          : d.method === 'get'
+          : meta.method === 'get'
             ? 'GET query params'
             : 'JSON body',
         responseDesc: detail ? detail.responseDesc : '',
@@ -723,32 +452,32 @@ export function renderDocs(
     })
 
   const postReadOps = postReadsEnabled
-    ? OPERATION_DEFS.filter(
-        (d) =>
-          READ_OPERATION_NAMES.has(d.name) &&
-          isOperationEnabled(config as Record<string, any>, d),
-      ).map((d) => {
-        const detail = OP_DETAIL_MAP[d.name]
-        const postPath =
-          d.name === 'findMany'
-            ? buildFullPath(exampleBasePath, '/read')
-            : buildFullPath(exampleBasePath, d.pathSuffix)
-        return {
-          op: d.name + ' (POST)',
-          method: 'POST',
-          path: postPath,
-          transport: 'POST JSON body',
-          responseDesc: detail ? detail.responseDesc : '',
-          errors: detail ? detail.errors.join(', ') : '',
-          required: detail ? detail.required : [],
-          optional: detail ? detail.optional : [],
-          supportsSelect: detail ? detail.supportsSelect : false,
-          supportsInclude: detail ? detail.supportsInclude : false,
-          supportsOmit: detail ? detail.supportsOmit : false,
-          notes:
-            'POST alternative for complex queries exceeding URL length limits. Same args as GET but in request body.',
-        }
-      })
+    ? OPERATION_METADATA.filter((meta) => READ_OPERATION_NAMES.has(meta.name))
+        .filter((meta) =>
+          isOperationEnabled(config as Record<string, any>, meta),
+        )
+        .map((meta) => {
+          const detail = detailForOp(meta.name)
+          const postPath =
+            meta.name === 'findMany'
+              ? buildFullPath(exampleBasePath, '/read')
+              : buildFullPath(exampleBasePath, meta.pathSuffix)
+          return {
+            op: meta.name + ' (POST)',
+            method: 'POST',
+            path: postPath,
+            transport: 'POST JSON body',
+            responseDesc: detail ? detail.responseDesc : '',
+            errors: detail ? detail.errors.join(', ') : '',
+            required: detail ? detail.required : [],
+            optional: detail ? detail.optional : [],
+            supportsSelect: detail ? detail.supportsSelect : false,
+            supportsInclude: detail ? detail.supportsInclude : false,
+            supportsOmit: detail ? detail.supportsOmit : false,
+            notes:
+              'POST alternative for complex queries exceeding URL length limits. Same args as GET but in request body.',
+          }
+        })
     : []
 
   const ops = [...getOps, ...postReadOps]
@@ -1301,6 +1030,7 @@ export function renderDocs(
     'hasMore is reliable for forward offset pagination (skip + take) only. With cursor pagination or negative take, hasMore may be inaccurate.',
     'When the server config sets pagination.defaultLimit, take is automatically applied to findMany and findManyPaginated if omitted.',
     'When the server config sets pagination.maxLimit, take is capped by absolute value to that limit for findMany and findManyPaginated. This applies to both positive and negative take values.',
+    'When maxLimit is set and take is a non-finite or non-integer value, the request is rejected with 400.',
     'Clients cannot detect these server-side limits from the API alone. Check with the API provider for configured limits.',
   ]
 

package/src/copy/errorMapper.ts

@@ -0,0 +1,126 @@
+export const LOG_PREFIX = '[auto-progressive]'
+
+export class HttpError extends Error {
+  status: number
+  constructor(status: number, message: string) {
+    super(message)
+    this.name = 'HttpError'
+    this.status = status
+  }
+}
+
+const PRISMA_ERROR_MAP: Record<string, { status: number; message: string }> = {
+  P2000: { status: 400, message: 'Value too long for column' },
+  P2001: { status: 404, message: 'Record not found' },
+  P2002: { status: 409, message: 'Unique constraint violation' },
+  P2003: { status: 400, message: 'Foreign key constraint failed' },
+  P2004: { status: 400, message: 'Constraint failed on the database' },
+  P2005: { status: 400, message: 'Invalid field value' },
+  P2006: { status: 400, message: 'Invalid value provided' },
+  P2007: { status: 400, message: 'Data validation error' },
+  P2008: { status: 400, message: 'Failed to parse the query' },
+  P2009: { status: 400, message: 'Failed to validate the query' },
+  P2010: { status: 500, message: 'Raw query failed' },
+  P2011: { status: 400, message: 'Null constraint violation' },
+  P2012: { status: 400, message: 'Missing required value' },
+  P2013: { status: 400, message: 'Missing required argument' },
+  P2014: { status: 400, message: 'Required relation violation' },
+  P2015: { status: 404, message: 'Related record not found' },
+  P2016: { status: 400, message: 'Query interpretation error' },
+  P2017: { status: 400, message: 'Records not connected' },
+  P2018: { status: 404, message: 'Required connected record not found' },
+  P2019: { status: 400, message: 'Input error' },
+  P2020: { status: 400, message: 'Value out of range for the field type' },
+  P2021: { status: 500, message: 'Table does not exist in the database' },
+  P2022: { status: 500, message: 'Column does not exist in the database' },
+  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' },
+  P2028: { status: 500, message: 'Transaction API error' },
+  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' },
+}
+
+type ErrorShape = {
+  name?: string
+  code?: string
+  message?: string
+  issues?: unknown
+  status?: unknown
+  statusCode?: unknown
+}
+
+function asErrorShape(error: unknown): ErrorShape {
+  if (error && typeof error === 'object') return error as ErrorShape
+  return {}
+}
+
+function isProduction(): boolean {
+  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
+}
+
+export function mapError(error: unknown): HttpError {
+  if (error instanceof HttpError) return error
+  const e = asErrorShape(error)
+  const isProd = isProduction()
+
+  const duckStatus = isHttpStatus(e.status)
+    ? e.status
+    : isHttpStatus(e.statusCode)
+      ? e.statusCode
+      : null
+  if (duckStatus !== null) {
+    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 === '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')
+    return new HttpError(400, message)
+  }
+  if (typeof e.code === 'string') {
+    const mapped = PRISMA_ERROR_MAP[e.code]
+    if (mapped) {
+      const detail = e.message
+      const shouldStripDetail = isProd && mapped.status >= 500
+      return new HttpError(
+        mapped.status,
+        !shouldStripDetail && detail ? mapped.message + ': ' + detail : mapped.message,
+      )
+    }
+    if (e.code.startsWith('P')) {
+      const msg = e.message || 'Database operation failed'
+      console.warn(LOG_PREFIX, 'Unmapped Prisma error code:', e.code, msg)
+      return new HttpError(500, isProd ? 'Internal server error' : msg)
+    }
+  }
+  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 === 'PrismaClientInitializationError') {
+      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'))
+    }
+    if (e.name === 'PrismaClientUnknownRequestError') {
+      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'))
+}

package/src/copy/guardHelpers.ts

@@ -0,0 +1,56 @@
+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
+}
+
+export function assertGuard(
+  delegate: PrismaDelegateLike,
+): asserts delegate is PrismaDelegateLike & { guard: NonNullable<PrismaDelegateLike['guard']> } {
+  if (typeof delegate.guard !== 'function') {
+    throw new HttpError(
+      500,
+      'Guard shapes require prisma-guard extension on PrismaClient. Install: npm install prisma-guard, then extend your client with guardExtension().',
+    )
+  }
+}
+
+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',
+])
+
+function keepWhereOnly(obj: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  if ('where' in obj) result.where = obj.where
+  return result
+}
+
+export type ShapeFn = (...args: unknown[]) => Record<string, unknown>
+
+export function buildCountShape(
+  shape: Record<string, unknown> | ShapeFn,
+): Record<string, unknown> | ShapeFn {
+  if (typeof shape === 'function') {
+    const fn = shape as ShapeFn
+    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))
+  if (isSingleShape) return keepWhereOnly(shape)
+  const result: Record<string, unknown> = {}
+  for (const [key, variant] of Object.entries(shape)) {
+    if (typeof variant === 'function') {
+      const vfn = variant as ShapeFn
+      result[key] = (...args: unknown[]) => keepWhereOnly(vfn(...args))
+    } else if (variant && typeof variant === 'object') {
+      result[key] = keepWhereOnly(variant as Record<string, unknown>)
+    } else {
+      result[key] = variant
+    }
+  }
+  return result
+}