prisma-generator-express 1.62.1 → 1.62.3

package/src/copy/autoIncludeRuntimeGuarded.ts

@@ -157,7 +157,7 @@ async function runRootQuery(
 }
 
 async function runStage(
-  extended: unknown,
+  base: unknown,
   models: Record<string, ModelRelationMap>,
   stage: GuardedAutoIncludeStage,
   parentValue: unknown,
@@ -196,38 +196,9 @@ async function runStage(
     [childKey]: { in: [linkVal] },
   }
 
-  const stageDelegate = getDelegate(extended, targetModel.delegateKey)
+  const stageDelegate = getDelegate(base, targetModel.delegateKey)
   const g = guarded(stageDelegate, stage.stageShape, caller)
 
-  if (stage.relationPath === 'featureFlags' || stage.relationPath === 'companies') {
-    const raw = rel.isList
-      ? await stageDelegate.findMany(stageArgs)
-      : await stageDelegate.findFirst(stageArgs)
-
-    const guardedResult = rel.isList
-      ? await g.findMany(stageArgs)
-      : await g.findFirst(stageArgs)
-
-    console.dir(
-      {
-        relationPath: stage.relationPath,
-        targetDelegateKey: targetModel.delegateKey,
-        parentKey,
-        childKey,
-        linkVal,
-        stageArgs,
-        stageShape: stage.stageShape,
-        rawCount: Array.isArray(raw) ? raw.length : raw ? 1 : 0,
-        guardedCount: Array.isArray(guardedResult) ? guardedResult.length : guardedResult ? 1 : 0,
-        raw,
-        guardedResult,
-      },
-      { depth: null },
-    )
-
-    return guardedResult
-  }
-
   if (rel.isList) {
     return g.findMany(stageArgs)
   }
@@ -297,7 +268,7 @@ async function runGuardedAutoIncludeSingle(
       if (isAborted()) return
       try {
         const stageResult = await runStage(
-          extended,
+          ctx.prisma,
           models,
           stage,
           internal,

package/src/copy/projectionDefaults.ts

@@ -0,0 +1,473 @@
+import { isPlainObject } from './misc'
+
+const SHAPE_KEYS = new Set([
+  'where',
+  'select',
+  'include',
+  'orderBy',
+  'cursor',
+  'take',
+  'skip',
+  'distinct',
+  'having',
+  '_count',
+  '_avg',
+  '_sum',
+  '_min',
+  '_max',
+  'by',
+  'data',
+  'create',
+  'update',
+])
+
+const COMBINATOR_KEYS = new Set(['AND', 'OR', 'NOT'])
+const TO_ONE_RELATION_OPS = new Set(['is', 'isNot'])
+const TO_MANY_RELATION_OPS = new Set(['some', 'every', 'none'])
+const ALL_RELATION_OPS = new Set([
+  ...TO_ONE_RELATION_OPS,
+  ...TO_MANY_RELATION_OPS,
+])
+
+const FORCED_MARKER = Symbol.for('prisma-guard.forced')
+
+function isForcedValue(v: unknown): v is { value: unknown } {
+  return (
+    v !== null &&
+    typeof v === 'object' &&
+    (v as Record<PropertyKey, unknown>)[FORCED_MARKER] === true
+  )
+}
+
+export type ContextResolver = () => unknown | Promise<unknown>
+
+export type OpKind =
+  | 'read'
+  | 'readUnique'
+  | 'create'
+  | 'createMany'
+  | 'update'
+  | 'updateMany'
+  | 'upsert'
+  | 'delete'
+  | 'deleteMany'
+  | 'noop'
+
+interface WhereForced {
+  conditions: Record<string, unknown>
+  relations: Record<string, Record<string, WhereForced>>
+}
+
+function emptyForced(): WhereForced {
+  return { conditions: {}, relations: {} }
+}
+
+function hasForced(f: WhereForced): boolean {
+  return (
+    Object.keys(f.conditions).length > 0 ||
+    Object.keys(f.relations).length > 0
+  )
+}
+
+function isDirectGuardShape(input: Record<string, unknown>): boolean {
+  const keys = Object.keys(input)
+  if (keys.length === 0) return true
+  return keys.every((k) => SHAPE_KEYS.has(k))
+}
+
+async function callShapeFn(
+  fn: (ctx: unknown) => unknown,
+  resolveContext: ContextResolver | undefined,
+): Promise<Record<string, unknown> | null> {
+  if (!resolveContext) return null
+  const ctx = await resolveContext()
+  const result = fn(ctx)
+  if (!isPlainObject(result)) return null
+  return result
+}
+
+async function resolveShape(
+  input: unknown,
+  caller: string | undefined,
+  resolveContext: ContextResolver | undefined,
+): Promise<Record<string, unknown> | null> {
+  if (!input) return null
+
+  if (typeof input === 'function') {
+    return callShapeFn(input as (ctx: unknown) => unknown, resolveContext)
+  }
+
+  if (!isPlainObject(input)) return null
+  if (isDirectGuardShape(input)) return input
+
+  let entry: unknown = undefined
+  if (caller !== undefined && caller in input) entry = input[caller]
+  if (entry === undefined && 'default' in input) entry = input['default']
+  if (entry === undefined) return null
+
+  if (typeof entry === 'function') {
+    return callShapeFn(entry as (ctx: unknown) => unknown, resolveContext)
+  }
+  if (!isPlainObject(entry)) return null
+  return entry
+}
+
+function buildDefaultCount(config: unknown): unknown {
+  if (config === true) return true
+  if (!isPlainObject(config)) return true
+  const selectVal = config.select
+  if (!isPlainObject(selectVal)) return true
+  const result: Record<string, unknown> = {}
+  for (const key of Object.keys(selectVal)) result[key] = true
+  return { select: result }
+}
+
+function buildRelSkeleton(
+  config: Record<string, unknown>,
+): Record<string, unknown> {
+  const skel: Record<string, unknown> = {}
+  if (isPlainObject(config.select)) {
+    skel.select = buildDefaultProjectionInput(config.select)
+  }
+  if (isPlainObject(config.include)) {
+    skel.include = buildDefaultProjectionInput(config.include)
+  }
+  return skel
+}
+
+function buildDefaultProjectionInput(
+  config: Record<string, unknown>,
+): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(config)) {
+    if (key === '_count') {
+      result[key] = buildDefaultCount(value)
+      continue
+    }
+    if (value === true) {
+      result[key] = true
+      continue
+    }
+    if (isPlainObject(value)) {
+      result[key] = buildRelSkeleton(value)
+    }
+  }
+  return result
+}
+
+function buildDefaultProjectionBody(
+  shape: Record<string, unknown>,
+): Record<string, unknown> | null {
+  if (isPlainObject(shape.select)) {
+    return { select: buildDefaultProjectionInput(shape.select) }
+  }
+  if (isPlainObject(shape.include)) {
+    return { include: buildDefaultProjectionInput(shape.include) }
+  }
+  return null
+}
+
+function extractForcedFromWhereConfig(
+  whereConfig: Record<string, unknown>,
+): WhereForced {
+  const forced = emptyForced()
+
+  for (const [key, value] of Object.entries(whereConfig)) {
+    if (COMBINATOR_KEYS.has(key)) continue
+
+    if (isForcedValue(value)) {
+      forced.conditions[key] = value.value
+      continue
+    }
+
+    if (isPlainObject(value)) {
+      const relOps: Record<string, WhereForced> = {}
+      let hasRelOp = false
+
+      for (const [op, opValue] of Object.entries(value)) {
+        if (!ALL_RELATION_OPS.has(op)) continue
+        if (opValue === null) continue
+        if (!isPlainObject(opValue)) continue
+        const nested = extractForcedFromWhereConfig(opValue)
+        if (hasForced(nested)) {
+          relOps[op] = nested
+          hasRelOp = true
+        }
+      }
+
+      if (hasRelOp) {
+        forced.relations[key] = relOps
+        continue
+      }
+
+      const forcedOps: Record<string, unknown> = {}
+      let hasForcedOp = false
+      for (const [op, opValue] of Object.entries(value)) {
+        if (isForcedValue(opValue)) {
+          forcedOps[op] = opValue.value
+          hasForcedOp = true
+        }
+      }
+      if (hasForcedOp) {
+        forced.conditions[key] = forcedOps
+      }
+    }
+  }
+
+  return forced
+}
+
+function extractForcedFromDataConfig(
+  dataConfig: Record<string, unknown>,
+): Record<string, unknown> {
+  const forced: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(dataConfig)) {
+    if (isForcedValue(value)) {
+      forced[key] = value.value
+      continue
+    }
+    if (typeof value === 'function') continue
+    if (value === true) continue
+    if (isPlainObject(value)) continue
+    forced[key] = value
+  }
+  return forced
+}
+
+function mergeWhereForced(
+  where: Record<string, unknown> | undefined,
+  forced: WhereForced,
+): Record<string, unknown> {
+  if (!hasForced(forced)) return where ?? {}
+
+  let result: Record<string, unknown> = where ? { ...where } : {}
+
+  for (const [relName, opMap] of Object.entries(forced.relations)) {
+    if (!isPlainObject(result[relName])) {
+      result[relName] = {}
+    }
+    const relObj = { ...(result[relName] as Record<string, unknown>) }
+    for (const [op, nestedForced] of Object.entries(opMap)) {
+      relObj[op] = mergeWhereForced(
+        isPlainObject(relObj[op])
+          ? (relObj[op] as Record<string, unknown>)
+          : undefined,
+        nestedForced,
+      )
+    }
+    result[relName] = relObj
+  }
+
+  if (Object.keys(forced.conditions).length > 0) {
+    const remaining: Record<string, unknown> = {}
+    for (const [field, forcedValue] of Object.entries(forced.conditions)) {
+      const existing = result[field]
+
+      if (existing === undefined) {
+        remaining[field] = forcedValue
+        continue
+      }
+
+      if (isPlainObject(existing) && isPlainObject(forcedValue)) {
+        result[field] = { ...existing, ...forcedValue }
+        continue
+      }
+
+      if (isPlainObject(existing) && !isPlainObject(forcedValue)) {
+        result[field] = { ...existing, equals: forcedValue }
+        continue
+      }
+
+      if (!isPlainObject(existing) && isPlainObject(forcedValue)) {
+        result[field] = { equals: existing, ...forcedValue }
+        continue
+      }
+
+      remaining[field] = forcedValue
+    }
+
+    if (Object.keys(remaining).length > 0) {
+      if (Object.keys(result).length === 0) {
+        result = remaining
+      } else {
+        result = { AND: [result, remaining] }
+      }
+    }
+  }
+
+  return result
+}
+
+function mergeUniqueWhereForced(
+  where: Record<string, unknown> | undefined,
+  forced: WhereForced,
+): Record<string, unknown> {
+  if (!hasForced(forced)) return where ?? {}
+
+  const result: Record<string, unknown> = where ? { ...where } : {}
+
+  for (const [key, value] of Object.entries(forced.conditions)) {
+    if (!(key in result)) {
+      result[key] = value
+      continue
+    }
+    if (isPlainObject(result[key]) && isPlainObject(value)) {
+      result[key] = {
+        ...(result[key] as Record<string, unknown>),
+        ...(value as Record<string, unknown>),
+      }
+    } else {
+      result[key] = value
+    }
+  }
+
+  return result
+}
+
+function applyProjectionToTarget(
+  target: Record<string, unknown>,
+  projection: Record<string, unknown>,
+): void {
+  if ('select' in target || 'include' in target) return
+  Object.assign(target, projection)
+}
+
+function mergeForcedData(
+  targetData: unknown,
+  forced: Record<string, unknown>,
+): Record<string, unknown> | unknown[] {
+  if (Array.isArray(targetData)) {
+    return targetData.map((item) => {
+      if (!isPlainObject(item)) return { ...forced }
+      return { ...item, ...forced }
+    })
+  }
+  if (isPlainObject(targetData)) {
+    return { ...targetData, ...forced }
+  }
+  return { ...forced }
+}
+
+interface WhereMergeOptions {
+  targetContainer: Record<string, unknown>
+  whereKey: string
+  forced: WhereForced
+  isUnique: boolean
+}
+
+function applyForcedWhere(opts: WhereMergeOptions): void {
+  if (!hasForced(opts.forced)) return
+  const existing = opts.targetContainer[opts.whereKey]
+  const merged = opts.isUnique
+    ? mergeUniqueWhereForced(
+        isPlainObject(existing)
+          ? (existing as Record<string, unknown>)
+          : undefined,
+        opts.forced,
+      )
+    : mergeWhereForced(
+        isPlainObject(existing)
+          ? (existing as Record<string, unknown>)
+          : undefined,
+        opts.forced,
+      )
+  opts.targetContainer[opts.whereKey] = merged
+}
+
+export async function applyDroppedGuard(
+  shape: unknown,
+  caller: string | undefined,
+  resolveContext: ContextResolver | undefined,
+  opKind: OpKind,
+  targets: {
+    readQuery?: Record<string, unknown>
+    writeBody?: Record<string, unknown>
+  },
+  ensureReadTarget: () => Record<string, unknown>,
+  ensureWriteTarget: () => Record<string, unknown>,
+): Promise<void> {
+  const resolved = await resolveShape(shape, caller, resolveContext)
+  if (!resolved) return
+
+  const projection = buildDefaultProjectionBody(resolved)
+
+  if (opKind === 'read' || opKind === 'readUnique') {
+    const isUnique = opKind === 'readUnique'
+    const shapeWhere = isPlainObject(resolved.where)
+      ? extractForcedFromWhereConfig(resolved.where)
+      : emptyForced()
+
+    if (projection || hasForced(shapeWhere)) {
+      const target = targets.readQuery ?? ensureReadTarget()
+      if (projection) applyProjectionToTarget(target, projection)
+      if (hasForced(shapeWhere)) {
+        applyForcedWhere({
+          targetContainer: target,
+          whereKey: 'where',
+          forced: shapeWhere,
+          isUnique,
+        })
+      }
+    }
+    return
+  }
+
+  if (opKind === 'noop') return
+
+  const shapeWhere = isPlainObject(resolved.where)
+    ? extractForcedFromWhereConfig(resolved.where)
+    : emptyForced()
+
+  const forcedData =
+    opKind === 'create' || opKind === 'createMany' || opKind === 'update' || opKind === 'updateMany'
+      ? isPlainObject(resolved.data)
+        ? extractForcedFromDataConfig(resolved.data)
+        : {}
+      : {}
+
+  const forcedCreate =
+    opKind === 'upsert' && isPlainObject(resolved.create)
+      ? extractForcedFromDataConfig(resolved.create)
+      : {}
+
+  const forcedUpdate =
+    opKind === 'upsert' && isPlainObject(resolved.update)
+      ? extractForcedFromDataConfig(resolved.update)
+      : {}
+
+  const needsBody =
+    projection !== null ||
+    hasForced(shapeWhere) ||
+    Object.keys(forcedData).length > 0 ||
+    Object.keys(forcedCreate).length > 0 ||
+    Object.keys(forcedUpdate).length > 0
+
+  if (!needsBody) return
+
+  const target = targets.writeBody ?? ensureWriteTarget()
+
+  if (projection) applyProjectionToTarget(target, projection)
+
+  if (hasForced(shapeWhere)) {
+    const isUnique =
+      opKind === 'update' || opKind === 'delete' || opKind === 'upsert'
+    applyForcedWhere({
+      targetContainer: target,
+      whereKey: 'where',
+      forced: shapeWhere,
+      isUnique,
+    })
+  }
+
+  if (Object.keys(forcedData).length > 0) {
+    target.data = mergeForcedData(target.data, forcedData)
+  }
+
+  if (Object.keys(forcedCreate).length > 0) {
+    target.create = mergeForcedData(target.create, forcedCreate)
+  }
+
+  if (Object.keys(forcedUpdate).length > 0) {
+    target.update = mergeForcedData(target.update, forcedUpdate)
+  }
+}

package/src/generators/generateRouter.ts

@@ -5,12 +5,6 @@ import { importExt } from '../utils/importExt'
 import { WriteStrategy, FindManyPaginatedMode } from '../constants'
 import { OPERATION_METADATA } from '../copy/operationDefinitions'
 
-interface OpEmitContext {
-  modelName: string
-  basePath: string
-  postReadsEnabled: string
-}
-
 function pathExpr(basePath: string, suffix: string): string {
   if (!suffix) return basePath || '/'
   if (!basePath) return `'${suffix}'`
@@ -28,7 +22,7 @@ function emitReadOp(
   const postReadBlock = meta.supportsPostRead
     ? `    if (postReadsEnabled) {
       const postPath = ${meta.name === 'findMany' ? "basePath ? `${basePath}/read` : '/read'" : `path`}
-      router.post(postPath, parseBodyAsQuery, setShape(opConfig), ...before, ${handlerName} as RequestHandler, ...after, respond)
+      router.post(postPath, parseBodyAsQuery, setShape(opConfig, 'read'), ...before, ${handlerName} as RequestHandler, ...after, respond)
     }`
     : ''
 
@@ -36,7 +30,7 @@ function emitReadOp(
     const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = ${pathValue}
-    router.get(path, parseQuery, setShape(opConfig), ...before, maybeProgressiveSSE(opConfig, core.${meta.coreName}, '${meta.name}'), ${handlerName} as RequestHandler, ...after, respond)
+    router.get(path, parseQuery, setShape(opConfig, 'read'), ...before, maybeProgressiveSSE(opConfig, core.${meta.coreName}, '${meta.name}'), ${handlerName} as RequestHandler, ...after, respond)
 ${postReadBlock}
   }`
 }
@@ -54,7 +48,7 @@ function emitWriteOp(
     const opConfig: OperationConfigLike = (config.${meta.configKey} as OperationConfigLike | undefined) ?? defaultOpConfig
     const { before = [], after = [] } = opConfig
     const path = ${pathValue}
-    router.${meta.method}(path, setShape(opConfig), ...before, ${handlerName} as RequestHandler, ...after, ${respondFn})
+    router.${meta.method}(path, setShape(opConfig, 'write'), ...before, ${handlerName} as RequestHandler, ...after, ${respondFn})
   }`
 }
 
@@ -114,7 +108,7 @@ import type {
   PaginationConfig,
 } from '../routeConfig.target${ext}'
 import { parseQueryParams } from '../parseQueryParams${ext}'
-import { sanitizeKeys, normalizePrefix, getEnv } from '../misc${ext}'
+import { sanitizeKeys, normalizePrefix, getEnv, isPlainObject } from '../misc${ext}'
 import { buildModelOpenApi } from '../buildModelOpenApi${ext}'
 import { validateCountSourceWhere } from '../routeConfig${ext}'
 import type { OperationContext } from '../operationRuntime${ext}'
@@ -130,6 +124,10 @@ import {
 } from '../sse${ext}'
 import { relationModels } from '../relationModels${ext}'
 import { runAutoIncludeProgressive } from '../autoIncludeRuntime${ext}'
+import {
+  resolveDroppedGuardProjection,
+  applyProjectionToTarget,
+} from '../projectionDefaults${ext}'
 import { MODEL_FIELDS, MODEL_ENUMS } from './${modelName}Metadata${ext}'
 
 ${generateRouteConfigType(modelName, 'RequestHandler', guardShapesImport, importStyle, 'express')}
@@ -258,6 +256,11 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
     }
   }
 
+  const buildResolveContext = (req: Request): (() => unknown | Promise<unknown>) | undefined => {
+    if (typeof config.resolveContext !== 'function') return undefined
+    return () => (config.resolveContext as (r: Request) => unknown | Promise<unknown>)(req)
+  }
+
   const parseQuery: RequestHandler = (req, res, next) => {
     const rawQuery = req.query
     if (rawQuery && Object.keys(rawQuery).length > 0) {
@@ -275,19 +278,47 @@ export function ${routerFunctionName}<TCtx = unknown, TPrisma = any>(config: ${m
     next()
   }
 
-  const setShape = (opConfig: OperationConfigLike): RequestHandler => {
-    return (req, res, next) => {
-      const locals = readLocals(res)
-      const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
-      if (merged) {
-        locals.routeConfig = { pagination: merged }
+  const setShape = (opConfig: OperationConfigLike, kind: 'read' | 'write'): RequestHandler => {
+    return async (req, res, next) => {
+      try {
+        const locals = readLocals(res)
+        const merged = mergePaginationConfig(config.pagination, opConfig.pagination)
+        if (merged) {
+          locals.routeConfig = { pagination: merged }
+        }
+        const headerName = config.guard?.variantHeader || 'x-api-variant'
+        const headerValue = req.get(headerName)
+        const caller = config.guard?.resolveVariant?.(req) ?? headerValue ?? undefined
+        if (caller) locals.guardCaller = caller
+        if (opConfig.shape) {
+          if (!DROP_GUARD) {
+            locals.guardShape = opConfig.shape
+          } else {
+            const projection = await resolveDroppedGuardProjection(
+              opConfig.shape,
+              caller,
+              buildResolveContext(req),
+            )
+            if (projection) {
+              if (kind === 'read') {
+                if (!locals.parsedQuery) locals.parsedQuery = {}
+                applyProjectionToTarget(locals.parsedQuery, projection)
+              } else {
+                if (!isPlainObject(req.body)) {
+                  req.body = {}
+                }
+                applyProjectionToTarget(
+                  req.body as Record<string, unknown>,
+                  projection,
+                )
+              }
+            }
+          }
+        }
+        next()
+      } catch (err) {
+        next(mapError(err))
       }
-      const headerName = config.guard?.variantHeader || 'x-api-variant'
-      const headerValue = req.get(headerName)
-      const caller = config.guard?.resolveVariant?.(req) ?? headerValue ?? undefined
-      if (caller) locals.guardCaller = caller
-      if (opConfig.shape && !DROP_GUARD) locals.guardShape = opConfig.shape
-      next()
     }
   }
 
@@ -442,7 +473,7 @@ ${writeOpBlocks}
     const path = basePath ? \`\${basePath}/each\` : '/each'
     router.post(
       path,
-      setShape(opConfig),
+      setShape(opConfig, 'write'),
       ...before,
       async (req: Request, res: Response, next: NextFunction) => {
         try {
@@ -470,4 +501,4 @@ ${writeOpBlocks}
   return router
 }
 `
-}
+}