chore(*): polishing upstream work on the data proxy [DPGA, 5]

helpers/compile/plugins/fill-plugin/fillers/function.ts

@@ -0,0 +1,3 @@
+export const fn = () => {}
+
+fn.prototype = fn

packages/cli/src/Init.ts

@@ -1,8 +1,9 @@
 import type { ConnectorType } from '@prisma/generator-helper'
-import type { Command } from '@prisma/sdk'
 import {
   arg,
   canConnectToDatabase,
+  checkUnsupportedDataProxy,
+  Command,
   format,
   getCommandWithExecutor,
   HelpError,
@@ -134,6 +135,8 @@ export class Init implements Command {
       return this.help()
     }
 
+    await checkUnsupportedDataProxy('init', args, false)
+
     /**
      * Validation
      */

packages/client/edge.d.ts

@@ -0,0 +1 @@
+export * from '.prisma/client'

packages/client/edge.js

@@ -0,0 +1,3 @@
+module.exports = {
+  ...require('.prisma/client/edge'),
+}

packages/client/helpers/build.ts

@@ -5,6 +5,9 @@ import type { BuildOptions } from '../../../helpers/compile/build'
 import { build } from '../../../helpers/compile/build'
 import { fillPlugin } from '../../../helpers/compile/plugins/fill-plugin/fillPlugin'
 
+const fillPluginPath = path.join('..', '..', 'helpers', 'compile', 'plugins', 'fill-plugin')
+const functionPolyfillPath = path.join(fillPluginPath, 'fillers', 'function.ts')
+
 // we define the config for runtime
 const nodeRuntimeBuildConfig: BuildOptions = {
   name: 'runtime',
@@ -13,6 +16,8 @@ const nodeRuntimeBuildConfig: BuildOptions = {
   bundle: true,
   define: {
     NODE_CLIENT: 'true',
+    // that fixes an issue with lz-string umd builds
+    'define.amd': 'false',
   },
 }
 
@@ -36,9 +41,18 @@ const edgeRuntimeBuildConfig: BuildOptions = {
   define: {
     // that helps us to tree-shake unused things out
     NODE_CLIENT: 'false',
+    // that fixes an issue with lz-string umd builds
+    'define.amd': 'false',
   },
   plugins: [
     fillPlugin({
+      // we remove eval and Function for vercel
+      eval: { define: 'undefined' },
+      Function: {
+        define: 'fn',
+        inject: functionPolyfillPath,
+      },
+
       // TODO no tree shaking on wrapper pkgs
       '@prisma/get-platform': { contents: '' },
       // removes un-needed code out of `chalk`

packages/client/package.json

@@ -56,6 +56,8 @@
     "runtime",
     "scripts",
     "generator-build",
+    "edge.js",
+    "edge.d.ts",
     "index.js",
     "index.d.ts",
     "index-browser.js"

packages/client/scripts/postinstall.js

@@ -197,21 +197,20 @@ function run(cmd, params, cwd = process.cwd()) {
 /**
  * Copies our default "throw" files into the default generation folder. These
  * files are dummy and informative because they just throw an error to let the
- * user know that they have forgotten to run `prisma generate`.
+ * user know that they have forgotten to run `prisma generate` or that they
+ * don't have a a schema file yet. We only add these files at the default
+ * location `node_modules/.prisma/client`.
  */
 async function createDefaultGeneratedThrowFiles() {
   try {
     const dotPrismaClientDir = path.join(__dirname, '../../../.prisma/client')
     const defaultNodeIndexPath = path.join(dotPrismaClientDir, 'index.js')
     const defaultNodeIndexDtsPath = path.join(dotPrismaClientDir, 'index.d.ts')
     const defaultBrowserIndexPath = path.join(dotPrismaClientDir, 'index-browser.js')
+    const defaultEdgeIndexPath = path.join(dotPrismaClientDir, 'edge.js')
+    const defaultEdgeIndexDtsPath = path.join(dotPrismaClientDir, 'edge.d.ts')
     await makeDir(dotPrismaClientDir)
 
-    const dotPrismaClientEdgeDir = path.join(dotPrismaClientDir, 'edge')
-    const defaultEdgeIndexPath = path.join(dotPrismaClientEdgeDir, 'index.js')
-    const defaultEdgeIndexDtsPath = path.join(dotPrismaClientEdgeDir, 'index.d.ts')
-    await makeDir(dotPrismaClientEdgeDir)
-
     if (!fs.existsSync(defaultNodeIndexPath)) {
       await copyFile(path.join(__dirname, 'default-index.js'), defaultNodeIndexPath)
     }

packages/client/src/generation/TSClient/Generatable.ts

@@ -1,6 +1,6 @@
 export interface Generatable {
   toJS?(edge?: boolean): string | Promise<string>
-  toTS(): string | Promise<string>
+  toTS(edge?: boolean): string | Promise<string>
   toBrowserJS?(): string | Promise<string>
   toTSWithoutNamespace?(): string | Promise<string>
 }
@@ -13,6 +13,6 @@ export function BrowserJS(gen: Generatable): string | Promise<string> {
   return gen.toBrowserJS?.() ?? ''
 }
 
-export function TS(gen: Generatable): string | Promise<string> {
-  return gen.toTS()
+export function TS(gen: Generatable, edge = false): string | Promise<string> {
+  return gen.toTS(edge)
 }

packages/client/src/generation/TSClient/TSClient.ts

@@ -133,7 +133,10 @@ ${buildNFTAnnotations(dataProxy, engineType, platforms, relativeOutdir)}
 `
     return code
   }
-  public toTS(): string {
+  public toTS(edge = false): string {
+    // edge exports the same ts definitions as the index
+    if (edge === true) return `export * from './index'`
+
     const prismaClientClass = new PrismaClientClass(
       this.dmmf,
       this.options.datasources,

packages/client/src/generation/generateClient.ts

@@ -123,17 +123,8 @@ export async function buildClient({
 
   // we only generate the edge client if `--data-proxy` is passed
   if (dataProxy === true) {
-    fileMap[path.join('edge', 'index.js')] = await JS(edgeTsClient, true)
-    fileMap[path.join('edge', 'package.json')] = JSON.stringify(
-      {
-        name: '.prisma/client/edge',
-        main: 'index.js',
-        types: '../index.d.ts',
-        browser: '../index-browser.js',
-      },
-      null,
-      2,
-    )
+    fileMap[path.join('edge.js')] = await JS(edgeTsClient, true)
+    fileMap[path.join('edge.d.ts')] = await TS(edgeTsClient, true)
   }
 
   return {
@@ -222,7 +213,6 @@ export async function generateClient(options: GenerateClientOptions): Promise<vo
   }
 
   await makeDir(finalOutputDir)
-  await makeDir(path.join(finalOutputDir, 'edge'))
   await makeDir(path.join(outputDir, 'runtime'))
   // TODO: why do we sometimes use outputDir and sometimes finalOutputDir?
   // outputDir:       /home/millsp/Work/prisma/packages/client
@@ -435,7 +425,7 @@ async function getGenerationDirs({ testMode, runtimeDirs, generator, outputDir }
   const _runtimeDirs = {
     // if we have an override, we use it, but if not then use the defaults
     node: runtimeDirs?.node || (useDefaultOutdir ? '@prisma/client/runtime' : './runtime'),
-    edge: runtimeDirs?.edge || (useDefaultOutdir ? '@prisma/client/runtime' : '../runtime'),
+    edge: runtimeDirs?.edge || (useDefaultOutdir ? '@prisma/client/runtime' : './runtime'),
   }
 
   const finalOutputDir = useDefaultOutdir ? await getDefaultOutdir(outputDir) : outputDir

packages/client/src/generation/utils/buildInjectableEdgeEnv.ts

@@ -1,6 +1,6 @@
 import type { InternalDatasource } from '../../runtime/utils/printDatasources'
 
-type LoadedEnv = {
+type InjectableEnv = {
   parsed: {
     [x: string]: string | undefined
   }
@@ -9,90 +9,70 @@ type LoadedEnv = {
 /**
  * Builds an injectable environment for the data proxy edge client. It's useful
  * because it is designed to run in browser-like environments where things like
- * `fs`, `process.env`, and .env file loading are not available. The injectable
- * env is the default fallback when `tryLoadEnvs` wasn't called by the client.
+ * `fs`, `process.env`, and .env file loading are not available. It is the place
+ * where we make collect the env vars for the edge client. To understand this
+ * better, take a look at the generated code in the edge client.
  * @see {@link declareInjectableEdgeEnv}
  * @param edge
  * @param datasources
  * @returns
  */
 export function buildInjectableEdgeEnv(edge: boolean, datasources: InternalDatasource[]) {
   if (edge === true) {
-    const envVarNames = getSelectedEnvVarNames(datasources)
-    const loadedEnv = getEmptyEnvObjectForVars(envVarNames)
-
-    return declareInjectableEdgeEnv(loadedEnv)
+    return declareInjectableEdgeEnv(datasources)
   }
 
   return ``
 }
 
 /**
- * Determines which env vars we are interested in in the case of the data proxy
- * client. Right now, we are only interested in env vars from the `datasource`.
+ * Creates the necessary declarations to embed env vars directly inside of the
+ * generated client. We abuse a custom `JSON.stringify` to generate the code.
  * @param datasources to find env vars in
- * @returns
  */
-function getSelectedEnvVarNames(datasources: InternalDatasource[]) {
-  return datasources.reduce((acc, datasource) => {
-    if (datasource.url.fromEnvVar) {
-      return [...acc, datasource.url.fromEnvVar]
-    }
+function declareInjectableEdgeEnv(datasources: InternalDatasource[]) {
+  const envVarNames = getSelectedEnvVarNames(datasources)
 
-    return acc
-  }, [] as string[])
-}
-
-/**
- * Like `tryLoadEnvs` but we only retain a subset of the env vars that will be
- * used in the case of the data proxy client. And we discard the `message` prop.
- * @param envVarNames to be selected from the load
- * @returns
- */
-function getEmptyEnvObjectForVars(envVarNames: string[]) {
-  const selectedEnv: LoadedEnv = { parsed: {} }
+  const injectableEdgeEnv: InjectableEnv = { parsed: {} }
 
+  // we create a base env with empty values for env names
   for (const envVarName of envVarNames) {
-    /** note that we willingly keep `undefined` values because
-     * we need that later in {@link declareInjectableEdgeEnv} **/
-    selectedEnv.parsed[envVarName] = undefined
+    injectableEdgeEnv.parsed[envVarName] = undefined
   }
 
-  return selectedEnv
-}
-
-/**
- * Creates the necessary declarations to embed env vars directly inside of the
- * generated client. We abuse a custom `JSON.stringify` replacer to transform
- * {@link loadedEnv} into a piece of code. The goal of this is to take that and
- * generate a new object which re-prioritizes the loading of the environment.
- *
- * By generating an output with `${key} || process.env.${key} || '${value}'` it
- * would yield something like `DB_URL || process.env.DB_URL || undefined`:
- * - For Cloudflare Workers `DB_URL` will be the first to be found (runtime)
- *   - `process.env.DB_URL` will be undefined
- * - For Vercel `process.env.DB_URL` is replaced by webpack by a value
- *   - `DB_URL` will be undefined at anytime
- * - If none of them were provided, we fallback to the default `undefined`
- * @param loadedEnv
- */
-function declareInjectableEdgeEnv(loadedEnv: LoadedEnv) {
   // abuse a custom replacer to create the injectable env
   const injectableEdgeEnvDeclaration = JSON.stringify(
-    loadedEnv,
+    injectableEdgeEnv,
     (key, value) => {
       if (key === '') return value
       if (key === 'parsed') return value
 
+      // for cloudflare workers, an env var is a global js variable
       const cfwEnv = `typeof global !== 'undefined' && global['${key}']`
-      const vercelEnv = `process.env['${key}']`
-      const dotEnv = value ? `'${value}'` : 'undefined'
+      // for vercel edge functions, it's injected statically at build
+      const vercelEnv = `process.env.${key}`
 
-      return `${cfwEnv} || ${vercelEnv} || ${dotEnv}`
+      return `${cfwEnv} || ${vercelEnv} || undefined`
     },
     2,
   ).replace(/"/g, '') // remove quotes to make code
 
   return `
 config.injectableEdgeEnv = ${injectableEdgeEnvDeclaration}`
 }
+
+/**
+ * Determines which env vars we are interested in in the case of the data proxy
+ * client. Right now, we are only interested in env vars from the `datasource`.
+ * @param datasources to find env vars in
+ * @returns
+ */
+function getSelectedEnvVarNames(datasources: InternalDatasource[]) {
+  return datasources.reduce((acc, datasource) => {
+    if (datasource.url.fromEnvVar) {
+      return [...acc, datasource.url.fromEnvVar]
+    }
+
+    return acc
+  }, [] as string[])
+}

packages/client/src/generation/utils/buildNFTAnnotations.ts

@@ -35,10 +35,11 @@ export function buildNFTAnnotations(
   }
 
   const engineAnnotations = map(platforms, (platform) => {
-    return buildNFTEngineAnnotation(engineType, platform, relativeOutdir)
+    const engineFilename = getQueryEngineFilename(engineType, platform)
+    return engineFilename ? buildNFTAnnotation(engineFilename, relativeOutdir) : ''
   }).join('\n')
 
-  const schemaAnnotations = buildNFTSchemaAnnotation(engineType, relativeOutdir)
+  const schemaAnnotations = buildNFTAnnotation('schema.prisma', relativeOutdir)
 
   return `${engineAnnotations}${schemaAnnotations}`
 }
@@ -76,32 +77,3 @@ function buildNFTAnnotation(fileName: string, relativeOutdir: string) {
 path.join(__dirname, ${JSON.stringify(fileName)});
 path.join(process.cwd(), ${JSON.stringify(relativeFilePath)})`
 }
-
-/**
- * Build an annotation for the prisma client engine files
- * @param engineType
- * @param platform
- * @param relativeOutdir
- * @returns
- */
-function buildNFTEngineAnnotation(engineType: ClientEngineType, platform: Platform, relativeOutdir: string) {
-  const engineFilename = getQueryEngineFilename(engineType, platform)
-
-  if (engineFilename === undefined) return ''
-
-  return buildNFTAnnotation(engineFilename, relativeOutdir)
-}
-
-/**
- * Build an annotation for the prisma schema files
- * @param engineType
- * @param relativeOutdir
- * @returns
- */
-function buildNFTSchemaAnnotation(engineType: ClientEngineType, relativeOutdir: string) {
-  if (engineType === ClientEngineType.Library || engineType === ClientEngineType.Binary) {
-    return buildNFTAnnotation('schema.prisma', relativeOutdir)
-  }
-
-  return ''
-}

packages/client/src/runtime/getPrismaClient.ts

@@ -47,7 +47,7 @@ declare global {
 }
 
 // used by esbuild for tree-shaking
-globalThis.NODE_CLIENT = true
+typeof globalThis === 'object' ? (globalThis.NODE_CLIENT = true) : 0
 
 function isReadonlyArray(arg: any): arg is ReadonlyArray<any> {
   return Array.isArray(arg)

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

@@ -56,7 +56,7 @@ export interface EngineConfig {
   showColors?: boolean
   logQueries?: boolean
   logLevel?: 'info' | 'warn'
-  env?: Record<string, string>
+  env: Record<string, string>
   flags?: string[]
   clientVersion?: string
   previewFeatures?: string[]