chore: revert "fix(sdk): avoid crash in prisma version, rename 'getVe…

…rsion' -> 'getBinaryVersion' (#13737)" (#14025)

This reverts commit 3718bfa.

Co-authored-by: Alexey Orlenko <alex@aqrln.net>

packages/cli/src/Version.ts

@@ -4,23 +4,32 @@ import type { Command } from '@prisma/internals'
 import {
   arg,
   BinaryType,
+  engineEnvVarMap,
   format,
   formatTable,
   getConfig,
-  getEnginesMetaInfo,
   getSchema,
   getSchemaPath,
+  getVersion,
   HelpError,
   isError,
   loadEnvFile,
+  resolveBinary,
 } from '@prisma/internals'
 import chalk from 'chalk'
-import { match, P } from 'ts-pattern'
+import fs from 'fs'
+import path from 'path'
 
 import { getInstalledPrismaClientVersion } from './utils/getClientVersion'
 
 const packageJson = require('../package.json') // eslint-disable-line @typescript-eslint/no-var-requires
 
+interface BinaryInfo {
+  path: string
+  version: string
+  fromEnvVar?: string
+}
+
 /**
  * $ prisma version
  */
@@ -65,51 +74,29 @@ export class Version implements Command {
 
     const platform = await getPlatform()
     const cliQueryEngineBinaryType = getCliQueryEngineBinaryType()
-
-    const [enginesMetaInfo, enginesMetaInfoErrors] = await getEnginesMetaInfo()
-
-    const enginesRows = enginesMetaInfo.map((engineMetaInfo) => {
-      return match(engineMetaInfo)
-        .with({ 'query-engine': P.select() }, (currEngineInfo) => {
-          return [
-            `Query Engine${cliQueryEngineBinaryType === BinaryType.libqueryEngine ? ' (Node-API)' : ' (Binary)'}`,
-            currEngineInfo,
-          ]
-        })
-        .with({ 'migration-engine': P.select() }, (currEngineInfo) => {
-          return ['Migration Engine', currEngineInfo]
-        })
-        .with({ 'introspection-engine': P.select() }, (currEngineInfo) => {
-          return ['Introspection Engine', currEngineInfo]
-        })
-        .with({ 'format-binary': P.select() }, (currEngineInfo) => {
-          return ['Format Binary', currEngineInfo]
-        })
-        .exhaustive()
-    })
+    const introspectionEngine = await this.resolveEngine(BinaryType.introspectionEngine)
+    const migrationEngine = await this.resolveEngine(BinaryType.migrationEngine)
+    // TODO This conditional does not really belong here, CLI should be able to tell you which engine it is _actually_ using
+    const queryEngine = await this.resolveEngine(cliQueryEngineBinaryType)
+    const fmtBinary = await this.resolveEngine(BinaryType.prismaFmt)
 
     const prismaClientVersion = await getInstalledPrismaClientVersion()
 
     const rows = [
       [packageJson.name, packageJson.version],
       ['@prisma/client', prismaClientVersion ?? 'Not found'],
       ['Current platform', platform],
-
-      ...enginesRows,
-
+      [
+        `Query Engine${cliQueryEngineBinaryType === BinaryType.libqueryEngine ? ' (Node-API)' : ' (Binary)'}`,
+        this.printBinaryInfo(queryEngine),
+      ],
+      ['Migration Engine', this.printBinaryInfo(migrationEngine)],
+      ['Introspection Engine', this.printBinaryInfo(introspectionEngine)],
+      ['Format Binary', this.printBinaryInfo(fmtBinary)],
       ['Default Engines Hash', packageJson.dependencies['@prisma/engines'].split('.').pop()],
       ['Studio', packageJson.devDependencies['@prisma/studio-server']],
     ]
 
-    /**
-     * If reading Rust engines metainfo (like their git hash) failed, display the errors to stderr,
-     * and let Node.js exit naturally, but with error code 1.
-     */
-    if (enginesMetaInfoErrors.length > 0) {
-      process.exitCode = 1
-      enginesMetaInfoErrors.forEach((e) => console.error(e))
-    }
-
     const schemaPath = await getSchemaPath()
     const featureFlags = await this.getFeatureFlags(schemaPath)
 
@@ -140,6 +127,24 @@ export class Version implements Command {
     return []
   }
 
+  private printBinaryInfo({ path: absolutePath, version, fromEnvVar }: BinaryInfo): string {
+    const resolved = fromEnvVar ? `, resolved by ${fromEnvVar}` : ''
+    return `${version} (at ${path.relative(process.cwd(), absolutePath)}${resolved})`
+  }
+
+  private async resolveEngine(binaryName: BinaryType): Promise<BinaryInfo> {
+    const envVar = engineEnvVarMap[binaryName]
+    const pathFromEnv = process.env[envVar]
+    if (pathFromEnv && fs.existsSync(pathFromEnv)) {
+      const version = await getVersion(pathFromEnv, binaryName)
+      return { version, path: pathFromEnv, fromEnvVar: envVar }
+    }
+
+    const binaryPath = await resolveBinary(binaryName)
+    const version = await getVersion(binaryPath, binaryName)
+    return { path: binaryPath, version }
+  }
+
   public help(error?: string): string | HelpError {
     if (error) {
       return new HelpError(`\n${chalk.bold.red(`!`)} ${error}\n${Version.help}`)

packages/client/src/generation/generateClient.ts

@@ -1,7 +1,7 @@
 import { BinaryType } from '@prisma/fetch-engine'
 import type { BinaryPaths, DataSource, DMMF, GeneratorConfig } from '@prisma/generator-helper'
 import type { Platform } from '@prisma/internals'
-import { ClientEngineType, getClientEngineType, getEngineVersion } from '@prisma/internals'
+import { ClientEngineType, getClientEngineType, getVersion } from '@prisma/internals'
 import copy from '@timsuchanek/copy'
 import chalk from 'chalk'
 import fs from 'fs'
@@ -291,8 +291,8 @@ export async function generateClient(options: GenerateClientOptions): Promise<vo
         clientEngineType === ClientEngineType.Binary ? BinaryType.queryEngine : BinaryType.libqueryEngine
       // They must have an equal size now, let's check for the hash
       const [sourceVersion, targetVersion] = await Promise.all([
-        getEngineVersion(filePath, binaryName).catch(() => null),
-        getEngineVersion(target, binaryName).catch(() => null),
+        getVersion(filePath, binaryName).catch(() => null),
+        getVersion(target, binaryName).catch(() => null),
       ])
 
       if (sourceVersion && targetVersion && sourceVersion === targetVersion) {

packages/internals/src/__tests__/engine-commands/getEngineVersion.test.ts → packages/internals/src/__tests__/engine-commands/getVersion.test.ts

@@ -1,32 +1,32 @@
 import { enginesVersion, getCliQueryEngineBinaryType } from '@prisma/engines'
 
-import { BinaryType, getEngineVersion } from '../..'
+import { BinaryType, getVersion } from '../..'
 
 const testIf = (condition: boolean) => (condition ? test : test.skip)
 const useNodeAPI = getCliQueryEngineBinaryType() === BinaryType.libqueryEngine
 
-describe('getEngineVersion', () => {
+describe('getVersion', () => {
   test('Introspection Engine', async () => {
-    const introspectionEngineVersion = await getEngineVersion(undefined, BinaryType.introspectionEngine)
+    const introspectionEngineVersion = await getVersion(undefined, BinaryType.introspectionEngine)
     expect(introspectionEngineVersion.split(' ')[1]).toMatch(enginesVersion)
   })
 
   test('Migration Engine', async () => {
-    const migrationEngineVersion = await getEngineVersion(undefined, BinaryType.migrationEngine)
+    const migrationEngineVersion = await getVersion(undefined, BinaryType.migrationEngine)
     expect(migrationEngineVersion.split(' ')[1]).toMatch(enginesVersion)
   })
 
   test('Prisma Fmt', async () => {
-    const prismaFmtVersion = await getEngineVersion(undefined, BinaryType.prismaFmt)
+    const prismaFmtVersion = await getVersion(undefined, BinaryType.prismaFmt)
     expect(prismaFmtVersion.split(' ')[1]).toMatch(enginesVersion)
   })
 
   testIf(!useNodeAPI)('Query Engine', async () => {
-    const queryEngineVersion = await getEngineVersion(undefined, BinaryType.queryEngine)
+    const queryEngineVersion = await getVersion(undefined, BinaryType.queryEngine)
     expect(queryEngineVersion.split(' ')[1]).toMatch(enginesVersion)
   })
   testIf(useNodeAPI)('Query Engine (Node-API)', async () => {
-    const libqueryEngineVersion = await getEngineVersion(undefined, BinaryType.libqueryEngine)
+    const libqueryEngineVersion = await getVersion(undefined, BinaryType.libqueryEngine)
     expect(libqueryEngineVersion.split(' ')[1]).toMatch(enginesVersion)
   })
 })

packages/internals/src/engine-commands/getEngineVersion.ts → packages/internals/src/engine-commands/getVersion.ts

@@ -1,14 +1,18 @@
+import Debug from '@prisma/debug'
 import type { NodeAPILibraryTypes } from '@prisma/engine-core'
 import { getCliQueryEngineBinaryType } from '@prisma/engines'
 import { BinaryType } from '@prisma/fetch-engine'
 import { isNodeAPISupported } from '@prisma/get-platform'
 import execa from 'execa'
-import * as TE from 'fp-ts/TaskEither'
 
 import { resolveBinary } from '../resolveBinary'
 import { load } from '../utils/load'
 
-export async function getEngineVersion(enginePath?: string, binaryName?: BinaryType): Promise<string> {
+const debug = Debug('prisma:getVersion')
+
+const MAX_BUFFER = 1_000_000_000
+
+export async function getVersion(enginePath?: string, binaryName?: BinaryType): Promise<string> {
   if (!binaryName) {
     binaryName = getCliQueryEngineBinaryType()
   }
@@ -19,15 +23,10 @@ export async function getEngineVersion(enginePath?: string, binaryName?: BinaryT
     const QE = load<NodeAPILibraryTypes.Library>(enginePath)
     return `libquery-engine ${QE.version().commit}`
   } else {
-    const result = await execa(enginePath, ['--version'])
+    const result = await execa(enginePath, ['--version'], {
+      maxBuffer: MAX_BUFFER,
+    })
 
     return result.stdout
   }
 }
-
-export function safeGetEngineVersion(enginePath?: string, binaryName?: BinaryType): TE.TaskEither<Error, string> {
-  return TE.tryCatch(
-    () => getEngineVersion(enginePath, binaryName),
-    (error) => error as Error,
-  )
-}

packages/internals/src/engine-commands/index.ts

@@ -3,5 +3,4 @@ export type { ConfigMetaFormat } from './getConfig'
 export { getConfig } from './getConfig'
 export type { GetDMMFOptions } from './getDmmf'
 export { getDMMF } from './getDmmf'
-export { getEnginesMetaInfo } from './getEnginesMetaInfo'
-export { getEngineVersion } from './getEngineVersion'
+export { getVersion } from './getVersion'