prisma-generator-express 1.59.0 → 1.61.0

package/src/copy/materializedCount.ts

@@ -0,0 +1,68 @@
+import { HttpError } from './errorMapper'
+import type { PaginationCountSource } from './routeConfig'
+
+export const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/
+
+type PrismaRawClient = {
+  $queryRawUnsafe?: <T = unknown>(sql: string, ...values: unknown[]) => Promise<T>
+}
+
+export function quoteIdent(name: string): string {
+  if (!IDENT_RE.test(name)) {
+    throw new HttpError(400, 'invalid identifier: ' + name)
+  }
+  return '"' + name.replace(/"/g, '""') + '"'
+}
+
+function buildMaterializedCountFqn(
+  source: Extract<PaginationCountSource, { type: 'materializedView' }>,
+): string {
+  return source.schema
+    ? quoteIdent(source.schema) + '.' + quoteIdent(source.relation)
+    : quoteIdent(source.relation)
+}
+
+function buildMaterializedCountWhere(
+  where: Record<string, unknown> | undefined,
+): { sql: string; values: unknown[] } {
+  if (!where || Object.keys(where).length === 0) {
+    return { sql: '', values: [] }
+  }
+  const values: unknown[] = []
+  const clauses: string[] = []
+  for (const [key, value] of Object.entries(where)) {
+    if (value === null) {
+      clauses.push(quoteIdent(key) + ' IS NULL')
+      continue
+    }
+    values.push(value)
+    clauses.push(quoteIdent(key) + ' = $' + values.length)
+  }
+  return { sql: ' WHERE ' + clauses.join(' AND '), values }
+}
+
+export async function countFromMaterializedView(
+  client: unknown,
+  source: Extract<PaginationCountSource, { type: 'materializedView' }>,
+): Promise<number> {
+  const raw = client as PrismaRawClient
+  if (typeof raw.$queryRawUnsafe !== 'function') {
+    throw new HttpError(500, 'Materialized count source requires $queryRawUnsafe on the Prisma client')
+  }
+  const column = source.column ?? 'total'
+  const where = buildMaterializedCountWhere(source.where)
+  const sql =
+    'SELECT ' +
+    quoteIdent(column) +
+    ' AS "total" FROM ' +
+    buildMaterializedCountFqn(source) +
+    where.sql +
+    ' LIMIT 1'
+  const rows = await raw.$queryRawUnsafe<Array<{ total: unknown }>>(sql, ...where.values)
+  const value = rows[0]?.total
+  const total = Number(value)
+  if (!Number.isFinite(total)) {
+    throw new HttpError(500, 'Materialized count source did not return a numeric total')
+  }
+  return Math.trunc(total)
+}

package/src/copy/materializedRouter.ts

@@ -6,7 +6,8 @@ import type {
   Response,
   Router,
 } from 'express'
-import { HttpError, mapError, transformResult } from './operationRuntime'
+import { HttpError, mapError } from './errorMapper'
+import { transformResult } from './operationRuntime'
 
 type SortDirection = 'asc' | 'desc'
 type NullsOrder = 'first' | 'last'
@@ -48,7 +49,8 @@ type MaterializedRouterOptions = {
 
 const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/
 
-export const forbidden = (message: string): HttpError => new HttpError(403, message)
+export const forbidden = (message: string): HttpError =>
+  new HttpError(403, message)
 
 const quoteIdent = (name: string): string => {
   if (!IDENT_RE.test(name))
@@ -105,6 +107,18 @@ const buildOrderBy = (orderBy?: OrderByDef): string => {
   )
 }
 
+const validateSort = (value: unknown): SortDirection | undefined => {
+  if (value === undefined) return undefined
+  if (value === 'asc' || value === 'desc') return value
+  throw new HttpError(400, 'invalid orderBy.sort: expected "asc" or "desc"')
+}
+
+const validateNullsOrder = (value: unknown): NullsOrder | undefined => {
+  if (value === undefined) return undefined
+  if (value === 'first' || value === 'last') return value
+  throw new HttpError(400, 'invalid orderBy.nulls: expected "first" or "last"')
+}
+
 const parseOrderByParam = (raw: unknown): OrderByDef | undefined => {
   if (raw === undefined || raw === null || raw === '') return undefined
   if (typeof raw !== 'string') return undefined
@@ -124,12 +138,10 @@ const parseOrderByParam = (raw: unknown): OrderByDef | undefined => {
       if (dirRaw === 'asc' || dirRaw === 'desc')
         return { field, direction: dirRaw }
       if (dirRaw && typeof dirRaw === 'object') {
-        const sort = (dirRaw as { sort?: unknown }).sort
-        const nulls = (dirRaw as { nulls?: unknown }).nulls
-        const direction = sort === 'asc' || sort === 'desc' ? sort : undefined
-        const nullsOrder =
-          nulls === 'first' || nulls === 'last' ? nulls : undefined
-        return { field, direction, nulls: nullsOrder }
+        const dirObj = dirRaw as { sort?: unknown; nulls?: unknown }
+        const direction = validateSort(dirObj.sort)
+        const nulls = validateNullsOrder(dirObj.nulls)
+        return { field, direction, nulls }
       }
       return { field }
     }
@@ -153,8 +165,12 @@ const validateViewIdentifier = (
 ): void => {
   if (!IDENT_RE.test(value)) {
     throw new Error(
-      'materializedViewsRouter: invalid ' + fieldName + ' identifier for view "' +
-      viewName + '": ' + value,
+      'materializedViewsRouter: invalid ' +
+        fieldName +
+        ' identifier for view "' +
+        viewName +
+        '": ' +
+        value,
     )
   }
 }
@@ -172,9 +188,10 @@ const validateViewConfig = (viewName: string, def: ViewDef): void => {
   }
   if (!def.allowedOrderBy && !def.orderBy) {
     console.warn(
-      '[materializedViewsRouter] view "' + viewName +
-      '" has neither `orderBy` nor `allowedOrderBy` set. ' +
-      'Clients can sort by any valid identifier, which may cause full table scans.',
+      '[materializedViewsRouter] view "' +
+        viewName +
+        '" has neither `orderBy` nor `allowedOrderBy` set. ' +
+        'Clients can sort by any valid identifier, which may cause full table scans.',
     )
   }
 }
@@ -198,7 +215,7 @@ export const materializedViewsRouter = (
     ...before,
     async (req: Request, res: Response, next: NextFunction) => {
       try {
-        const viewName = req.params.viewName
+        const viewName = String(req.params.viewName)
         const def = opts.views[viewName]
         if (!def) throw new HttpError(404, 'unknown view')
         if (def.authorize) await def.authorize(req, viewName, def)
@@ -247,26 +264,13 @@ export const materializedViewsRouter = (
 
   router.use(
     (err: unknown, _req: Request, res: Response, next: NextFunction) => {
-      const httpError =
-        err instanceof HttpError
-          ? err
-          : err &&
-              typeof err === 'object' &&
-              typeof (err as { status?: number }).status === 'number'
-            ? new HttpError(
-                (err as { status: number }).status,
-                (err as { message?: string }).message ||
-                  'Internal server error',
-              )
-            : mapError(err)
-
+      const httpError = mapError(err)
       if (!res.headersSent) {
         return res.status(httpError.status).json({ message: httpError.message })
       }
-
       next(err)
     },
   )
 
   return router
-}
+}

package/src/copy/operationDefinitions.ts

@@ -1,122 +1,446 @@
 export type HttpMethod = 'get' | 'post' | 'put' | 'patch' | 'delete'
 
-export interface OperationDef {
+export type OpKind = 'read' | 'write' | 'batch'
+
+export interface OpMetadata {
   name: string
   method: HttpMethod
   pathSuffix: string
   configKey: string
-  excludeFromEnableAll?: boolean
+  kind: OpKind
+  coreName: string
+  successStatus: number
+  requiredBodyFields: readonly string[]
+  supportsPostRead: boolean
+  supportsProjection: boolean
+  excludeFromEnableAll: boolean
+  writeStrategyAffected: boolean
+  errors: readonly number[]
+  responseDesc: string
+  transport: string
+  argsSchema: readonly string[]
+  requiredArgs: readonly string[]
+  notes: string
 }
 
-export const OPERATION_DEFS: OperationDef[] = [
-  { name: 'findMany', method: 'get', pathSuffix: '', configKey: 'findMany' },
+export const OPERATION_METADATA: readonly OpMetadata[] = [
+  {
+    name: 'findMany',
+    method: 'get',
+    pathSuffix: '',
+    configKey: 'findMany',
+    kind: 'read',
+    coreName: 'findMany',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 500, 501, 503],
+    responseDesc: 'Array of records',
+    transport: 'GET query params',
+    argsSchema: ['where', 'select', 'include', 'omit', 'orderBy', 'cursor', 'take', 'skip', 'distinct'],
+    requiredArgs: [],
+    notes: 'Pagination limits may apply when configured.',
+  },
   {
     name: 'findUnique',
     method: 'get',
     pathSuffix: '/unique',
     configKey: 'findUnique',
+    kind: 'read',
+    coreName: 'findUnique',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 500, 501, 503],
+    responseDesc: 'Single record or null',
+    transport: 'GET query params',
+    argsSchema: ['where', 'select', 'include', 'omit'],
+    requiredArgs: ['where'],
+    notes: 'Returns null (not 404) when no record matches.',
   },
   {
     name: 'findUniqueOrThrow',
     method: 'get',
     pathSuffix: '/unique/strict',
     configKey: 'findUniqueOrThrow',
+    kind: 'read',
+    coreName: 'findUniqueOrThrow',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 404, 500, 501, 503],
+    responseDesc: 'Single record',
+    transport: 'GET query params',
+    argsSchema: ['where', 'select', 'include', 'omit'],
+    requiredArgs: ['where'],
+    notes: 'Returns 404 when no record matches.',
   },
   {
     name: 'findFirst',
     method: 'get',
     pathSuffix: '/first',
     configKey: 'findFirst',
+    kind: 'read',
+    coreName: 'findFirst',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 500, 501, 503],
+    responseDesc: 'Single record or null',
+    transport: 'GET query params',
+    argsSchema: ['where', 'select', 'include', 'omit', 'orderBy', 'cursor', 'take', 'skip', 'distinct'],
+    requiredArgs: [],
+    notes: 'Returns null (not 404) when no record matches.',
   },
   {
     name: 'findFirstOrThrow',
     method: 'get',
     pathSuffix: '/first/strict',
     configKey: 'findFirstOrThrow',
+    kind: 'read',
+    coreName: 'findFirstOrThrow',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 404, 500, 501, 503],
+    responseDesc: 'Single record',
+    transport: 'GET query params',
+    argsSchema: ['where', 'select', 'include', 'omit', 'orderBy', 'cursor', 'take', 'skip', 'distinct'],
+    requiredArgs: [],
+    notes: 'Returns 404 when no record matches.',
   },
   {
     name: 'findManyPaginated',
     method: 'get',
     pathSuffix: '/paginated',
     configKey: 'findManyPaginated',
+    kind: 'read',
+    coreName: 'findManyPaginated',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 409, 500, 501, 503],
+    responseDesc: '{ data: Record[], total: number, hasMore: boolean }',
+    transport: 'GET query params',
+    argsSchema: ['where', 'select', 'include', 'omit', 'orderBy', 'cursor', 'take', 'skip', 'distinct'],
+    requiredArgs: [],
+    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.',
+  },
+  {
+    name: 'count',
+    method: 'get',
+    pathSuffix: '/count',
+    configKey: 'count',
+    kind: 'read',
+    coreName: 'count',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: false,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 500, 501, 503],
+    responseDesc: 'Integer, or per-field count object when select is provided',
+    transport: 'GET query params',
+    argsSchema: ['where', 'orderBy', 'cursor', 'take', 'skip', 'select'],
+    requiredArgs: [],
+    notes: 'select here means count-specific field selection, not record field selection.',
+  },
+  {
+    name: 'aggregate',
+    method: 'get',
+    pathSuffix: '/aggregate',
+    configKey: 'aggregate',
+    kind: 'read',
+    coreName: 'aggregate',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: false,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 500, 501, 503],
+    responseDesc: 'Object with requested aggregate fields (_count, _avg, _sum, _min, _max)',
+    transport: 'GET query params',
+    argsSchema: ['where', 'orderBy', 'cursor', 'take', 'skip', '_count', '_avg', '_sum', '_min', '_max'],
+    requiredArgs: [],
+    notes: '_avg, _sum only apply to numeric fields.',
+  },
+  {
+    name: 'groupBy',
+    method: 'get',
+    pathSuffix: '/groupby',
+    configKey: 'groupBy',
+    kind: 'read',
+    coreName: 'groupBy',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: true,
+    supportsProjection: false,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 500, 501, 503],
+    responseDesc: 'Array of objects, each with grouped field values and requested aggregates',
+    transport: 'GET query params',
+    argsSchema: ['by', 'where', 'orderBy', 'having', 'take', 'skip', '_count', '_avg', '_sum', '_min', '_max'],
+    requiredArgs: ['by'],
+    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.',
+  },
+  {
+    name: 'create',
+    method: 'post',
+    pathSuffix: '',
+    configKey: 'create',
+    kind: 'write',
+    coreName: 'create',
+    successStatus: 201,
+    requiredBodyFields: ['data'],
+    supportsPostRead: false,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 409, 500, 501, 503],
+    responseDesc: 'Created record (201)',
+    transport: 'POST JSON body',
+    argsSchema: ['data', 'select', 'include', 'omit'],
+    requiredArgs: ['data'],
+    notes: '409 on unique constraint violation.',
   },
-  { name: 'create', method: 'post', pathSuffix: '', configKey: 'create' },
   {
     name: 'createMany',
     method: 'post',
     pathSuffix: '/many',
     configKey: 'createMany',
+    kind: 'batch',
+    coreName: 'createMany',
+    successStatus: 201,
+    requiredBodyFields: ['data'],
+    supportsPostRead: false,
+    supportsProjection: false,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: true,
+    errors: [400, 403, 409, 500, 501, 503],
+    responseDesc: '{ count: number } (201)',
+    transport: 'POST JSON body',
+    argsSchema: ['data', 'skipDuplicates'],
+    requiredArgs: ['data'],
+    notes: 'data is an array of scalar-only inputs. Nested relation writes are not supported. skipDuplicates silently ignores conflicts (not supported on all providers).',
   },
   {
     name: 'createManyAndReturn',
     method: 'post',
     pathSuffix: '/many/return',
     configKey: 'createManyAndReturn',
+    kind: 'batch',
+    coreName: 'createManyAndReturn',
+    successStatus: 201,
+    requiredBodyFields: ['data'],
+    supportsPostRead: false,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 409, 500, 501, 503],
+    responseDesc: 'Array of created records (201)',
+    transport: 'POST JSON body',
+    argsSchema: ['data', 'skipDuplicates', 'select', 'include', 'omit'],
+    requiredArgs: ['data'],
+    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.',
+  },
+  {
+    name: 'update',
+    method: 'put',
+    pathSuffix: '',
+    configKey: 'update',
+    kind: 'write',
+    coreName: 'update',
+    successStatus: 200,
+    requiredBodyFields: ['where', 'data'],
+    supportsPostRead: false,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 404, 409, 500, 501, 503],
+    responseDesc: 'Updated record',
+    transport: 'PUT JSON body',
+    argsSchema: ['where', 'data', 'select', 'include', 'omit'],
+    requiredArgs: ['where', 'data'],
+    notes: '404 when the record to update is not found. 409 on unique constraint violation or transaction conflict.',
   },
-  { name: 'update', method: 'put', pathSuffix: '', configKey: 'update' },
   {
     name: 'updateMany',
     method: 'put',
     pathSuffix: '/many',
     configKey: 'updateMany',
+    kind: 'batch',
+    coreName: 'updateMany',
+    successStatus: 200,
+    requiredBodyFields: ['where', 'data'],
+    supportsPostRead: false,
+    supportsProjection: false,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: true,
+    errors: [400, 403, 409, 500, 501, 503],
+    responseDesc: '{ count: number }',
+    transport: 'PUT JSON body',
+    argsSchema: ['where', 'data'],
+    requiredArgs: ['where', 'data'],
+    notes: 'Updates all matching records with scalar-only data. Nested relation writes are not supported. Returns count, not records. 409 on unique constraint violation.',
   },
   {
     name: 'updateManyAndReturn',
     method: 'put',
     pathSuffix: '/many/return',
     configKey: 'updateManyAndReturn',
+    kind: 'batch',
+    coreName: 'updateManyAndReturn',
+    successStatus: 200,
+    requiredBodyFields: ['where', 'data'],
+    supportsPostRead: false,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 409, 500, 501, 503],
+    responseDesc: 'Array of updated records',
+    transport: 'PUT JSON body',
+    argsSchema: ['where', 'data', 'select', 'include', 'omit'],
+    requiredArgs: ['where', 'data'],
+    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.',
   },
-  { name: 'upsert', method: 'patch', pathSuffix: '', configKey: 'upsert' },
-  { name: 'delete', method: 'delete', pathSuffix: '', configKey: 'delete' },
   {
-    name: 'deleteMany',
-    method: 'delete',
-    pathSuffix: '/many',
-    configKey: 'deleteMany',
+    name: 'upsert',
+    method: 'patch',
+    pathSuffix: '',
+    configKey: 'upsert',
+    kind: 'write',
+    coreName: 'upsert',
+    successStatus: 200,
+    requiredBodyFields: ['where', 'create', 'update'],
+    supportsPostRead: false,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 409, 500, 501, 503],
+    responseDesc: 'Created or updated record',
+    transport: 'PATCH JSON body',
+    argsSchema: ['where', 'create', 'update', 'select', 'include', 'omit'],
+    requiredArgs: ['where', 'create', 'update'],
+    notes: 'Creates if not found, updates if found.',
   },
-  { name: 'count', method: 'get', pathSuffix: '/count', configKey: 'count' },
   {
-    name: 'aggregate',
-    method: 'get',
-    pathSuffix: '/aggregate',
-    configKey: 'aggregate',
+    name: 'delete',
+    method: 'delete',
+    pathSuffix: '',
+    configKey: 'delete',
+    kind: 'write',
+    coreName: 'deleteUnique',
+    successStatus: 200,
+    requiredBodyFields: ['where'],
+    supportsPostRead: false,
+    supportsProjection: true,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 404, 500, 501, 503],
+    responseDesc: 'Deleted record',
+    transport: 'DELETE JSON body',
+    argsSchema: ['where', 'select', 'include', 'omit'],
+    requiredArgs: ['where'],
+    notes: '404 when the record to delete is not found.',
   },
   {
-    name: 'groupBy',
-    method: 'get',
-    pathSuffix: '/groupby',
-    configKey: 'groupBy',
+    name: 'deleteMany',
+    method: 'delete',
+    pathSuffix: '/many',
+    configKey: 'deleteMany',
+    kind: 'batch',
+    coreName: 'deleteMany',
+    successStatus: 200,
+    requiredBodyFields: ['where'],
+    supportsPostRead: false,
+    supportsProjection: false,
+    excludeFromEnableAll: false,
+    writeStrategyAffected: false,
+    errors: [400, 403, 500, 501, 503],
+    responseDesc: '{ count: number }',
+    transport: 'DELETE JSON body',
+    argsSchema: ['where'],
+    requiredArgs: ['where'],
+    notes: 'Deletes all matching records. Returns count, not records.',
   },
   {
     name: 'updateEach',
     method: 'post',
     pathSuffix: '/each',
     configKey: 'updateEach',
+    kind: 'batch',
+    coreName: 'updateEach',
+    successStatus: 200,
+    requiredBodyFields: [],
+    supportsPostRead: false,
+    supportsProjection: false,
     excludeFromEnableAll: true,
+    writeStrategyAffected: false,
+    errors: [400, 403, 409, 500, 501, 503],
+    responseDesc: 'Non-atomic: per-row { status, data } / { status, error } array. Atomic: array of records.',
+    transport: 'POST JSON body (array)',
+    argsSchema: [],
+    requiredArgs: ['array of { where, data }'],
+    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.',
   },
 ]
 
-export const READ_OPERATION_NAMES = new Set([
-  'findMany',
-  'findUnique',
-  'findUniqueOrThrow',
-  'findFirst',
-  'findFirstOrThrow',
-  'findManyPaginated',
-  'count',
-  'aggregate',
-  'groupBy',
-])
+export const OPERATION_BY_NAME: Record<string, OpMetadata> = Object.fromEntries(
+  OPERATION_METADATA.map((m) => [m.name, m]),
+)
+
+export const READ_OPERATIONS: readonly OpMetadata[] = OPERATION_METADATA.filter((m) => m.kind === 'read')
+
+export const WRITE_OPERATIONS: readonly OpMetadata[] = OPERATION_METADATA.filter((m) => m.kind === 'write' || m.kind === 'batch')
+
+export const READ_OPERATION_NAMES = new Set(READ_OPERATIONS.map((m) => m.name))
+
+export interface OperationDef {
+  name: string
+  method: HttpMethod
+  pathSuffix: string
+  configKey: string
+  excludeFromEnableAll?: boolean
+}
+
+export const OPERATION_DEFS: OperationDef[] = OPERATION_METADATA.map((m) => ({
+  name: m.name,
+  method: m.method,
+  pathSuffix: m.pathSuffix,
+  configKey: m.configKey,
+  excludeFromEnableAll: m.excludeFromEnableAll || undefined,
+}))
 
 export function getPostReadPathSuffix(opName: string): string {
   if (opName === 'findMany') return '/read'
-  const def = OPERATION_DEFS.find((d) => d.name === opName)
-  return def ? def.pathSuffix : ''
+  const meta = OPERATION_BY_NAME[opName]
+  return meta ? meta.pathSuffix : ''
 }
 
 export function isOperationEnabled(
   config: Record<string, any>,
-  def: OperationDef,
+  def: OperationDef | OpMetadata,
 ): boolean {
   if (config[def.configKey] === false) return false
   if (def.excludeFromEnableAll) return !!config[def.configKey]