prisma-generator-express 1.41.0 → 1.43.0

package/src/copy/autoIncludePlanner.ts

@@ -0,0 +1,299 @@
+export type ModelRelationDirection = 'parentOwnsFk' | 'childOwnsFk' | 'implicitM2M'
+
+export type ModelRelationField = {
+  name: string
+  type: string
+  isList: boolean
+  isRequired: boolean
+  direction: ModelRelationDirection
+  parentLinkFields: string[]
+  childLinkFields: string[]
+}
+
+export type ModelRelationMap = {
+  name: string
+  delegateKey: string
+  scalarFields: string[]
+  idFields: string[]
+  relations: Record<string, ModelRelationField>
+}
+
+export type AutoIncludeStage = {
+  relationPath: string
+  parentPath: string
+  relationName: string
+  relationField: ModelRelationField
+  stageArgs: Record<string, unknown>
+  depth: number
+}
+
+export type AutoIncludePlan = {
+  rootArgs: Record<string, unknown>
+  stages: AutoIncludeStage[]
+  internalFieldPaths: string[]
+  unsupportedReason?: string
+}
+
+export type AutoIncludePlannerInput = {
+  rootModelName: string
+  models: Record<string, ModelRelationMap>
+  args: Record<string, unknown>
+  maxDepth?: number
+  maxStages?: number
+}
+
+export const DEFAULT_AUTO_INCLUDE_MAX_DEPTH = 3
+export const DEFAULT_AUTO_INCLUDE_MAX_STAGES = 20
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object') return false
+  if (Array.isArray(value)) return false
+  return true
+}
+
+function hasCountKey(value: unknown): boolean {
+  if (!isPlainObject(value)) return false
+  return '_count' in value
+}
+
+function hasWhereLikeRelationReference(
+  args: Record<string, unknown>,
+  model: ModelRelationMap,
+): boolean {
+  const checkObject = (obj: unknown): boolean => {
+    if (!isPlainObject(obj)) return false
+    for (const key of Object.keys(obj)) {
+      if (model.relations[key]) return true
+      if (key === 'AND' || key === 'OR' || key === 'NOT') {
+        const sub = obj[key]
+        if (Array.isArray(sub)) {
+          for (const item of sub) if (checkObject(item)) return true
+        } else if (checkObject(sub)) {
+          return true
+        }
+      }
+    }
+    return false
+  }
+
+  if (checkObject(args.where)) return true
+
+  if (args.orderBy) {
+    const obs = Array.isArray(args.orderBy) ? args.orderBy : [args.orderBy]
+    for (const ob of obs) {
+      if (!isPlainObject(ob)) continue
+      for (const key of Object.keys(ob)) {
+        if (model.relations[key]) return true
+      }
+    }
+  }
+
+  if (isPlainObject(args.cursor)) {
+    for (const key of Object.keys(args.cursor)) {
+      if (model.relations[key]) return true
+    }
+  }
+
+  return false
+}
+
+type WalkContext = {
+  models: Record<string, ModelRelationMap>
+  stages: AutoIncludeStage[]
+  internalFieldPaths: string[]
+  maxDepth: number
+  maxStages: number
+}
+
+type WalkResult = {
+  unsupportedReason?: string
+  projectionAfterStrip?: Record<string, unknown>
+}
+
+function walk(
+  ctx: WalkContext,
+  modelName: string,
+  parentPath: string,
+  parentArgs: Record<string, unknown>,
+  depth: number,
+): WalkResult {
+  if (depth > ctx.maxDepth) {
+    return { unsupportedReason: 'depth exceeds maxDepth=' + ctx.maxDepth }
+  }
+  if (ctx.stages.length > ctx.maxStages) {
+    return { unsupportedReason: 'stages exceed maxStages=' + ctx.maxStages }
+  }
+
+  const model = ctx.models[modelName]
+  if (!model) {
+    return { unsupportedReason: 'model ' + modelName + ' not in relation metadata' }
+  }
+
+  const select = parentArgs.select
+  const include = parentArgs.include
+  const omit = parentArgs.omit
+
+  if (isPlainObject(select) && isPlainObject(include)) {
+    return { unsupportedReason: 'select+include at same level' }
+  }
+  if (isPlainObject(select) && isPlainObject(omit)) {
+    return { unsupportedReason: 'select+omit at same level' }
+  }
+  if (hasCountKey(select) || hasCountKey(include)) {
+    return { unsupportedReason: '_count not supported in MVP' }
+  }
+  if (hasWhereLikeRelationReference(parentArgs, model)) {
+    return { unsupportedReason: 'relation used in where/orderBy/cursor is not supported in MVP' }
+  }
+
+  const projection = isPlainObject(select) ? select : (isPlainObject(include) ? include : null)
+  if (!projection) {
+    return {}
+  }
+
+  const isSelectMode = isPlainObject(select)
+  const localOmit = isPlainObject(omit) ? omit : null
+  const updatedProjection: Record<string, unknown> = {}
+  const userFields = new Set(Object.keys(projection))
+
+  const relationBranches: Array<{ name: string; value: unknown }> = []
+
+  for (const [key, value] of Object.entries(projection)) {
+    if (model.relations[key]) {
+      relationBranches.push({ name: key, value })
+    } else {
+      updatedProjection[key] = value
+    }
+  }
+
+  if (relationBranches.length === 0) {
+    return { projectionAfterStrip: isSelectMode ? updatedProjection : undefined }
+  }
+
+  for (const branch of relationBranches) {
+    const relation = model.relations[branch.name]
+
+    if (relation.direction === 'implicitM2M') {
+      return { unsupportedReason: 'implicit many-to-many not supported in MVP' }
+    }
+    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 }
+    }
+
+    for (const linkField of relation.parentLinkFields) {
+      if (localOmit && localOmit[linkField] === true) {
+        const where = parentPath ? parentPath + '.' : 'root '
+        return { unsupportedReason: 'required parent link field omitted: ' + where + linkField }
+      }
+    }
+
+    for (const linkField of relation.parentLinkFields) {
+      if (isSelectMode && !userFields.has(linkField)) {
+        updatedProjection[linkField] = true
+        const fullPath = parentPath ? parentPath + '.' + linkField : linkField
+        ctx.internalFieldPaths.push(fullPath)
+      }
+    }
+
+    const relationArgs: Record<string, unknown> = branch.value === true
+      ? {}
+      : (isPlainObject(branch.value) ? branch.value : {})
+
+    const relationPath = parentPath ? parentPath + '.' + branch.name : branch.name
+
+    const stageArgs: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(relationArgs)) {
+      if (k === 'select' || k === 'include' || k === 'omit') continue
+      stageArgs[k] = v
+    }
+
+    const stageIndex = ctx.stages.length
+
+    ctx.stages.push({
+      relationPath,
+      parentPath,
+      relationName: branch.name,
+      relationField: relation,
+      stageArgs,
+      depth: depth + 1,
+    })
+
+    const hasNestedProjection =
+      isPlainObject(relationArgs.select) ||
+      isPlainObject(relationArgs.include) ||
+      isPlainObject(relationArgs.omit)
+
+    if (hasNestedProjection) {
+      const stagesBeforeRecursion = ctx.stages.length
+
+      const nested = walk(ctx, relation.type, relationPath, relationArgs, depth + 1)
+      if (nested.unsupportedReason) return nested
+
+      if (relation.isList && ctx.stages.length > stagesBeforeRecursion) {
+        return { unsupportedReason: 'nested relation through to-many parent not supported in MVP' }
+      }
+
+      if (nested.projectionAfterStrip) {
+        ctx.stages[stageIndex].stageArgs.select = nested.projectionAfterStrip
+      }
+      if (isPlainObject(relationArgs.omit)) {
+        ctx.stages[stageIndex].stageArgs.omit = relationArgs.omit
+      }
+    }
+  }
+
+  return { projectionAfterStrip: isSelectMode ? updatedProjection : undefined }
+}
+
+export function planAutoInclude(input: AutoIncludePlannerInput): AutoIncludePlan {
+  const maxDepth = input.maxDepth ?? DEFAULT_AUTO_INCLUDE_MAX_DEPTH
+  const maxStages = input.maxStages ?? DEFAULT_AUTO_INCLUDE_MAX_STAGES
+
+  const ctx: WalkContext = {
+    models: input.models,
+    stages: [],
+    internalFieldPaths: [],
+    maxDepth,
+    maxStages,
+  }
+
+  const result = walk(ctx, input.rootModelName, '', input.args, 0)
+
+  if (result.unsupportedReason) {
+    return {
+      rootArgs: input.args,
+      stages: [],
+      internalFieldPaths: [],
+      unsupportedReason: 'auto-progressive fallback: ' + result.unsupportedReason,
+    }
+  }
+
+  const rootArgs: Record<string, unknown> = { ...input.args }
+  const rootModel = input.models[input.rootModelName]
+
+  if (result.projectionAfterStrip) {
+    rootArgs.select = result.projectionAfterStrip
+    delete rootArgs.include
+  } else if (rootModel && isPlainObject(input.args.include)) {
+    const stripped: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(input.args.include)) {
+      if (!rootModel.relations[k]) {
+        stripped[k] = v
+      }
+    }
+    if (Object.keys(stripped).length > 0) {
+      rootArgs.include = stripped
+    } else {
+      delete rootArgs.include
+    }
+  }
+
+  return {
+    rootArgs,
+    stages: ctx.stages,
+    internalFieldPaths: ctx.internalFieldPaths,
+  }
+}

package/src/copy/autoIncludeRuntime.ts

@@ -0,0 +1,307 @@
+import type { Request, Response } from 'express'
+import {
+  initSSE,
+  endSSE,
+  startSSEKeepalive,
+  sendSSEField,
+  sendSSEResult,
+  sendSSEError,
+  sendSSEProgress,
+  runSingleResultSSE,
+  setByPath,
+  getDelegate,
+  getExtendedClient,
+  type OperationContext,
+  type PrismaDelegate,
+} from './operationRuntime'
+import {
+  planAutoInclude,
+  type ModelRelationMap,
+  type AutoIncludeStage,
+} from './autoIncludePlanner'
+import type { AutoIncludeProgressiveVariantConfig } from './routeConfig'
+
+const STAGE_CONCURRENCY = 4
+type IntervalHandle = ReturnType<typeof setInterval>
+
+export type RunAutoIncludeOptions = {
+  req: Request
+  res: Response
+  ctx: OperationContext
+  args: Record<string, unknown>
+  baseOp: 'findUnique' | 'findUniqueOrThrow' | 'findFirst' | 'findFirstOrThrow'
+  modelName: string
+  delegateKey: string
+  models: Record<string, ModelRelationMap>
+  variantConfig: AutoIncludeProgressiveVariantConfig
+  coreQueryFn: () => Promise<unknown>
+}
+
+function isObject(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === 'object' && !Array.isArray(v)
+}
+
+function readPath(source: Record<string, unknown>, path: string): unknown {
+  if (path === '') return source
+  const parts = path.split('.')
+  let cursor: unknown = source
+  for (const part of parts) {
+    if (!isObject(cursor)) return undefined
+    cursor = cursor[part]
+  }
+  return cursor
+}
+
+function stripInternalAtScope(
+  target: Record<string, unknown>,
+  internalPaths: string[],
+  scopePath: string,
+): void {
+  for (const fullPath of internalPaths) {
+    if (scopePath === '') {
+      if (!fullPath.includes('.')) {
+        delete target[fullPath]
+      }
+      continue
+    }
+    if (!fullPath.startsWith(scopePath + '.')) continue
+    const relative = fullPath.slice(scopePath.length + 1)
+    if (relative.includes('.')) continue
+    delete target[relative]
+  }
+}
+
+function mergeWhere(
+  userWhere: unknown,
+  linkFilter: Record<string, unknown>,
+): Record<string, unknown> {
+  if (!isObject(userWhere) || Object.keys(userWhere).length === 0) return linkFilter
+  return { AND: [userWhere, linkFilter] }
+}
+
+function buildLinkFilter(
+  stage: AutoIncludeStage,
+  parentValue: Record<string, unknown>,
+): Record<string, unknown> | null {
+  const filter: Record<string, unknown> = {}
+  const rel = stage.relationField
+  for (let i = 0; i < rel.parentLinkFields.length; i++) {
+    const parentKey = rel.parentLinkFields[i]
+    const childKey = rel.childLinkFields[i]
+    const value = parentValue[parentKey]
+    if (value === undefined || value === null) return null
+    filter[childKey] = value
+  }
+  return filter
+}
+
+function emptyResultFor(isList: boolean): unknown {
+  return isList ? [] : null
+}
+
+async function runOneStage(options: {
+  extended: unknown
+  models: Record<string, ModelRelationMap>
+  stage: AutoIncludeStage
+  internal: Record<string, unknown>
+  publicState: Record<string, unknown>
+  internalFieldPaths: string[]
+  res: Response
+}): Promise<void> {
+  const { extended, models, stage, internal, publicState, internalFieldPaths, res } = options
+  if (res.writableEnded || res.destroyed) return
+
+  const parentRaw = readPath(internal, stage.parentPath)
+  if (!isObject(parentRaw)) {
+    const empty = emptyResultFor(stage.relationField.isList)
+    setByPath(publicState, stage.relationPath, empty)
+    sendSSEField(res, stage.relationPath, empty)
+    return
+  }
+
+  const linkFilter = buildLinkFilter(stage, parentRaw)
+  if (!linkFilter) {
+    const empty = emptyResultFor(stage.relationField.isList)
+    setByPath(publicState, stage.relationPath, empty)
+    sendSSEField(res, stage.relationPath, empty)
+    return
+  }
+
+  const targetModel = models[stage.relationField.type]
+  if (!targetModel) {
+    const empty = emptyResultFor(stage.relationField.isList)
+    setByPath(publicState, stage.relationPath, empty)
+    sendSSEField(res, stage.relationPath, empty)
+    return
+  }
+
+  const finalArgs: Record<string, unknown> = { ...stage.stageArgs }
+  finalArgs.where = mergeWhere(stage.stageArgs.where, linkFilter)
+
+  const delegate: PrismaDelegate = getDelegate(extended, targetModel.delegateKey)
+  const method: 'findMany' | 'findFirst' = stage.relationField.isList ? 'findMany' : 'findFirst'
+  const result = await delegate[method](finalArgs)
+
+  setByPath(internal, stage.relationPath, result)
+
+  let publicResult: unknown
+  if (Array.isArray(result)) {
+    publicResult = result
+  } else if (isObject(result)) {
+    const copy: Record<string, unknown> = { ...result }
+    stripInternalAtScope(copy, internalFieldPaths, stage.relationPath)
+    publicResult = copy
+  } else {
+    publicResult = result
+  }
+
+  setByPath(publicState, stage.relationPath, publicResult)
+  sendSSEField(res, stage.relationPath, publicResult)
+}
+
+function groupStagesByDepth(stages: AutoIncludeStage[]): AutoIncludeStage[][] {
+  const byDepth = new Map<number, AutoIncludeStage[]>()
+  for (const s of stages) {
+    const arr = byDepth.get(s.depth)
+    if (arr) arr.push(s)
+    else byDepth.set(s.depth, [s])
+  }
+  return Array.from(byDepth.keys())
+    .sort((a, b) => a - b)
+    .map((d) => byDepth.get(d) as AutoIncludeStage[])
+}
+
+async function runConcurrent<T>(
+  items: T[],
+  limit: number,
+  fn: (item: T) => Promise<void>,
+): Promise<void> {
+  let index = 0
+  const workers: Promise<void>[] = []
+  const workerCount = Math.min(limit, items.length)
+  for (let w = 0; w < workerCount; w++) {
+    workers.push((async () => {
+      for (;;) {
+        const i = index++
+        if (i >= items.length) return
+        await fn(items[i])
+      }
+    })())
+  }
+  await Promise.all(workers)
+}
+
+export async function runAutoIncludeProgressive(
+  options: RunAutoIncludeOptions,
+): Promise<void> {
+  const { req, res, ctx, args, baseOp, modelName, delegateKey, models, variantConfig, coreQueryFn } = options
+
+  if (ctx.guardShape) {
+    return runSingleResultSSE({ req, res, coreQueryFn })
+  }
+
+  const plan = planAutoInclude({
+    rootModelName: modelName,
+    models,
+    args,
+  })
+
+  if (plan.unsupportedReason) {
+    if (variantConfig.fallback === 'error') {
+      let keepalive: IntervalHandle | null = null
+      try {
+        initSSE(res)
+        keepalive = startSSEKeepalive(res)
+        sendSSEError(res, plan.unsupportedReason)
+      } finally {
+        endSSE(res, keepalive)
+      }
+      return
+    }
+    return runSingleResultSSE({ req, res, coreQueryFn })
+  }
+
+  if (plan.stages.length === 0) {
+    return runSingleResultSSE({ req, res, coreQueryFn })
+  }
+
+  let keepalive: IntervalHandle | null = null
+  try {
+    initSSE(res)
+    keepalive = startSSEKeepalive(res)
+    if (req.destroyed) return
+
+    const extended = await getExtendedClient(ctx)
+    const rootDelegate = getDelegate(extended, delegateKey)
+
+    let rootResult: unknown
+    try {
+      rootResult = await rootDelegate[baseOp](plan.rootArgs)
+    } catch (err) {
+      const code = (err as { code?: string } | null)?.code
+      const isOrThrow = baseOp === 'findUniqueOrThrow' || baseOp === 'findFirstOrThrow'
+      if (isOrThrow && code === 'P2025') {
+        sendSSEError(res, 'Record not found')
+        return
+      }
+      console.error('[auto-progressive] root query failed:', err)
+      sendSSEError(res, 'Root query failed')
+      return
+    }
+
+    if (res.writableEnded || res.destroyed) return
+
+    if (rootResult === null || !isObject(rootResult)) {
+      sendSSEResult(res, null)
+      return
+    }
+
+    const internal: Record<string, unknown> = { ...rootResult }
+    const publicRoot: Record<string, unknown> = { ...rootResult }
+    stripInternalAtScope(publicRoot, plan.internalFieldPaths, '')
+
+    const publicState: Record<string, unknown> = { ...publicRoot }
+    for (const [k, v] of Object.entries(publicRoot)) {
+      sendSSEField(res, k, v)
+    }
+
+    sendSSEProgress(res, 'root', 0, plan.stages.length)
+
+    const groups = groupStagesByDepth(plan.stages)
+    let completed = 0
+
+    for (const group of groups) {
+      if (res.writableEnded || res.destroyed) return
+      await runConcurrent(group, STAGE_CONCURRENCY, async (stage) => {
+        try {
+          await runOneStage({
+            extended,
+            models,
+            stage,
+            internal,
+            publicState,
+            internalFieldPaths: plan.internalFieldPaths,
+            res,
+          })
+        } catch (err) {
+          console.error('[auto-progressive] stage failed:', stage.relationPath, err)
+          const empty = emptyResultFor(stage.relationField.isList)
+          setByPath(publicState, stage.relationPath, empty)
+          sendSSEField(res, stage.relationPath, empty)
+        }
+        completed++
+        sendSSEProgress(res, stage.relationPath, completed, plan.stages.length)
+      })
+    }
+
+    if (res.writableEnded || res.destroyed) return
+    sendSSEResult(res, publicState)
+  } catch (err) {
+    console.error('[auto-progressive] dispatch error:', err)
+    if (!res.writableEnded && !res.destroyed) {
+      sendSSEError(res, 'Internal server error')
+    }
+  } finally {
+    endSSE(res, keepalive)
+  }
+}