prisma-generator-express 1.66.0 → 1.68.0

package/src/copy/autoIncludePlannerGuarded.ts

@@ -1,8 +1,5 @@
 import { isPlainObject } from './misc'
-import type {
-  ModelRelationField,
-  ModelRelationMap,
-} from './autoIncludePlanner'
+import type { ModelRelationField, ModelRelationMap } from './autoIncludePlanner'
 
 export type GuardedAutoIncludeStage = {
   relationPath: string
@@ -36,7 +33,15 @@ export const DEFAULT_GUARDED_MAX_STAGES = 20
 
 const ALLOWED_TO_ONE_STAGE_ARGS = new Set(['select', 'include', 'omit'])
 const ALLOWED_TO_MANY_STAGE_ARGS = new Set([
-  'select', 'include', 'omit', 'where', 'orderBy', 'take', 'skip', 'cursor', 'distinct',
+  'select',
+  'include',
+  'omit',
+  'where',
+  'orderBy',
+  'take',
+  'skip',
+  'cursor',
+  'distinct',
 ])
 
 function containsCountProjection(value: unknown): boolean {
@@ -49,7 +54,10 @@ function containsCountProjection(value: unknown): boolean {
 }
 
 function projectionHasCount(node: Record<string, unknown>): boolean {
-  return containsCountProjection(node.select) || containsCountProjection(node.include)
+  return (
+    containsCountProjection(node.select) ||
+    containsCountProjection(node.include)
+  )
 }
 
 function rootHasRelationRefInFilter(
@@ -120,7 +128,8 @@ function whereMentionsField(where: unknown, fieldName: string): boolean {
     if (key === 'AND' || key === 'OR' || key === 'NOT') {
       const sub = where[key]
       if (Array.isArray(sub)) {
-        for (const item of sub) if (whereMentionsField(item, fieldName)) return true
+        for (const item of sub)
+          if (whereMentionsField(item, fieldName)) return true
       } else if (whereMentionsField(sub, fieldName)) {
         return true
       }
@@ -129,7 +138,10 @@ function whereMentionsField(where: unknown, fieldName: string): boolean {
   return false
 }
 
-function rejectIncludeOrOmit(node: Record<string, unknown>, label: string): string | null {
+function rejectIncludeOrOmit(
+  node: Record<string, unknown>,
+  label: string,
+): string | null {
   if (isPlainObject(node.include)) {
     return label + ' uses include (guarded MVP supports select only)'
   }
@@ -169,7 +181,9 @@ function walkRoot(
 
   const model = ctx.models[modelName]
   if (!model) {
-    return { unsupportedReason: 'model ' + modelName + ' not in relation metadata' }
+    return {
+      unsupportedReason: 'model ' + modelName + ' not in relation metadata',
+    }
   }
 
   const bodyIncludeOmit = rejectIncludeOrOmit(parentBody, 'root body')
@@ -178,10 +192,14 @@ function walkRoot(
   if (shapeIncludeOmit) return { unsupportedReason: shapeIncludeOmit }
 
   if (projectionHasCount(parentBody)) {
-    return { unsupportedReason: '_count in root body not supported in guarded MVP' }
+    return {
+      unsupportedReason: '_count in root body not supported in guarded MVP',
+    }
   }
   if (projectionHasCount(parentShape)) {
-    return { unsupportedReason: '_count in root shape not supported in guarded MVP' }
+    return {
+      unsupportedReason: '_count in root shape not supported in guarded MVP',
+    }
   }
 
   if (isRejectableWhere(parentBody.where)) {
@@ -192,10 +210,16 @@ function walkRoot(
   }
 
   if (rootHasRelationRefInFilter(parentBody, model)) {
-    return { unsupportedReason: 'root body where/orderBy/cursor relation ref not supported' }
+    return {
+      unsupportedReason:
+        'root body where/orderBy/cursor relation ref not supported',
+    }
   }
   if (rootHasRelationRefInFilter(parentShape, model)) {
-    return { unsupportedReason: 'root shape where/orderBy/cursor relation ref not supported' }
+    return {
+      unsupportedReason:
+        'root shape where/orderBy/cursor relation ref not supported',
+    }
   }
 
   const bodySelect = parentBody.select
@@ -229,10 +253,17 @@ function walkRoot(
       const shapeBranch = shapeProjection[key]
       if (shapeBranch === undefined) {
         return {
-          unsupportedReason: 'body projects relation "' + key + '" not present in guard shape at root',
+          unsupportedReason:
+            'body projects relation "' +
+            key +
+            '" not present in guard shape at root',
         }
       }
-      relationBranches.push({ name: key, bodyValue: value, shapeValue: shapeBranch })
+      relationBranches.push({
+        name: key,
+        bodyValue: value,
+        shapeValue: shapeBranch,
+      })
     } else {
       updatedBodyProjection[key] = value
       if (key in shapeProjection) {
@@ -249,30 +280,51 @@ function walkRoot(
     const relation = model.relations[branch.name]
 
     if (relation.direction === 'implicitM2M') {
-      return { unsupportedReason: 'implicit many-to-many not supported in guarded MVP' }
+      return {
+        unsupportedReason: 'implicit many-to-many not supported in guarded MVP',
+      }
     }
-    if (relation.parentLinkFields.length === 0 || relation.childLinkFields.length === 0) {
-      return { unsupportedReason: 'ambiguous relation metadata for ' + relation.name }
+    if (
+      relation.parentLinkFields.length === 0 ||
+      relation.childLinkFields.length === 0
+    ) {
+      return {
+        unsupportedReason: 'ambiguous relation metadata for ' + relation.name,
+      }
     }
     if (relation.parentLinkFields.length !== relation.childLinkFields.length) {
-      return { unsupportedReason: 'mismatched link field counts for ' + relation.name }
+      return {
+        unsupportedReason: 'mismatched link field counts for ' + relation.name,
+      }
     }
     if (relation.parentLinkFields.length !== 1) {
       return {
-        unsupportedReason: 'composite link fields not supported for guarded stage ' + relation.name,
+        unsupportedReason:
+          'composite link fields not supported for guarded stage ' +
+          relation.name,
       }
     }
     if (!ctx.models[relation.type]) {
       return {
-        unsupportedReason: 'target model ' + relation.type + ' not in relation metadata for ' + branch.name,
+        unsupportedReason:
+          'target model ' +
+          relation.type +
+          ' not in relation metadata for ' +
+          branch.name,
       }
     }
 
     if (branch.bodyValue !== true && !isPlainObject(branch.bodyValue)) {
-      return { unsupportedReason: 'invalid relation projection body for ' + branch.name }
+      return {
+        unsupportedReason:
+          'invalid relation projection body for ' + branch.name,
+      }
     }
     if (branch.shapeValue !== true && !isPlainObject(branch.shapeValue)) {
-      return { unsupportedReason: 'invalid relation projection shape for ' + branch.name }
+      return {
+        unsupportedReason:
+          'invalid relation projection shape for ' + branch.name,
+      }
     }
 
     const parentKey = relation.parentLinkFields[0]
@@ -286,71 +338,141 @@ function walkRoot(
       updatedShapeProjection[parentKey] = true
     }
 
-    const relationBodyArgs: Record<string, unknown> = branch.bodyValue === true ? {} : branch.bodyValue
-    const relationShapeArgs: Record<string, unknown> = branch.shapeValue === true ? {} : branch.shapeValue
+    const relationBodyArgs: Record<string, unknown> =
+      branch.bodyValue === true ? {} : branch.bodyValue
+    const relationShapeArgs: Record<string, unknown> =
+      branch.shapeValue === true ? {} : branch.shapeValue
 
-    const allowedArgs = relation.isList ? ALLOWED_TO_MANY_STAGE_ARGS : ALLOWED_TO_ONE_STAGE_ARGS
+    const allowedArgs = relation.isList
+      ? ALLOWED_TO_MANY_STAGE_ARGS
+      : ALLOWED_TO_ONE_STAGE_ARGS
     for (const key of Object.keys(relationBodyArgs)) {
       if (!allowedArgs.has(key)) {
         return {
-          unsupportedReason: 'unsupported body arg "' + key + '" for ' +
-            (relation.isList ? 'to-many' : 'to-one') + ' relation ' + relation.name,
+          unsupportedReason:
+            'unsupported body arg "' +
+            key +
+            '" for ' +
+            (relation.isList ? 'to-many' : 'to-one') +
+            ' relation ' +
+            relation.name,
         }
       }
     }
     for (const key of Object.keys(relationShapeArgs)) {
       if (!allowedArgs.has(key)) {
         return {
-          unsupportedReason: 'unsupported shape arg "' + key + '" for ' +
-            (relation.isList ? 'to-many' : 'to-one') + ' relation ' + relation.name,
+          unsupportedReason:
+            'unsupported shape arg "' +
+            key +
+            '" for ' +
+            (relation.isList ? 'to-many' : 'to-one') +
+            ' relation ' +
+            relation.name,
         }
       }
     }
 
     if (isPlainObject(relationBodyArgs.include)) {
-      return { unsupportedReason: 'stage body uses include for ' + relation.name + ' (guarded MVP supports select only)' }
+      return {
+        unsupportedReason:
+          'stage body uses include for ' +
+          relation.name +
+          ' (guarded MVP supports select only)',
+      }
     }
     if (isPlainObject(relationBodyArgs.omit)) {
-      return { unsupportedReason: 'stage body uses omit for ' + relation.name + ' (guarded MVP supports select only)' }
+      return {
+        unsupportedReason:
+          'stage body uses omit for ' +
+          relation.name +
+          ' (guarded MVP supports select only)',
+      }
     }
     if (isPlainObject(relationShapeArgs.include)) {
-      return { unsupportedReason: 'stage shape uses include for ' + relation.name + ' (guarded MVP supports select only)' }
+      return {
+        unsupportedReason:
+          'stage shape uses include for ' +
+          relation.name +
+          ' (guarded MVP supports select only)',
+      }
     }
     if (isPlainObject(relationShapeArgs.omit)) {
-      return { unsupportedReason: 'stage shape uses omit for ' + relation.name + ' (guarded MVP supports select only)' }
+      return {
+        unsupportedReason:
+          'stage shape uses omit for ' +
+          relation.name +
+          ' (guarded MVP supports select only)',
+      }
     }
 
     if (projectionHasCount(relationBodyArgs)) {
-      return { unsupportedReason: '_count in stage body for ' + relation.name + ' not supported in guarded MVP' }
+      return {
+        unsupportedReason:
+          '_count in stage body for ' +
+          relation.name +
+          ' not supported in guarded MVP',
+      }
     }
     if (projectionHasCount(relationShapeArgs)) {
-      return { unsupportedReason: '_count in stage shape for ' + relation.name + ' not supported in guarded MVP' }
+      return {
+        unsupportedReason:
+          '_count in stage shape for ' +
+          relation.name +
+          ' not supported in guarded MVP',
+      }
     }
 
     if (isRejectableWhere(relationBodyArgs.where)) {
-      return { unsupportedReason: 'stage body where must be a plain object for ' + relation.name }
+      return {
+        unsupportedReason:
+          'stage body where must be a plain object for ' + relation.name,
+      }
     }
     if (isRejectableWhere(relationShapeArgs.where)) {
-      return { unsupportedReason: 'stage shape where must be a plain object for ' + relation.name }
+      return {
+        unsupportedReason:
+          'stage shape where must be a plain object for ' + relation.name,
+      }
     }
 
-    if (stageHasBlockedRelationRef(relationBodyArgs, ctx.models[relation.type])) {
-      return { unsupportedReason: 'stage body orderBy/cursor relation ref not supported for ' + relation.name }
+    if (
+      stageHasBlockedRelationRef(relationBodyArgs, ctx.models[relation.type])
+    ) {
+      return {
+        unsupportedReason:
+          'stage body orderBy/cursor relation ref not supported for ' +
+          relation.name,
+      }
     }
-    if (stageHasBlockedRelationRef(relationShapeArgs, ctx.models[relation.type])) {
-      return { unsupportedReason: 'stage shape orderBy/cursor relation ref not supported for ' + relation.name }
+    if (
+      stageHasBlockedRelationRef(relationShapeArgs, ctx.models[relation.type])
+    ) {
+      return {
+        unsupportedReason:
+          'stage shape orderBy/cursor relation ref not supported for ' +
+          relation.name,
+      }
     }
 
     if (whereMentionsField(relationBodyArgs.where, childKey)) {
       return {
-        unsupportedReason: 'FK collision: stage body where for ' + relation.name +
-          ' already mentions child link field "' + childKey + '"',
+        unsupportedReason:
+          'FK collision: stage body where for ' +
+          relation.name +
+          ' already mentions child link field "' +
+          childKey +
+          '"',
       }
     }
     if (whereMentionsField(relationShapeArgs.where, childKey)) {
       return {
-        unsupportedReason: 'FK collision: stage shape where for ' + relation.name +
-          ' already mentions child link field "' + childKey + '"',
+        unsupportedReason:
+          'FK collision: stage shape where for ' +
+          relation.name +
+          ' already mentions child link field "' +
+          childKey +
+          '"',
       }
     }
 
@@ -449,7 +571,8 @@ export function planGuardedAutoInclude(
       rootShape: input.shape,
       stages: [],
       internalFieldPaths: [],
-      unsupportedReason: 'guarded auto-progressive fallback: ' + result.unsupportedReason,
+      unsupportedReason:
+        'guarded auto-progressive fallback: ' + result.unsupportedReason,
     }
   }
 
@@ -474,4 +597,4 @@ export function planGuardedAutoInclude(
     stages: ctx.stages,
     internalFieldPaths: ctx.internalFieldPaths,
   }
-}
+}

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)
-}
+}