[pull] main from prisma:main

packages/client-engine-runtime/package.json

@@ -39,17 +39,14 @@
   "devDependencies": {
     "@codspeed/benchmark.js-plugin": "4.0.0",
     "@types/benchmark": "2.1.5",
-    "@types/jest": "29.5.14",
     "@types/node": "~20.19.24",
-    "benchmark": "2.1.4",
-    "jest": "29.7.0",
-    "jest-junit": "16.0.0"
+    "benchmark": "2.1.4"
   },
   "scripts": {
     "dev": "DEV=true tsx helpers/build.ts",
     "build": "tsx helpers/build.ts",
     "prepublishOnly": "pnpm run build",
-    "test": "jest"
+    "test": "vitest run"
   },
   "files": [
     "dist"

packages/client-engine-runtime/src/interpreter/generators.test.ts

@@ -1,3 +1,5 @@
+import { expect, test } from 'vitest'
+
 import { GeneratorRegistry } from './generators'
 
 test('should always return the same time for a single snapshot', async () => {

packages/client-engine-runtime/src/interpreter/render-query.test.ts

@@ -1,3 +1,5 @@
+import { expect, test } from 'vitest'
+
 import type { PlaceholderFormat, QueryPlanDbQuery } from '../query-plan'
 import { GeneratorRegistry } from './generators'
 import { renderQuery } from './render-query'

packages/client-engine-runtime/src/interpreter/serialize-sql.test.ts

@@ -1,4 +1,5 @@
 import { ColumnTypeEnum } from '@prisma/driver-adapter-utils'
+import { expect, test } from 'vitest'
 
 import { serializeSql } from './serialize-sql'
 

packages/client-engine-runtime/src/json-protocol.test.ts

@@ -1,4 +1,5 @@
 import { Decimal } from '@prisma/client-runtime-utils'
+import { describe, expect, test } from 'vitest'
 
 import { deserializeJsonObject } from './json-protocol'
 

packages/client-engine-runtime/src/sql-commenter.test.ts

@@ -1,4 +1,5 @@
 import type { SqlCommenterContext, SqlCommenterPlugin } from '@prisma/sqlcommenter'
+import { describe, expect, test, vi } from 'vitest'
 
 import { appendSqlComment, applySqlCommenters, buildSqlComment, formatSqlComment } from './sql-commenter'
 
@@ -90,7 +91,7 @@ describe('applySqlCommenters', () => {
   })
 
   test('calls plugin with context', () => {
-    const plugin = jest.fn(() => ({ key: 'value' }))
+    const plugin = vi.fn(() => ({ key: 'value' }))
     applySqlCommenters([plugin], mockSingleContext)
     expect(plugin).toHaveBeenCalledWith(mockSingleContext)
   })

packages/client-engine-runtime/src/transaction-manager/transaction-manager.test.ts

@@ -1,6 +1,7 @@
 import timers from 'node:timers/promises'
 
 import type { SqlDriverAdapter, SqlQuery, SqlResultSet, Transaction } from '@prisma/driver-adapter-utils'
+import { expect, test, vi } from 'vitest'
 
 import { noopTracingHelper } from '../tracing'
 import { Options } from './transaction'
@@ -15,7 +16,7 @@ import {
   TransactionStartTimeoutError,
 } from './transaction-manager-error'
 
-jest.useFakeTimers()
+vi.useFakeTimers()
 
 const START_TRANSACTION_TIME = 200
 const TRANSACTION_EXECUTION_TIMEOUT = 500
@@ -34,9 +35,9 @@ class MockDriverAdapter implements SqlDriverAdapter {
   private readonly rollbackToSavepoint: Transaction['rollbackToSavepoint']
   private readonly releaseSavepoint: Transaction['releaseSavepoint']
 
-  executeRawMock: jest.MockedFn<(params: SqlQuery) => Promise<number>> = jest.fn().mockResolvedValue(1)
-  commitMock: jest.MockedFn<() => Promise<void>> = jest.fn().mockResolvedValue(undefined)
-  rollbackMock: jest.MockedFn<() => Promise<void>> = jest.fn().mockResolvedValue(undefined)
+  executeRawMock = vi.fn().mockResolvedValue(1)
+  commitMock = vi.fn().mockResolvedValue(undefined)
+  rollbackMock = vi.fn().mockResolvedValue(undefined)
 
   constructor(
     options: {
@@ -104,7 +105,7 @@ class MockDriverAdapter implements SqlDriverAdapter {
       adapterName: 'mock-adapter',
       provider,
       options: { usePhantomQuery },
-      queryRaw: jest.fn().mockRejectedValue('Not implemented for test'),
+      queryRaw: vi.fn().mockRejectedValue('Not implemented for test'),
       executeRaw: executeRawMock,
       commit: commitMock,
       rollback: rollbackMock,
@@ -128,7 +129,7 @@ async function startTransaction(transactionManager: TransactionManager, options:
       maxWait: START_TRANSACTION_TIME * 2,
       ...options,
     }),
-    jest.advanceTimersByTimeAsync(START_TRANSACTION_TIME + 100),
+    vi.advanceTimersByTimeAsync(START_TRANSACTION_TIME + 100),
   ])
   return id
 }
@@ -343,11 +344,9 @@ test('nested savepoints use sqlite syntax', async () => {
 })
 
 test('nested savepoints use adapter-provided methods when available', async () => {
-  const createSavepoint = jest.fn<ReturnType<NonNullable<Transaction['createSavepoint']>>, [string]>(async () => {})
-  const rollbackToSavepoint = jest.fn<ReturnType<NonNullable<Transaction['rollbackToSavepoint']>>, [string]>(
-    async () => {},
-  )
-  const releaseSavepoint = jest.fn<ReturnType<NonNullable<Transaction['releaseSavepoint']>>, [string]>(async () => {})
+  const createSavepoint = vi.fn(async (_name: string) => {})
+  const rollbackToSavepoint = vi.fn(async (_name: string) => {})
+  const releaseSavepoint = vi.fn(async (_name: string) => {})
 
   const driverAdapter = new MockDriverAdapter({
     provider: 'postgres',
@@ -377,7 +376,7 @@ test('nested savepoints use adapter-provided methods when available', async () =
 })
 
 test('nested savepoint release can be omitted by adapter', async () => {
-  const createSavepoint = jest.fn<ReturnType<NonNullable<Transaction['createSavepoint']>>, [string]>(async () => {})
+  const createSavepoint = vi.fn(async () => {})
 
   const driverAdapter = new MockDriverAdapter({
     provider: 'postgres',
@@ -474,7 +473,7 @@ test('commitTransaction during a rollback caused by a time out raises a Transact
   const timeout = 200
   const rollbackDelay = 200
 
-  driverAdapter.rollbackMock = jest.fn().mockImplementation(() => timers.setTimeout(rollbackDelay))
+  driverAdapter.rollbackMock = vi.fn().mockImplementation(() => timers.setTimeout(rollbackDelay))
 
   const transactionManager = new TransactionManager({
     driverAdapter,
@@ -483,11 +482,11 @@ test('commitTransaction during a rollback caused by a time out raises a Transact
   })
 
   const txPromise = transactionManager.startTransaction()
-  await jest.advanceTimersByTimeAsync(START_TRANSACTION_TIME + timeout)
+  await vi.advanceTimersByTimeAsync(START_TRANSACTION_TIME + timeout)
   const tx = await txPromise
   const commitPromise = transactionManager.commitTransaction(tx.id)
 
-  await expect(Promise.all([jest.advanceTimersByTimeAsync(rollbackDelay), commitPromise])).rejects.toEqual(
+  await expect(Promise.all([vi.advanceTimersByTimeAsync(rollbackDelay), commitPromise])).rejects.toEqual(
     new TransactionExecutionTimeoutError('commit', {
       timeout,
       timeTaken: START_TRANSACTION_TIME + timeout + rollbackDelay,
@@ -594,7 +593,7 @@ test('transaction times out during starting', async () => {
   expect(driverAdapter.rollbackMock).not.toHaveBeenCalled()
 
   // Now let the startTransaction promise resolve
-  await jest.advanceTimersByTimeAsync(START_TRANSACTION_TIME)
+  await vi.advanceTimersByTimeAsync(START_TRANSACTION_TIME)
 
   // The transaction that was started in the background should now be rolled back
   // to release the connection back to the pool.
@@ -610,16 +609,16 @@ test('transaction start timeout cleans up connection if transaction eventually s
   const TIME_PAST_MAX_WAIT = MAX_WAIT + 50
   const REMAINING_TIME_FOR_START = SLOW_START_TRANSACTION_TIME - TIME_PAST_MAX_WAIT
 
-  const rollbackMock = jest.fn().mockResolvedValue(undefined)
+  const rollbackMock = vi.fn().mockResolvedValue(undefined)
 
   const driverAdapter = {
     adapterName: 'slow-adapter',
     provider: 'postgres' as const,
-    executeRaw: jest.fn().mockResolvedValue(1),
-    queryRaw: jest.fn(),
-    executeScript: jest.fn(),
-    dispose: jest.fn(),
-    startTransaction: jest.fn().mockImplementation(
+    executeRaw: vi.fn().mockResolvedValue(1),
+    queryRaw: vi.fn(),
+    executeScript: vi.fn(),
+    dispose: vi.fn(),
+    startTransaction: vi.fn().mockImplementation(
       () =>
         new Promise((resolve) =>
           setTimeout(
@@ -628,9 +627,9 @@ test('transaction start timeout cleans up connection if transaction eventually s
                 adapterName: 'slow-adapter',
                 provider: 'postgres',
                 options: { usePhantomQuery: false },
-                queryRaw: jest.fn(),
-                executeRaw: jest.fn(),
-                commit: jest.fn(),
+                queryRaw: vi.fn(),
+                executeRaw: vi.fn(),
+                commit: vi.fn(),
                 rollback: rollbackMock,
               }),
             SLOW_START_TRANSACTION_TIME,
@@ -648,7 +647,7 @@ test('transaction start timeout cleans up connection if transaction eventually s
   // Start a transaction with a maxWait shorter than the actual connection time
   // Use Promise.all to advance timers and wait for the rejection simultaneously
   const [, txResult] = await Promise.all([
-    jest.advanceTimersByTimeAsync(TIME_PAST_MAX_WAIT),
+    vi.advanceTimersByTimeAsync(TIME_PAST_MAX_WAIT),
     transactionManager.startTransaction().catch((e) => e),
   ])
 
@@ -659,7 +658,7 @@ test('transaction start timeout cleans up connection if transaction eventually s
   expect(rollbackMock).not.toHaveBeenCalled()
 
   // Now advance time to let the startTransaction promise resolve
-  await jest.advanceTimersByTimeAsync(REMAINING_TIME_FOR_START)
+  await vi.advanceTimersByTimeAsync(REMAINING_TIME_FOR_START)
 
   // After the background startTransaction completes, rollback should be called
   // to release the connection and avoid pool exhaustion
@@ -676,7 +675,7 @@ test('transaction times out during execution', async () => {
 
   const id = await startTransaction(transactionManager)
 
-  await jest.advanceTimersByTimeAsync(TRANSACTION_EXECUTION_TIMEOUT + 100)
+  await vi.advanceTimersByTimeAsync(TRANSACTION_EXECUTION_TIMEOUT + 100)
 
   await expect(transactionManager.commitTransaction(id)).rejects.toBeInstanceOf(TransactionExecutionTimeoutError)
   await expect(transactionManager.rollbackTransaction(id)).rejects.toBeInstanceOf(TransactionExecutionTimeoutError)
@@ -692,7 +691,7 @@ test('internal transaction does not apply the default start timeout', async () =
 
   const [tx] = await Promise.all([
     transactionManager.startInternalTransaction(),
-    jest.advanceTimersByTimeAsync(START_TRANSACTION_TIME),
+    vi.advanceTimersByTimeAsync(START_TRANSACTION_TIME),
   ])
   await transactionManager.commitTransaction(tx.id)
 
@@ -710,9 +709,9 @@ test('internal transaction does not apply the default execution timeout', async
 
   const [tx] = await Promise.all([
     transactionManager.startInternalTransaction(),
-    jest.advanceTimersByTimeAsync(START_TRANSACTION_TIME),
+    vi.advanceTimersByTimeAsync(START_TRANSACTION_TIME),
   ])
-  await jest.advanceTimersByTimeAsync(TRANSACTION_EXECUTION_TIMEOUT)
+  await vi.advanceTimersByTimeAsync(TRANSACTION_EXECUTION_TIMEOUT)
   await transactionManager.commitTransaction(tx.id)
 
   expect(driverAdapter.commitMock).toHaveBeenCalled()
@@ -745,7 +744,7 @@ test('TransactionManagerErrors have common structure', () => {
 
 test('startTransaction works when setTimeout returns a timer without unref (workerd environment)', async () => {
   const originalSetTimeout = global.setTimeout
-  const setTimeoutSpy = jest
+  const setTimeoutSpy = vi
     .spyOn(global, 'setTimeout')
     .mockImplementation((callback: (...args: any[]) => void, ms?: number, ...args: any[]) => {
       const timer = originalSetTimeout(callback, ms, ...args)