prisma-generator-express 1.62.3 → 1.63.0

package/src/copy/guardVariantRouting.ts

@@ -0,0 +1,109 @@
+export type GuardVariantResolutionInput =
+  | { kind: 'single' }
+  | {
+      kind: 'named'
+      keys: readonly string[]
+      caller?: string
+      reservedKeys: ReadonlySet<string>
+    }
+
+export type GuardVariantResolution =
+  | { ok: true; key: string }
+  | {
+      ok: false
+      code:
+        | 'reserved-key'
+        | 'missing-caller'
+        | 'ambiguous-caller'
+        | 'unknown-caller'
+      caller?: string
+      key?: string
+      keys: readonly string[]
+      matches?: readonly string[]
+    }
+
+function matchVariantPatterns(
+  keys: readonly string[],
+  caller: string,
+): string[] {
+  const callerParts = caller.split('/')
+  const matches: string[] = []
+
+  for (const pattern of keys) {
+    if (!pattern.includes(':')) continue
+
+    const patternParts = pattern.split('/')
+    if (patternParts.length !== callerParts.length) continue
+
+    let matchesCaller = true
+
+    for (let index = 0; index < patternParts.length; index++) {
+      if (patternParts[index].startsWith(':')) continue
+      if (patternParts[index] !== callerParts[index]) {
+        matchesCaller = false
+        break
+      }
+    }
+
+    if (matchesCaller) matches.push(pattern)
+  }
+
+  return matches
+}
+
+export function resolveGuardVariantKey(
+  input: GuardVariantResolutionInput,
+): GuardVariantResolution {
+  if (input.kind === 'single') {
+    return { ok: true, key: '_default' }
+  }
+
+  const { keys, caller, reservedKeys } = input
+
+  for (const key of keys) {
+    if (reservedKeys.has(key)) {
+      return {
+        ok: false,
+        code: 'reserved-key',
+        key,
+        keys,
+      }
+    }
+  }
+
+  const hasDefault = keys.includes('default')
+
+  if (typeof caller !== 'string') {
+    if (hasDefault) return { ok: true, key: 'default' }
+    return { ok: false, code: 'missing-caller', keys }
+  }
+
+  if (caller.trim().length === 0) {
+    if (hasDefault) return { ok: true, key: 'default' }
+    return { ok: false, code: 'unknown-caller', caller, keys }
+  }
+
+  if (keys.includes(caller)) {
+    return { ok: true, key: caller }
+  }
+
+  const matches = matchVariantPatterns(keys, caller)
+
+  if (matches.length === 1) {
+    return { ok: true, key: matches[0] }
+  }
+
+  if (matches.length > 1) {
+    return {
+      ok: false,
+      code: 'ambiguous-caller',
+      caller,
+      keys,
+      matches,
+    }
+  }
+
+  if (hasDefault) return { ok: true, key: 'default' }
+
+  return { ok: false, code: 'unknown-caller', caller, keys }
+}

package/src/copy/projectionDefaults.ts

@@ -88,7 +88,7 @@ async function callShapeFn(
 
 async function resolveShape(
   input: unknown,
-  caller: string | undefined,
+  resolvedKey: string | undefined,
   resolveContext: ContextResolver | undefined,
 ): Promise<Record<string, unknown> | null> {
   if (!input) return null
@@ -100,9 +100,8 @@ async function resolveShape(
   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 (resolvedKey === undefined) return null
+  const entry = input[resolvedKey]
   if (entry === undefined) return null
 
   if (typeof entry === 'function') {
@@ -376,7 +375,7 @@ function applyForcedWhere(opts: WhereMergeOptions): void {
 
 export async function applyDroppedGuard(
   shape: unknown,
-  caller: string | undefined,
+  resolvedKey: string | undefined,
   resolveContext: ContextResolver | undefined,
   opKind: OpKind,
   targets: {
@@ -386,7 +385,7 @@ export async function applyDroppedGuard(
   ensureReadTarget: () => Record<string, unknown>,
   ensureWriteTarget: () => Record<string, unknown>,
 ): Promise<void> {
-  const resolved = await resolveShape(shape, caller, resolveContext)
+  const resolved = await resolveShape(shape, resolvedKey, resolveContext)
   if (!resolved) return
 
   const projection = buildDefaultProjectionBody(resolved)

package/src/copy/routeConfig.hono.ts

@@ -1,4 +1,5 @@
 import type { Context } from 'hono'
+import type { GuardVariantResolution } from './guardVariantRouting'
 import type {
   BaseOperationConfig,
   BaseRouteConfig,
@@ -35,6 +36,8 @@ export type HonoInternalVariables = {
   routeConfig?: { pagination?: PaginationConfig }
   guardShape?: Record<string, unknown>
   guardCaller?: string
+  guardVariantKey?: string
+  guardVariantFailure?: Extract<GuardVariantResolution, { ok: false }>
   resultData?: unknown
   resultStatus?: number
 }
@@ -58,10 +61,11 @@ export type HonoHookHandler<TEnv extends HonoEnvBase = HonoEnvBase> = HonoBefore
 export type OperationConfig<
   TShape = Record<string, unknown>,
   TEnv extends HonoEnvBase = HonoEnvBase,
-> = Omit<BaseOperationConfig<HonoBeforeHook<TEnv>, TShape>, 'before' | 'after'> & {
-  before?: HonoBeforeHook<TEnv>[]
-  after?: HonoAfterHook<TEnv>[]
-}
+> = BaseOperationConfig<
+  HonoBeforeHook<TEnv>,
+  TShape,
+  HonoAfterHook<TEnv>
+>
 
 export type UpdateEachConfig<TEnv extends HonoEnvBase = HonoEnvBase> = {
   before?: HonoBeforeHook<TEnv>[]
@@ -94,7 +98,13 @@ export type RouteConfig<
   TCtx = unknown,
   TEnv extends HonoEnvBase = HonoEnvBase,
 > = Omit<
-  BaseRouteConfig<HonoBeforeHook<TEnv>, Context<GeneratedHonoEnv<TEnv>>, TShape, TCtx>,
+  BaseRouteConfig<
+    HonoBeforeHook<TEnv>,
+    Context<GeneratedHonoEnv<TEnv>>,
+    TShape,
+    TCtx,
+    HonoAfterHook<TEnv>
+  >,
   HonoOpKeys
 > & {
   findUnique?: OperationConfig<TShape, TEnv> | false

package/src/copy/routeConfig.ts

@@ -1,3 +1,10 @@
+import { GUARD_SHAPE_CONFIG_KEYS } from './guardHelpers'
+import { isPlainObject } from './misc'
+import {
+  resolveGuardVariantKey,
+  type GuardVariantResolution,
+} from './guardVariantRouting'
+
 export interface QueryBuilderConfig {
   enabled?: boolean
   port?: number
@@ -87,23 +94,43 @@ export type ProgressiveVariantConfig =
   | ManualProgressiveVariantConfig
   | AutoIncludeProgressiveVariantConfig
 
-export interface BaseOperationConfig<HookHandler, TShape = Record<string, unknown>> {
-  before?: HookHandler[]
-  after?: HookHandler[]
-  shape?: TShape
+export type VariantEntry<TShape, TBefore, TAfter> = {
+  shape: TShape
+  before?: TBefore[]
+  after?: TAfter[]
+}
+
+type OperationShapeConfig<TShape, TBefore, TAfter> =
+  | {
+      shape?: TShape
+      variants?: never
+    }
+  | {
+      shape?: never
+      variants: Record<string, VariantEntry<TShape, TBefore, TAfter>>
+    }
+
+export type BaseOperationConfig<
+  TBefore,
+  TShape = Record<string, unknown>,
+  TAfter = TBefore,
+> = OperationShapeConfig<TShape, TBefore, TAfter> & {
+  before?: TBefore[]
+  after?: TAfter[]
   pagination?: Partial<PaginationConfig>
 }
 
-export interface BaseUpdateEachConfig<HookHandler> {
-  before?: HookHandler[]
-  after?: HookHandler[]
+export interface BaseUpdateEachConfig<TBefore, TAfter = TBefore> {
+  before?: TBefore[]
+  after?: TAfter[]
 }
 
 export interface BaseRouteConfig<
-  HookHandler,
+  TBefore,
   RequestType,
   TShape = Record<string, unknown>,
   TCtx = unknown,
+  TAfter = TBefore,
 > {
   enableAll?: boolean
   addModelPrefix?: boolean
@@ -125,30 +152,196 @@ export interface BaseRouteConfig<
   resolveContext?: (request: RequestType) => TCtx | Promise<TCtx>
   queryBuilder?: QueryBuilderConfig | false
   pagination?: PaginationConfig
-  findUnique?: BaseOperationConfig<HookHandler, TShape> | false
-  findUniqueOrThrow?: BaseOperationConfig<HookHandler, TShape> | false
-  findFirst?: BaseOperationConfig<HookHandler, TShape> | false
-  findFirstOrThrow?: BaseOperationConfig<HookHandler, TShape> | false
-  findMany?: BaseOperationConfig<HookHandler, TShape> | false
-  findManyPaginated?: BaseOperationConfig<HookHandler, TShape> | false
-  create?: BaseOperationConfig<HookHandler, TShape> | false
-  createMany?: BaseOperationConfig<HookHandler, TShape> | false
-  createManyAndReturn?: BaseOperationConfig<HookHandler, TShape> | false
-  update?: BaseOperationConfig<HookHandler, TShape> | false
-  updateMany?: BaseOperationConfig<HookHandler, TShape> | false
-  updateManyAndReturn?: BaseOperationConfig<HookHandler, TShape> | false
-  upsert?: BaseOperationConfig<HookHandler, TShape> | false
-  delete?: BaseOperationConfig<HookHandler, TShape> | false
-  deleteMany?: BaseOperationConfig<HookHandler, TShape> | false
-  updateEach?: BaseUpdateEachConfig<HookHandler>
-  aggregate?: BaseOperationConfig<HookHandler, TShape> | false
-  count?: BaseOperationConfig<HookHandler, TShape> | false
-  groupBy?: BaseOperationConfig<HookHandler, TShape> | false
+  findUnique?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findUniqueOrThrow?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findFirst?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findFirstOrThrow?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findMany?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  findManyPaginated?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  create?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  createMany?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  createManyAndReturn?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  update?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  updateMany?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  updateManyAndReturn?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  upsert?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  delete?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  deleteMany?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  updateEach?: BaseUpdateEachConfig<TBefore, TAfter>
+  aggregate?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  count?: BaseOperationConfig<TBefore, TShape, TAfter> | false
+  groupBy?: BaseOperationConfig<TBefore, TShape, TAfter> | false
 }
 
 export type OperationConfig = BaseOperationConfig<unknown>
 export type RouteConfig = BaseRouteConfig<unknown, unknown>
 
+export type NormalizedGuardRouting =
+  | { kind: 'none' }
+  | { kind: 'single' }
+  | { kind: 'named'; keys: readonly string[] }
+
+export type NormalizedVariantHooks<TBefore, TAfter> = Readonly<
+  Record<
+    string,
+    {
+      before: readonly TBefore[]
+      after: readonly TAfter[]
+    }
+  >
+>
+
+export interface NormalizedOperationConfig<TBefore, TAfter> {
+  guardShape?: Record<string, unknown>
+  guardRouting: NormalizedGuardRouting
+  operationBefore: readonly TBefore[]
+  operationAfter: readonly TAfter[]
+  variantHooks: NormalizedVariantHooks<TBefore, TAfter>
+  pagination?: Readonly<Partial<PaginationConfig>>
+}
+
+type OperationConfigInput<TBefore, TAfter> = {
+  before?: TBefore[]
+  after?: TAfter[]
+  shape?: unknown
+  variants?: Record<
+    string,
+    {
+      shape?: unknown
+      before?: TBefore[]
+      after?: TAfter[]
+    }
+  >
+  pagination?: Partial<PaginationConfig>
+}
+
+function classifyGuardRouting(shape: unknown): NormalizedGuardRouting {
+  if (shape === undefined) return { kind: 'none' }
+  if (typeof shape === 'function') return { kind: 'single' }
+  if (!isPlainObject(shape)) return { kind: 'single' }
+
+  const keys = Object.keys(shape)
+  const isSingle =
+    keys.length === 0 ||
+    keys.every((key) => GUARD_SHAPE_CONFIG_KEYS.has(key))
+
+  return isSingle ? { kind: 'single' } : { kind: 'named', keys }
+}
+
+export function validateOperationConfig(
+  config: { shape?: unknown; variants?: unknown } | undefined,
+  location: string,
+): void {
+  if (!config) return
+
+  const hasShape = config.shape !== undefined
+  const hasVariants = config.variants !== undefined
+
+  if (hasShape && hasVariants) {
+    throw new Error(location + ': shape and variants cannot both be defined')
+  }
+
+  if (!hasVariants) return
+
+  const variants = config.variants
+  if (!isPlainObject(variants)) {
+    throw new Error(location + ': variants must be a non-array object')
+  }
+
+  const entries = Object.entries(variants)
+  if (entries.length === 0) {
+    throw new Error(location + ': variants must contain at least one entry')
+  }
+
+  for (const [key, rawEntry] of entries) {
+    if (GUARD_SHAPE_CONFIG_KEYS.has(key)) {
+      throw new Error(
+        location + ': variant name "' + key +
+        '" collides with a reserved guard shape key',
+      )
+    }
+
+    if (!isPlainObject(rawEntry)) {
+      throw new Error(
+        location + ': variant "' + key + '" must be an object with a shape',
+      )
+    }
+
+    if (rawEntry.shape === undefined) {
+      throw new Error(
+        location + ': variant "' + key + '" is missing "shape"',
+      )
+    }
+  }
+}
+
+export function validateUpdateEachConfig(
+  config: { variants?: unknown } | undefined,
+  location: string,
+): void {
+  if (config?.variants !== undefined) {
+    throw new Error(location + ': updateEach does not support variants')
+  }
+}
+
+export function normalizeOperation<TBefore, TAfter>(
+  config: OperationConfigInput<TBefore, TAfter> | undefined,
+): NormalizedOperationConfig<TBefore, TAfter> {
+  const operationBefore = config?.before ?? []
+  const operationAfter = config?.after ?? []
+
+  if (config?.variants !== undefined) {
+    const entries = Object.entries(config.variants)
+
+    return {
+      guardShape: Object.fromEntries(
+        entries.map(([key, entry]) => [key, entry.shape]),
+      ),
+      guardRouting: {
+        kind: 'named',
+        keys: entries.map(([key]) => key),
+      },
+      operationBefore,
+      operationAfter,
+      variantHooks: Object.fromEntries(
+        entries.map(([key, entry]) => [
+          key,
+          {
+            before: entry.before ?? [],
+            after: entry.after ?? [],
+          },
+        ]),
+      ),
+      pagination: config.pagination,
+    }
+  }
+
+  return {
+    guardShape: config?.shape as Record<string, unknown> | undefined,
+    guardRouting: classifyGuardRouting(config?.shape),
+    operationBefore,
+    operationAfter,
+    variantHooks: {},
+    pagination: config?.pagination,
+  }
+}
+
+export function resolveOperationVariantKey(
+  routing: NormalizedGuardRouting,
+  caller: string | undefined,
+): GuardVariantResolution {
+  if (routing.kind === 'none' || routing.kind === 'single') {
+    return resolveGuardVariantKey({ kind: 'single' })
+  }
+
+  return resolveGuardVariantKey({
+    kind: 'named',
+    keys: routing.keys,
+    caller,
+    reservedKeys: GUARD_SHAPE_CONFIG_KEYS,
+  })
+}
+
 export function validateCountSourceWhere(
   cs: PaginationCountSource | undefined,
   location: string,

package/src/generators/generateRouteConfigType.ts

@@ -74,25 +74,55 @@ export function generateRouteConfigType(
 
   const shapeOps = Array.from(new Set(ROUTER_OPERATIONS))
   const opShapeImports = shapeOps
-    .map((op) => `${m}${capitalize(op)}ShapeInput`)
+    .flatMap((op) => {
+      const prefix = `${m}${capitalize(op)}Shape`
+      return [prefix, `${prefix}Input`]
+    })
     .join(',\n  ')
 
+  const shapeOrFnAliases = shapeOps
+    .map((op) => {
+      const prefix = `${m}${capitalize(op)}Shape`
+      return (
+        `type ${prefix}OrFn<TCtx = unknown> =\n` +
+        `  | ${prefix}\n` +
+        `  | ((ctx: TCtx) => ${prefix})`
+      )
+    })
+    .join('\n\n')
+
   const overrides = ROUTER_OPERATIONS.map((routerOp) => {
     const c = capitalize(routerOp)
     const isRead = READ_OPERATION_NAMES.has(routerOp)
-    const lines = [
+    const commonLines = [
       `    before?: ${beforeRef}[]`,
       `    after?: ${afterRef}[]`,
-      `    shape?: ${m}${c}ShapeInput<TCtx>`,
       `    pagination?: Partial<PaginationConfig>`,
     ]
+
     if (isRead && supportsProgressive) {
-      lines.push(`    progressive?: Record<string, ProgressiveVariantConfig>`)
-      lines.push(
+      commonLines.push(
+        `    progressive?: Record<string, ProgressiveVariantConfig>`,
+      )
+      commonLines.push(
         `    progressiveStages?: Record<string, ProgressiveStage<TCtx, TPrisma>>`,
       )
     }
-    return `  ${routerOp}?: {\n${lines.join('\n')}\n  } | false`
+
+    const commonConfig = `{\n${commonLines.join('\n')}\n  }`
+    const variantsConfig =
+      `Record<string, {\n` +
+      `      shape: ${m}${c}ShapeOrFn<TCtx>\n` +
+      `      before?: ${beforeRef}[]\n` +
+      `      after?: ${afterRef}[]\n` +
+      `    }>`
+
+    return (
+      `  ${routerOp}?: (${commonConfig} & (\n` +
+      `    | { shape?: ${m}${c}ShapeInput<TCtx>; variants?: never }\n` +
+      `    | { shape?: never; variants: ${variantsConfig} }\n` +
+      `  )) | false`
+    )
   }).join('\n')
 
   const omitKeys = ROUTER_OPERATIONS.map((k) => `'${k}'`).join('\n  | ')
@@ -100,6 +130,7 @@ export function generateRouteConfigType(
   return (
     progressiveTypeImport +
     `import type {\n  ${opShapeImports}\n} from '${guardShapesImport}${ext}'\n\n` +
+    `${shapeOrFnAliases}\n\n` +
     `export type ${m}RouteConfig${generics} = Omit<\n` +
     `  ${baseConfig},\n` +
     `  | ${omitKeys}\n` +