refactor(engine-core): organize

src/packages/client/src/__tests__/binaryEngine.test.ts

@@ -1,9 +1,8 @@
-import { BinaryEngine } from '@prisma/engine-core/dist/BinaryEngine'
+import { BinaryEngine } from '@prisma/engine-core'
 import path from 'path'
 
 describe('BinaryEngine', () => {
   test('should error correctly with invalid flags', async () => {
-
     // Skip for Node-API library
     // TODO Better scoping when to run this test so this conditional is not necessary
     if (process.env.PRISMA_FORCE_NAPI === 'true') {

src/packages/client/src/__tests__/integration/happy/long-running-transaction/test.ts

@@ -12,14 +12,14 @@ test('long-running transaction', async () => {
         email: 'test@hey.com',
       },
     }),
-    (new Promise((res) => setTimeout(res, 1000))) as any,
+    new Promise((res) => setTimeout(res, 1000)) as any,
     prisma.user.create({
       data: {
         email: 'test@hey.com',
       },
-    })
+    }),
   ])
- 
+
   console.log(result)
 
   await prisma.$disconnect()

src/packages/client/src/__tests__/integration/happy/restart/test.ts

@@ -3,7 +3,7 @@ import { getTestClient } from '../../../../utils/getTestClient'
 // Does Prisma Client restart the QE when it is killed for some reason?
 test('restart', async () => {
   // No child process for Node-API, so nothing that can be killed or tested
-  if(process.env.PRISMA_FORCE_NAPI === 'true') {
+  if (process.env.PRISMA_FORCE_NAPI === 'true') {
     return
   }
 
@@ -25,7 +25,7 @@ test('restart', async () => {
     db._engine.child.kill()
     await new Promise((r) => setTimeout(r, 200))
   }
-  
+
   const result2 = await db.user.findMany()
   expect(result2).toMatchInlineSnapshot(`
     Array [

src/packages/client/src/runtime/getPrismaClient.ts

@@ -4,9 +4,9 @@ import {
   Engine,
   EngineConfig,
   EngineEventType,
-} from '@prisma/engine-core/dist/Engine'
-import { LibraryEngine } from '@prisma/engine-core/dist/LibraryEngine'
-import { BinaryEngine } from '@prisma/engine-core/dist/BinaryEngine'
+} from '@prisma/engine-core'
+import { LibraryEngine } from '@prisma/engine-core'
+import { BinaryEngine } from '@prisma/engine-core'
 import {
   DataSource,
   GeneratorConfig,

src/packages/engine-core/src/BinaryEngine.ts → src/packages/engine-core/src/binary/BinaryEngine.ts

@@ -13,40 +13,38 @@ import path from 'path'
 import { Readable } from 'stream'
 import { URL } from 'url'
 import { promisify } from 'util'
-import byline from './byline'
+import byline from '../tools/byline'
 import {
   DatasourceOverwrite,
   Engine,
   EngineConfig,
   EngineEventType,
   GetConfigResult,
-} from './Engine'
-import {
-  getErrorMessageWithLink,
-  PrismaClientInitializationError,
-  PrismaClientKnownRequestError,
-  PrismaClientRustError,
-  PrismaClientRustPanicError,
-  PrismaClientUnknownRequestError,
-  RequestError,
-} from './errors'
+} from '../common/Engine'
+import { RequestError } from '../common/errors/types/RequestError'
+import { PrismaClientKnownRequestError } from '../common/errors/PrismaClientKnownRequestError'
+import { PrismaClientInitializationError } from '../common/errors/PrismaClientInitializationError'
+import { PrismaClientRustError } from '../common/errors/PrismaClientRustError'
+import { PrismaClientRustPanicError } from '../common/errors/PrismaClientRustPanicError'
+import { PrismaClientUnknownRequestError } from '../common/errors/PrismaClientUnknownRequestError'
+import { getErrorMessageWithLink } from '../common/errors/utils/getErrorMessageWithLink'
 import {
   convertLog,
   getMessage,
   isRustError,
   isRustErrorLog,
   RustError,
   RustLog,
-} from './log'
-import { omit } from './omit'
-import { printGeneratorConfig } from './printGeneratorConfig'
+} from '../common/errors/utils/log'
+import { omit } from '../tools/omit'
+import { printGeneratorConfig } from '../common/utils/printGeneratorConfig'
 import { Connection, Result } from './Connection'
-import { fixBinaryTargets, getRandomString, plusX } from './util'
-import type * as Tx from './definitions/Transaction'
+import { fixBinaryTargets, getRandomString, plusX } from '../common/utils/util'
+import type * as Tx from '../common/types/Transaction'
 import {
   QueryEngineRequestHeaders,
   QueryEngineResult,
-} from './NodeAPILibraryTypes'
+} from '../common/types/QueryEngine'
 
 const debug = Debug('prisma:engine')
 const exists = promisify(fs.exists)

src/packages/engine-core/src/Engine.ts → src/packages/engine-core/src/common/Engine.ts

@@ -1,6 +1,9 @@
 import { DataSource, GeneratorConfig } from '@prisma/generator-helper'
-import type * as Transaction from './definitions/Transaction'
-import { QueryEngineRequestHeaders, QueryEngineResult } from './NodeAPILibraryTypes'
+import type * as Transaction from './types/Transaction'
+import {
+  QueryEngineRequestHeaders,
+  QueryEngineResult,
+} from './types/QueryEngine'
 
 export interface FilterConstructor {
   new (config: EngineConfig): Engine
@@ -24,9 +27,15 @@ export abstract class Engine {
     transaction?: boolean,
     numTry?: number,
   ): Promise<QueryEngineResult<T>[]>
-  abstract transaction(action: 'start', options?: Transaction.Options): Promise<Transaction.Info>
+  abstract transaction(
+    action: 'start',
+    options?: Transaction.Options,
+  ): Promise<Transaction.Info>
   abstract transaction(action: 'commit', info: Transaction.Info): Promise<void>
-  abstract transaction(action: 'rollback', info: Transaction.Info): Promise<void>
+  abstract transaction(
+    action: 'rollback',
+    info: Transaction.Info,
+  ): Promise<void>
 }
 
 export type EngineEventType = 'query' | 'info' | 'warn' | 'error' | 'beforeExit'

src/packages/engine-core/src/common/errors/PrismaClientInitializationError.ts

@@ -0,0 +1,14 @@
+export class PrismaClientInitializationError extends Error {
+  clientVersion: string
+  errorCode?: string
+
+  constructor(message: string, clientVersion: string, errorCode?: string) {
+    super(message)
+    this.clientVersion = clientVersion
+    this.errorCode = errorCode
+    Error.captureStackTrace(PrismaClientInitializationError)
+  }
+  get [Symbol.toStringTag]() {
+    return 'PrismaClientInitializationError'
+  }
+}

src/packages/engine-core/src/common/errors/PrismaClientKnownRequestError.ts

@@ -0,0 +1,21 @@
+export class PrismaClientKnownRequestError extends Error {
+  code: string
+  meta?: object
+  clientVersion: string
+
+  constructor(
+    message: string,
+    code: string,
+    clientVersion: string,
+    meta?: any,
+  ) {
+    super(message)
+
+    this.code = code
+    this.clientVersion = clientVersion
+    this.meta = meta
+  }
+  get [Symbol.toStringTag]() {
+    return 'PrismaClientKnownRequestError'
+  }
+}

src/packages/engine-core/src/common/errors/PrismaClientRustError.ts

@@ -0,0 +1,28 @@
+import { getBacktraceFromLog, getBacktraceFromRustError } from './utils/log'
+import { PrismaClientRustErrorArgs } from './types/PrismaClientRustErrorArgs'
+
+/**
+ * A generic Prisma Client Rust error.
+ * This error is being exposed via the `prisma.$on('error')` interface
+ */
+export class PrismaClientRustError extends Error {
+  clientVersion: string
+
+  constructor({ clientVersion, log, error }: PrismaClientRustErrorArgs) {
+    if (log) {
+      const backtrace = getBacktraceFromLog(log)
+      super(backtrace ?? 'Unkown error')
+    } else if (error) {
+      const backtrace = getBacktraceFromRustError(error)
+      super(backtrace)
+    } else {
+      // this should never happen
+      super(`Unknown error`)
+    }
+
+    this.clientVersion = clientVersion
+  }
+  get [Symbol.toStringTag]() {
+    return 'PrismaClientRustPanicError'
+  }
+}

src/packages/engine-core/src/common/errors/PrismaClientRustPanicError.ts

@@ -0,0 +1,12 @@
+export class PrismaClientRustPanicError extends Error {
+  clientVersion: string
+
+  constructor(message: string, clientVersion: string) {
+    super(message)
+
+    this.clientVersion = clientVersion
+  }
+  get [Symbol.toStringTag]() {
+    return 'PrismaClientRustPanicError'
+  }
+}

src/packages/engine-core/src/common/errors/PrismaClientUnknownRequestError.ts

@@ -0,0 +1,12 @@
+export class PrismaClientUnknownRequestError extends Error {
+  clientVersion: string
+
+  constructor(message: string, clientVersion: string) {
+    super(message)
+
+    this.clientVersion = clientVersion
+  }
+  get [Symbol.toStringTag]() {
+    return 'PrismaClientUnknownRequestError'
+  }
+}

src/packages/engine-core/src/common/errors/types/ErrorWithLinkInput.ts

@@ -0,0 +1,11 @@
+import { ConnectorType } from '@prisma/generator-helper'
+
+export interface ErrorWithLinkInput {
+  version: string
+  engineVersion?: string
+  database?: ConnectorType
+  query?: string
+  platform?: string
+  title: string
+  description?: string
+}

src/packages/engine-core/src/common/errors/types/PrismaClientRustErrorArgs.ts

@@ -0,0 +1,7 @@
+import { RustLog, RustError } from '../utils/log'
+
+export type PrismaClientRustErrorArgs = {
+  clientVersion: string
+  log?: RustLog
+  error?: RustError
+}

src/packages/engine-core/src/common/errors/types/RequestError.ts

@@ -0,0 +1,9 @@
+export interface RequestError {
+  error: string
+  user_facing_error: {
+    is_panic: boolean
+    message: string
+    meta?: object
+    error_code?: string
+  }
+}

src/packages/engine-core/src/common/errors/utils/getErrorMessageWithLink.ts

@@ -0,0 +1,69 @@
+import { getLogs } from '@prisma/debug'
+import { getGithubIssueUrl, link } from '../../utils/util'
+import stripAnsi from 'strip-ansi'
+import { maskQuery } from './maskQuery'
+import { normalizeLogs } from './normalizeLogs'
+import { ErrorWithLinkInput } from '../types/ErrorWithLinkInput'
+
+export function getErrorMessageWithLink({
+  version,
+  platform,
+  title,
+  description,
+  engineVersion,
+  database,
+  query,
+}: ErrorWithLinkInput) {
+  const gotLogs = getLogs(6000 - (query?.length ?? 0))
+  const logs = normalizeLogs(stripAnsi(gotLogs))
+  const moreInfo = description
+    ? `# Description\n\`\`\`\n${description}\n\`\`\``
+    : ''
+  const body = stripAnsi(
+    `Hi Prisma Team! My Prisma Client just crashed. This is the report:
+## Versions
+
+| Name            | Version            |
+|-----------------|--------------------|
+| Node            | ${process.version?.padEnd(19)}| 
+| OS              | ${platform?.padEnd(19)}|
+| Prisma Client   | ${version?.padEnd(19)}|
+| Query Engine    | ${engineVersion?.padEnd(19)}|
+| Database        | ${database?.padEnd(19)}|
+
+${moreInfo}
+
+## Query
+\`\`\`
+${query ? maskQuery(query) : ''}
+\`\`\`
+
+## Logs
+\`\`\`
+${logs}
+\`\`\`
+
+## Client Snippet
+\`\`\`ts
+// PLEASE FILL YOUR CODE SNIPPET HERE
+\`\`\`
+
+## Schema
+\`\`\`prisma
+// PLEASE ADD YOUR SCHEMA HERE IF POSSIBLE
+\`\`\`
+`,
+  )
+
+  const url = getGithubIssueUrl({ title, body })
+  return `${title}
+
+This is a non-recoverable error which probably happens when the Prisma Query Engine has a panic.
+
+${link(url)}
+
+If you want the Prisma team to look into it, please open the link above 🙏
+To increase the chance of success, please post your schema and a snippet of
+how you used Prisma Client in the issue. 
+`
+}

src/packages/engine-core/src/common/errors/utils/normalizeLogs.ts

@@ -0,0 +1,17 @@
+/**
+ * Removes the leading timestamps (from docker) and trailing ms (from debug)
+ * @param logs logs to normalize
+ */
+export function normalizeLogs(logs: string): string {
+  return logs
+    .split('\n')
+    .map((l) => {
+      return l
+        .replace(
+          /^\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z)\s*/,
+          '',
+        )
+        .replace(/\+\d+\s*ms$/, '')
+    })
+    .join('\n')
+}