prisma-generator-express 1.40.0 → 1.41.0

package/dist/generators/generateOperationCore.js

@@ -2,8 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateOperationRuntime = generateOperationRuntime;
 exports.generateModelCore = generateModelCore;
-function generateOperationRuntime() {
-    return `import { sanitizeKeys } from './misc'
+const importExt_1 = require("../utils/importExt");
+function generateOperationRuntime(importStyle) {
+    const ext = (0, importExt_1.importExt)(importStyle);
+    return `import { sanitizeKeys } from './misc${ext}'
+import type {
+  ProgressivePatch,
+  ProgressiveStopResult,
+  ProgressiveStageResult,
+  ProgressiveStageContext,
+  ProgressiveStage,
+} from './routeConfig${ext}'
+
+export type {
+  ProgressivePatch,
+  ProgressiveStopResult,
+  ProgressiveStageResult,
+  ProgressiveStageContext,
+  ProgressiveStage,
+}
 
 export interface PaginationConfig {
   defaultLimit?: number
@@ -69,88 +86,41 @@ const PRISMA_ERROR_MAP: Record<string, { status: number; message: string }> = {
 
 export function mapError(error: unknown): HttpError {
   if (error instanceof HttpError) return error
-
-  if (
-    error &&
-    typeof error === 'object' &&
-    'name' in error &&
-    error.name === 'ShapeError'
-  ) {
+  if (error && typeof error === 'object' && 'name' in error && (error as any).name === 'ShapeError') {
     return new HttpError(400, (error as any).message)
   }
-
-  if (
-    error &&
-    typeof error === 'object' &&
-    'name' in error &&
-    error.name === 'CallerError'
-  ) {
+  if (error && typeof error === 'object' && 'name' in error && (error as any).name === 'CallerError') {
     return new HttpError(400, (error as any).message)
   }
-
-  if (
-    error &&
-    typeof error === 'object' &&
-    'name' in error &&
-    error.name === 'PolicyError'
-  ) {
+  if (error && typeof error === 'object' && 'name' in error && (error as any).name === 'PolicyError') {
     return new HttpError(403, (error as any).message)
   }
-
-  if (
-    error &&
-    typeof error === 'object' &&
-    'issues' in error &&
-    'name' in error &&
-    (error as any).name === 'ZodError'
-  ) {
+  if (error && typeof error === 'object' && 'issues' in error && 'name' in error && (error as any).name === 'ZodError') {
     const issues = (error as any).issues
-    const message = Array.isArray(issues)
-      ? issues.map((i: any) => i.message).join('; ')
-      : (error as any).message
+    const message = Array.isArray(issues) ? issues.map((i: any) => i.message).join('; ') : (error as any).message
     return new HttpError(400, message)
   }
-
   if (error && typeof error === 'object' && 'code' in error) {
     const code = (error as any).code as string
     const mapped = PRISMA_ERROR_MAP[code]
     if (mapped) {
       const detail = (error as any).message
-      const message = detail
-        ? mapped.message + ': ' + detail
-        : mapped.message
-      return new HttpError(mapped.status, message)
+      return new HttpError(mapped.status, detail ? mapped.message + ': ' + detail : mapped.message)
     }
     if (typeof code === 'string' && code.startsWith('P')) {
       const msg = (error as any).message || 'Database operation failed'
-      console.warn(
-        '[prisma-generator-express] Unmapped Prisma error code:',
-        code,
-        msg,
-      )
+      console.warn('[prisma-generator-express] Unmapped Prisma error code:', code, msg)
       return new HttpError(500, msg)
     }
   }
-
   if (error && typeof error === 'object' && 'name' in error) {
     const name = (error as any).name
-    if (name === 'PrismaClientValidationError') {
-      return new HttpError(400, (error as any).message || 'Invalid query parameters')
-    }
-    if (name === 'PrismaClientKnownRequestError') {
-      return new HttpError(400, (error as any).message || 'Database request error')
-    }
-    if (name === 'PrismaClientInitializationError') {
-      return new HttpError(503, (error as any).message || 'Database connection failed')
-    }
-    if (name === 'PrismaClientRustPanicError') {
-      return new HttpError(500, (error as any).message || 'Internal database engine error')
-    }
-    if (name === 'PrismaClientUnknownRequestError') {
-      return new HttpError(500, (error as any).message || 'Unknown database error')
-    }
+    if (name === 'PrismaClientValidationError') return new HttpError(400, (error as any).message || 'Invalid query parameters')
+    if (name === 'PrismaClientKnownRequestError') return new HttpError(400, (error as any).message || 'Database request error')
+    if (name === 'PrismaClientInitializationError') return new HttpError(503, (error as any).message || 'Database connection failed')
+    if (name === 'PrismaClientRustPanicError') return new HttpError(500, (error as any).message || 'Internal database engine error')
+    if (name === 'PrismaClientUnknownRequestError') return new HttpError(500, (error as any).message || 'Unknown database error')
   }
-
   const msg = error instanceof Error ? error.message : String(error)
   console.error('[prisma-generator-express] Unhandled error:', error)
   return new HttpError(500, msg || 'Internal server error')
@@ -178,14 +148,10 @@ export async function getExtendedClient(ctx: OperationContext): Promise<any> {
   if (!base) {
     throw new HttpError(500, 'PrismaClient not found on request. Set req.prisma in middleware.')
   }
-
   await _prismasqlReady
-
   if (!_speedExtension) return base
-
   const connector = ctx.postgres || ctx.sqlite
   if (!connector) return base
-
   if (typeof connector === 'object' && connector !== null) {
     const innerMap = _extendedClients.get(connector)
     if (innerMap) {
@@ -193,14 +159,12 @@ export async function getExtendedClient(ctx: OperationContext): Promise<any> {
       if (cached) return cached
     }
   }
-
   try {
     const extended = base.$extends(_speedExtension({
       postgres: ctx.postgres,
       sqlite: ctx.sqlite,
       debug: process.env.DEBUG === 'true',
     }))
-
     if (typeof connector === 'object' && connector !== null) {
       let innerMap = _extendedClients.get(connector)
       if (!innerMap) {
@@ -209,7 +173,6 @@ export async function getExtendedClient(ctx: OperationContext): Promise<any> {
       }
       innerMap.set(base, extended)
     }
-
     return extended
   } catch (error) {
     console.warn('[speedExtension] Failed to initialize, using base client:', error)
@@ -230,25 +193,18 @@ export function requireBodyField(body: Record<string, any>, field: string): void
   }
 }
 
-export function applyPaginationLimits(
-  query: Record<string, any>,
-  config?: PaginationConfig,
-): Record<string, any> {
+export function applyPaginationLimits(query: Record<string, any>, config?: PaginationConfig): Record<string, any> {
   if (!config) return query
-
   const result = { ...query }
-
   if (result.take === undefined && config.defaultLimit !== undefined) {
     result.take = config.defaultLimit
   }
-
   if (config.maxLimit !== undefined && result.take !== undefined) {
     const takeNum = Number(result.take)
     if (Math.abs(takeNum) > config.maxLimit) {
       result.take = takeNum < 0 ? -config.maxLimit : config.maxLimit
     }
   }
-
   return result
 }
 
@@ -260,10 +216,7 @@ export function normalizeDistinct(value: unknown): string[] {
 
 export function assertGuard(delegate: any): void {
   if (typeof delegate.guard !== 'function') {
-    throw new HttpError(
-      500,
-      'Guard shapes require prisma-guard extension on PrismaClient. Install: npm install prisma-guard, then extend your client with guardExtension().',
-    )
+    throw new HttpError(500, 'Guard shapes require prisma-guard extension on PrismaClient.')
   }
 }
 
@@ -283,14 +236,9 @@ export function buildCountShape(shape: Record<string, any>): Record<string, any>
   if (typeof shape === 'function') {
     return (...args: any[]) => keepWhereOnly((shape as Function)(...args))
   }
-
   const keys = Object.keys(shape)
   const isSingleShape = keys.length === 0 || keys.every((k) => GUARD_SHAPE_CONFIG_KEYS.has(k))
-
-  if (isSingleShape) {
-    return keepWhereOnly(shape)
-  }
-
+  if (isSingleShape) return keepWhereOnly(shape)
   const result: Record<string, any> = {}
   for (const [key, variant] of Object.entries(shape)) {
     if (typeof variant === 'function') {
@@ -314,7 +262,6 @@ export async function countForPagination(
   const distinctFields = normalizeDistinct(query.distinct)
   const hasDistinct = distinctFields.length > 0
   const effectiveLimit = distinctCountLimit ?? DISTINCT_COUNT_LIMIT
-
   const countShape = shape ? buildCountShape(shape) : undefined
 
   if (hasDistinct) {
@@ -325,30 +272,22 @@ export async function countForPagination(
       select: { [selectField]: true },
       take: effectiveLimit + 1,
     }
-
     const results = shape
       ? await delegate.guard(shape, caller).findMany(distinctArgs)
       : await delegate.findMany(distinctArgs)
-
     if (results.length > effectiveLimit) {
-      console.warn(
-        '[prisma-generator-express] Distinct count exceeds ' +
-          effectiveLimit +
-          ', falling back to approximate total',
-      )
+      console.warn('[prisma-generator-express] Distinct count exceeds ' + effectiveLimit + ', falling back to approximate total')
       const countArgs: Record<string, any> = {}
       if (query.where) countArgs.where = query.where
       return countShape
         ? await delegate.guard(countShape, caller).count(countArgs)
         : await delegate.count(countArgs)
     }
-
     return results.length
   }
 
   const countArgs: Record<string, any> = {}
   if (query.where) countArgs.where = query.where
-
   return countShape
     ? await delegate.guard(countShape, caller).count(countArgs)
     : await delegate.count(countArgs)
@@ -357,12 +296,8 @@ export async function countForPagination(
 export function transformResult(value: unknown): unknown {
   if (value === null || value === undefined) return value
   if (typeof value === 'bigint') return value.toString()
-  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
-    return value.toString('base64')
-  }
-  if (value instanceof Uint8Array) {
-    return Buffer.from(value).toString('base64')
-  }
+  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) return value.toString('base64')
+  if (value instanceof Uint8Array) return Buffer.from(value).toString('base64')
   if (value instanceof Date) return value
   if (Array.isArray(value)) return value.map(transformResult)
   if (typeof value === 'object') {
@@ -376,19 +311,227 @@ export function transformResult(value: unknown): unknown {
   }
   return value
 }
+
+export function acceptsEventStream(accept: string | undefined): boolean {
+  if (!accept) return false
+  return accept.toLowerCase().includes('text/event-stream')
+}
+
+const UNSAFE_PATH_SEGMENTS = new Set(['__proto__', 'constructor', 'prototype'])
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object') return false
+  if (Array.isArray(value)) return false
+  const proto = Object.getPrototypeOf(value)
+  return proto === Object.prototype || proto === null
+}
+
+export function setByPath(target: Record<string, unknown>, path: string, value: unknown): boolean {
+  const parts = path.split('.')
+  if (parts.length === 0) return false
+  for (const p of parts) {
+    if (p === '' || UNSAFE_PATH_SEGMENTS.has(p)) return false
+  }
+  let cursor: Record<string, unknown> = target
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i]
+    const next = cursor[part]
+    if (!isPlainObject(next)) {
+      if (process.env.NODE_ENV !== 'production') {
+        console.warn(
+          '[progressive] Dropping patch for "' + path +
+          '": cannot traverse non-plain-object at segment "' + part + '"',
+        )
+      }
+      return false
+    }
+    cursor = next
+  }
+  cursor[parts[parts.length - 1]] = value
+  return true
+}
+
+function removeReqCloseListener(req: any, listener: () => void): void {
+  if (typeof req.off === 'function') {
+    req.off('close', listener)
+  } else if (typeof req.removeListener === 'function') {
+    req.removeListener('close', listener)
+  }
+}
+
+export function initSSE(res: any): void {
+  res.statusCode = 200
+  res.setHeader('Content-Type', 'text/event-stream')
+  res.setHeader('Cache-Control', 'no-cache, no-transform')
+  res.setHeader('Connection', 'keep-alive')
+  res.setHeader('X-Accel-Buffering', 'no')
+  if (typeof res.flushHeaders === 'function') res.flushHeaders()
+}
+
+export function flushSSE(res: any): void {
+  if (typeof res.flush === 'function') {
+    try { res.flush() } catch {}
+  }
+}
+
+export function sendSSE(res: any, payload: unknown): boolean {
+  if (res.writableEnded || res.destroyed) return false
+  try {
+    res.write('data: ' + JSON.stringify(transformResult(payload)) + '\\n\\n')
+    flushSSE(res)
+    return true
+  } catch (err) {
+    console.error('[progressive] failed to send SSE event:', err)
+    return false
+  }
+}
+
+export function sendSSEProgress(res: any, stage: string, completed: number, total: number): boolean {
+  return sendSSE(res, { type: 'progress', stage, completed, total })
+}
+
+export function sendSSEField(res: any, key: string, value: unknown): boolean {
+  return sendSSE(res, { type: 'field', key, value })
+}
+
+export function sendSSEResult(res: any, data: unknown): boolean {
+  return sendSSE(res, { type: 'result', data })
+}
+
+export function sendSSEError(res: any, message: string): boolean {
+  if (res.writableEnded || res.destroyed) return false
+  try {
+    res.write('data: ' + JSON.stringify({ type: 'error', message }) + '\\n\\n')
+    flushSSE(res)
+    return true
+  } catch (err) {
+    console.error('[progressive] failed to send SSE error event:', err)
+    return false
+  }
+}
+
+export function startSSEKeepalive(res: any, intervalMs: number = 15000): any {
+  const handle = setInterval(() => {
+    if (res.writableEnded || res.destroyed) return
+    try {
+      res.write(': keepalive\\n\\n')
+      flushSSE(res)
+    } catch {}
+  }, intervalMs)
+  if (typeof (handle as any).unref === 'function') (handle as any).unref()
+  return handle
+}
+
+export function endSSE(res: any, keepaliveHandle: any): void {
+  if (keepaliveHandle) {
+    try { clearInterval(keepaliveHandle) } catch {}
+  }
+  if (!res.writableEnded && !res.destroyed) {
+    try { res.end() } catch {}
+  }
+}
+
+export interface RunSingleResultSSEOptions {
+  req: any
+  res: any
+  coreQueryFn: () => Promise<unknown>
+}
+
+export async function runSingleResultSSE(options: RunSingleResultSSEOptions): Promise<void> {
+  const { req, res, coreQueryFn } = options
+  let keepalive: any = null
+  try {
+    initSSE(res)
+    keepalive = startSSEKeepalive(res)
+    if (req.destroyed) return
+    const data = await coreQueryFn()
+    if (res.writableEnded || res.destroyed) return
+    sendSSEResult(res, data)
+  } catch (err) {
+    console.error('[progressive] single-result error:', err)
+    if (!res.writableEnded && !res.destroyed) {
+      sendSSEError(res, 'Internal server error')
+    }
+  } finally {
+    endSSE(res, keepalive)
+  }
+}
+
+function isStopResult(value: unknown): value is ProgressiveStopResult<unknown> {
+  return typeof value === 'object' && value !== null && (value as any).stop === true
+}
+
+export interface RunProgressiveOptions {
+  req: any
+  res: any
+  ctx: unknown
+  prisma: any
+  variant: string
+  stages: string[]
+  stageRegistry: Record<string, ProgressiveStage<any, any>>
+}
+
+export async function runProgressiveEndpoint(options: RunProgressiveOptions): Promise<void> {
+  const { req, res, ctx, prisma, variant, stages, stageRegistry } = options
+  let keepalive: any = null
+  const controller = new AbortController()
+  const onClose = () => controller.abort()
+  if (typeof req.on === 'function') req.on('close', onClose)
+
+  const accumulated: Record<string, unknown> = {}
+  const signal = controller.signal
+
+  try {
+    initSSE(res)
+    keepalive = startSSEKeepalive(res)
+    sendSSEProgress(res, 'start', 0, stages.length)
+
+    for (let i = 0; i < stages.length; i++) {
+      if (res.writableEnded || res.destroyed || signal.aborted) return
+      const stageName = stages[i]
+      const stage = stageRegistry[stageName]
+      if (!stage) throw new Error('Missing progressive stage: ' + stageName)
+
+      const result = await stage({ ctx, req, res, prisma, variant, accumulated, signal })
+      if (res.writableEnded || res.destroyed) return
+
+      if (isStopResult(result)) {
+        sendSSEResult(res, result.data)
+        return
+      }
+
+      const patches = Array.isArray(result) ? result : result ? [result] : []
+      for (const patch of patches) {
+        if (!patch || typeof patch !== 'object') continue
+        if (typeof (patch as any).key !== 'string') continue
+        if (!('value' in patch)) continue
+        const p = patch as ProgressivePatch
+        const applied = setByPath(accumulated, p.key, p.value)
+        if (applied) sendSSEField(res, p.key, p.value)
+      }
+      sendSSEProgress(res, stageName, i + 1, stages.length)
+    }
+    if (res.writableEnded || res.destroyed) return
+    sendSSEResult(res, accumulated)
+  } catch (err) {
+    console.error('[progressive] stage error:', err)
+    if (!res.writableEnded && !res.destroyed) {
+      sendSSEError(res, 'Could not load progressive response')
+    }
+  } finally {
+    removeReqCloseListener(req, onClose)
+    endSSE(res, keepalive)
+  }
+}
 `;
 }
 function generateModelCore(options) {
+    const ext = (0, importExt_1.importExt)(options.importStyle);
     const modelName = options.model.name;
     const modelNameLower = modelName.charAt(0).toLowerCase() + modelName.slice(1);
     const standardReadOps = [
-        'findFirst',
-        'findUnique',
-        'findUniqueOrThrow',
-        'findFirstOrThrow',
-        'count',
-        'aggregate',
-        'groupBy',
+        'findFirst', 'findUnique', 'findUniqueOrThrow', 'findFirstOrThrow',
+        'count', 'aggregate', 'groupBy',
     ];
     const standardReadHandlers = standardReadOps
         .map((op) => `
@@ -405,43 +548,16 @@ export async function ${op}(ctx: OperationContext): Promise<unknown> {
     const writeOps = [
         { name: 'create', method: 'create', requiredFields: ['data'] },
         { name: 'createMany', method: 'createMany', requiredFields: ['data'] },
-        {
-            name: 'createManyAndReturn',
-            method: 'createManyAndReturn',
-            requiredFields: ['data'],
-        },
-        {
-            name: 'update',
-            method: 'update',
-            requiredFields: ['where', 'data'],
-        },
-        {
-            name: 'updateMany',
-            method: 'updateMany',
-            requiredFields: ['where', 'data'],
-        },
-        {
-            name: 'updateManyAndReturn',
-            method: 'updateManyAndReturn',
-            requiredFields: ['where', 'data'],
-        },
+        { name: 'createManyAndReturn', method: 'createManyAndReturn', requiredFields: ['data'] },
+        { name: 'update', method: 'update', requiredFields: ['where', 'data'] },
+        { name: 'updateMany', method: 'updateMany', requiredFields: ['where', 'data'] },
+        { name: 'updateManyAndReturn', method: 'updateManyAndReturn', requiredFields: ['where', 'data'] },
         { name: 'deleteUnique', method: 'delete', requiredFields: ['where'] },
-        {
-            name: 'deleteMany',
-            method: 'deleteMany',
-            requiredFields: ['where'],
-        },
-        {
-            name: 'upsert',
-            method: 'upsert',
-            requiredFields: ['where', 'create', 'update'],
-        },
+        { name: 'deleteMany', method: 'deleteMany', requiredFields: ['where'] },
+        { name: 'upsert', method: 'upsert', requiredFields: ['where', 'create', 'update'] },
     ];
-    const writeHandlers = writeOps
-        .map((op) => {
-        const validationLines = op.requiredFields
-            .map((field) => `  requireBodyField(body, '${field}')`)
-            .join('\n');
+    const writeHandlers = writeOps.map((op) => {
+        const validationLines = op.requiredFields.map((field) => `  requireBodyField(body, '${field}')`).join('\n');
         return `
 export async function ${op.name}(ctx: OperationContext): Promise<unknown> {
   const body = validateBody(ctx.body)
@@ -453,8 +569,7 @@ ${validationLines}
   }
   return (extended as any).${modelNameLower}.${op.method}(body)
 }`;
-    })
-        .join('\n');
+    }).join('\n');
     return `import {
   OperationContext,
   getExtendedClient,
@@ -463,7 +578,7 @@ ${validationLines}
   applyPaginationLimits,
   assertGuard,
   countForPagination,
-} from '../operationRuntime'
+} from '../operationRuntime${ext}'
 
 export async function findMany(ctx: OperationContext): Promise<unknown> {
   const rawQuery = ctx.parsedQuery || {}
@@ -489,18 +604,14 @@ export async function findManyPaginated(
   const distinctCountLimit = ctx.paginationConfig?.distinctCountLimit
   const delegate = (extended as any).${modelNameLower}
 
-  if (shape) {
-    assertGuard(delegate)
-  }
+  if (shape) assertGuard(delegate)
 
   let items: any[]
   let total: number
 
   if (shape || typeof extended.$transaction !== 'function') {
     const [data, count] = await Promise.all([
-      shape
-        ? delegate.guard(shape, caller).findMany(query)
-        : delegate.findMany(query),
+      shape ? delegate.guard(shape, caller).findMany(query) : delegate.findMany(query),
       countForPagination(delegate, query, shape, caller, distinctCountLimit),
     ])
     items = data
@@ -515,13 +626,8 @@ export async function findManyPaginated(
       items = txResult.d
       total = txResult.t
     } catch (txError: any) {
-      if (
-        txError?.message?.includes?.('interactive transactions') ||
-        txError?.code === 'P2028'
-      ) {
-        console.warn(
-          '[prisma-generator-express] Interactive transactions not available, pagination queries are non-atomic',
-        )
+      if (txError?.message?.includes?.('interactive transactions') || txError?.code === 'P2028') {
+        console.warn('[prisma-generator-express] Interactive transactions not available, pagination queries are non-atomic')
         items = await delegate.findMany(query)
         total = await countForPagination(delegate, query, undefined, undefined, distinctCountLimit)
       } else {

package/dist/generators/generateOperationCore.js.map

@@ -1 +1 @@
-{"version":3,"file":"generateOperationCore.js","sourceRoot":"","sources":["../../src/generators/generateOperationCore.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"generateOperationCore.js","sourceRoot":"","sources":["../../src/generators/generateOperationCore.ts"],"names":[],"mappings":"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"}

package/dist/generators/generateRouteConfigType.d.ts

@@ -1 +1,3 @@
-export declare function generateRouteConfigType(modelName: string, hookHandlerType: string, guardShapesImport: string | null): string;
+import { ImportStyle } from '../utils/resolveImportStyle';
+import type { Target } from '../constants';
+export declare function generateRouteConfigType(modelName: string, hookHandlerType: string, guardShapesImport: string | null, importStyle: ImportStyle, target: Target): string;