diff --git a/.github/workflows/lost-pixel.yml b/.github/workflows/lost-pixel.yml index d61c999c2a..76cd037641 100644 --- a/.github/workflows/lost-pixel.yml +++ b/.github/workflows/lost-pixel.yml @@ -24,8 +24,11 @@ jobs: - name: Generate sitemap run: npx lost-pixel page-sitemap-gen http://172.17.0.1:3000/sitemap.xml "./lost-pixel-pages.json" + - name: Edit sitemap urls + run: sed -i -e 's|"/docs|"|g' lost-pixel-pages.json + - name: Edit page names - run: sed -i -e 's/_/\//g' -e 's/prisma\.io//g' -re 's/(name.+)(\/)(\")/\1-\3/g' lost-pixel-pages.json + run: sed -i -e 's/_/\//g' -e 's|prisma\.io\/docs||g' -re 's/(name.+)(\/)(\")/\1-\3/g' lost-pixel-pages.json - name: Lost Pixel uses: lost-pixel/lost-pixel@v3.16.0 diff --git a/content/200-orm/200-prisma-client/500-deployment/301-edge/450-deploy-to-cloudflare.mdx b/content/200-orm/200-prisma-client/500-deployment/301-edge/450-deploy-to-cloudflare.mdx deleted file mode 100644 index 7fc2fa078d..0000000000 --- a/content/200-orm/200-prisma-client/500-deployment/301-edge/450-deploy-to-cloudflare.mdx +++ /dev/null @@ -1,544 +0,0 @@ ---- -title: 'Deploy to Cloudflare Workers & Pages' -sidebar_label: Deploy to Cloudflare -metaTitle: 'Deploy to Cloudflare Workers & Pages' -metaDescription: 'Learn the things you need to know in order to deploy an app that uses Prisma Client for talking to a database to a Cloudflare Worker or to Cloudflare Pages.' -tocDepth: 3 -sidebar_class_name: preview-badge ---- - - - -This page covers everything you need to know to deploy an app with Prisma ORM to a [Cloudflare Worker](https://developers.cloudflare.com/workers/) or to [Cloudflare Pages](https://developers.cloudflare.com/pages). - - - -## General considerations when deploying to Cloudflare Workers - -This section covers _general_ things you need to be aware of when deploying to Cloudflare Workers or Pages and are using Prisma ORM, regardless of the database provider you use. - -### Using an edge-compatible driver - -When deploying a Cloudflare Worker that uses Prisma ORM, you need to use an [edge-compatible driver](/orm/prisma-client/deployment/edge/overview#edge-compatibility-of-database-drivers) and its respective [driver adapter](/orm/overview/databases/database-drivers#driver-adapters) for Prisma ORM. - -The edge-compatible drivers for Cloudflare Workers and Pages are: - -- [Neon Serverless](https://neon.tech/docs/serverless/serverless-driver) uses HTTP to access the database -- [PlanetScale Serverless](https://planetscale.com/docs/tutorials/planetscale-serverless-driver) uses HTTP to access the database -- [`node-postgres`](https://node-postgres.com/) (`pg`) uses Cloudflare's `connect()` (TCP) to access the database -- [`@libsql/client`](https://github.com/tursodatabase/libsql-client-ts) is used to access Turso databases - -There's [also work being done](https://github.com/sidorares/node-mysql2/pull/2289) on the `node-mysql2` driver which will enable access to traditional MySQL databases from Cloudflare Workers and Pages in the future as well. - -> **Note**: [Prisma Accelerate](/accelerate) enables you to access _any_ database from _any_ edge function provider. No edge-compatible driver is necessary. - -### Setting your database connection URL as an environment variable - -First, ensure that the `DATABASE_URL` is set as the `url` of the `datasource` in your Prisma schema: - -```prisma -datasource db { - provider = "postgresql" // this might also be `mysql` or another value depending on your database - url = env("DATABASE_URL") -} -``` - -#### Development - -When using your Worker in **development**, you can configure your database connection via the [`.dev.vars` file](https://developers.cloudflare.com/workers/configuration/secrets/#secrets-in-development) locally. - -Assuming you use the `DATABASE_URL` environment variable from above, you can set it inside `.dev.vars` as follows: - -```bash file=.dev.vars showLineNumbers -DATABASE_URL="your-database-connection-string" -``` - -In the above snippet, `your-database-connection-string` is a placeholder that you need to replace with the value of your own connection string, for example: - -```bash file=.dev.vars showLineNumbers -DATABASE_URL="postgresql://admin:mypassword42@somehost.aws.com:5432/mydb" -``` - -Note that the `.dev.vars` file is not compatible with `.env` files which are typically used by Prisma ORM. - -This means that you need to make sure that Prisma ORM gets access to the environment variable when needed, e.g. when running a Prisma CLI command like `prisma migrate dev`. - -There are several options for achieving this: - -- Run your Prisma CLI commands using [`dotenv`](https://www.npmjs.com/package/dotenv-cli) to specify from where the CLI should read the environment variable, for example: - ```terminal - dotenv -e .dev.vars -- npx prisma migrate dev - ``` -- Create a script in `package.json` that reads `.dev.vars` via [`dotenv`](https://www.npmjs.com/package/dotenv-cli). You can then execute `prisma` commands as follows: `npm run env -- npx prisma migrate dev`. Here's a reference for the script: - ```js file=package.json showLineNumbers - "scripts": { "env": "dotenv -e .dev.vars" } - ``` -- Duplicate the `DATABASE_URL` and any other relevant env vars into a new file called `.env` which can then be used by Prisma ORM. - -> **Note**: If you're using an approach that requires `dotenv`, you need to have the [`dotenv-cli`](https://www.npmjs.com/package/dotenv-cli) package installed. You can do this e.g. by using this command to install the package locally in your project: `npm install -D dotenv-cli`. - -#### Production - -When deploying your Worker to **production**, you'll need to set the database connection using the `wrangler` CLI: - -```terminal -npx wrangler secret put DATABASE_URL -``` - -The command is interactive and will ask you to enter the value for the `DATABASE_URL` env var as the next step in the terminal. - -> **Note**: This command requires you to be authenticated, and will ask you to log in to your Cloudflare account in case you are not. - -### Size limits on free accounts - -Cloudflare has a [size limit of 1 MB for Workers on the free plan](https://developers.cloudflare.com/workers/platform/limits/). If your application bundle with Prisma ORM exceeds that size, we recommend upgrading to a paid Worker plan or using Prisma Accelerate to deploy your application. - -If you're running into this problem with `pg` and the `@prisma/adapter-pg` package, you can replace the `pg` with the custom [`@prisma/pg-worker`](https://github.com/prisma/prisma/tree/main/packages/pg-worker) package and use the [`@prisma/adapter-pg-worker`](https://github.com/prisma/prisma/tree/main/packages/adapter-pg-worker) adapter that belongs to it. - -`@prisma/pg-worker` is an optimized and lightweight version of `pg` that is designed to be used in a Worker. It is a drop-in replacement for `pg` and is fully compatible with Prisma ORM. - -### Deploying a Next.js app with `@cloudflare/next-on-pages` - -Cloudflare offers an option to run Next.js apps on Cloudflare Pages with [`@cloudflare/next-on-pages`](https://github.com/cloudflare/next-on-pages), see the [docs](https://developers.cloudflare.com/pages/framework-guides/deploy-a-nextjs-site) for instructions. - -Based on some testing, we found the following: - -- You can deploy using the PlanetScale Serverless Driver. -- Neon currently doesn't work because of a probable bug in `@cloudflare/next-on-pages` (see [here](https://github.com/cloudflare/next-on-pages/issues/499#issuecomment-1863613990) and [here](https://github.com/cloudflare/workerd/issues/1513)). -- Traditional PostgreSQL deployments using `pg` don't work because `pg` itself currently does not work on `@cloudflare/next-on-pages` (see [here](https://github.com/cloudflare/next-on-pages/issues/605)). - -Feel free to reach out to us on [Discord](https://pris.ly/discord) if you find that anything has changed about this. - -### Set `PRISMA_CLIENT_FORCE_WASM=1` when running locally with `node` - -Some frameworks (e.g. [hono](https://hono.dev/)) use `node` instead of `wrangler` for running Workers locally. If you're using such a framework or are running your Worker locally with `node` for another reason, you need to set the `PRISMA_CLIENT_FORCE_WASM` environment variable: - -``` -export PRISMA_CLIENT_FORCE_WASM=1 -``` - -## Database-specific considerations & examples - -This section provides database-specific instructions for deploying a Cloudflare Worker with Prisma ORM. - -### Prerequisites - -As a prerequisite for the following section, you need to have a Cloudflare Worker running locally and the Prisma CLI installed. - -If you don't have that yet, you can run these commands: - -```terminal -npm create cloudflare@latest prisma-cloudflare-worker-example -- --type hello-world -cd prisma-cloudflare-worker-example -npm install prisma --save-dev -npx prisma init -``` - -We'll use the default `User` model for the example below: - -```prisma -model User { - id Int @id @default(autoincrement()) - email String @unique - name String? -} -``` - -### PostgreSQL (traditional) - -If you are using a traditional PostgreSQL database that's accessed via TCP and the `pg` driver, you need to: - -- use the `@prisma/adapter-pg` database adapter (via the `driverAdapters` Preview feature) -- set `node_compat = true` in `wrangler.toml` (see the [Cloudflare docs](https://developers.cloudflare.com/workers/wrangler/configuration/#add-polyfills-using-wrangler)) - -If you are running into a size issue and can't deploy your application because of that, you can use our slimmer variant of the `pg` driver package [`@prisma/pg-worker`](https://github.com/prisma/prisma/tree/main/packages/pg-worker) and the [`@prisma/adapter-pg-worker`](https://github.com/prisma/prisma/tree/main/packages/adapter-pg-worker) adapter that belongs to it. - -`@prisma/pg-worker` is an optimized and lightweight version of `pg` that is designed to be used in a Worker. It is a drop-in replacement for `pg` and is fully compatible with Prisma ORM. - -#### 1. Configure Prisma schema & database connection - -First, ensure that the database connection is configured properly. In your Prisma schema, set the `url` of the `datasource` block to the `DATABASE_URL` environment variable. You also need to enable the `driverAdapters` feature flag: - -```prisma file=schema.prisma showLineNumbers -generator client { - provider = "prisma-client-js" - previewFeatures = ["driverAdapters"] -} - -datasource db { - provider = "postgresql" - url = env("DATABASE_URL") -} -``` - -Next, you need to set the `DATABASE_URL` environment variable to the value of your database connection string. You'll do this in a file called `.dev.vars` used by Cloudflare: - -```bash file=.dev.vars showLineNumbers -DATABASE_URL="postgresql://admin:mypassword42@somehost.aws.com:5432/mydb" -``` - -Because the Prisma CLI by default is only compatible with `.env` files, you can adjust your `package.json` with the following script that loads the env vars from `.dev.vars`. You can then use this script to load the env vars before executing a `prisma` command. - -Add this script to your `package.json`: - -```js file=package.json highlight=5;add showLineNumbers -{ - // ... - "scripts": { - // .... - //add-next-line - "env": "dotenv -e .dev.vars" - }, - // ... -} -``` - -Now you can execute Prisma CLI commands as follows while ensuring that the command has access to the env vars in `.dev.vars`: - -```terminal -npm run env -- npx prisma -``` - -#### 2. Install dependencies - -Next, install the required packages: - -```terminal -npm install @prisma/adapter-pg -npm install pg -npm install @types/pg --save-dev # if you're using TypeScript -``` - -#### 3. Set `node_compat = true` in `wrangler.toml` - -In your `wrangler.toml` file, add the following line: - -```toml file=wrangler.toml showLineNumbers -node_compat = true -``` - -> **Note**: For Cloudflare Pages, using `node_compat` is not officially supported. If you want to use `pg` in Cloudflare Pages, you can find a workaround [here](https://github.com/cloudflare/workers-sdk/pull/2541#issuecomment-1954209855). - -#### 4. Migrate your database schema (if applicable) - -If you ran `npx prisma init` above, you need to migrate your database schema to create the `User` table that's defined in your Prisma schema (if you already have all the tables you need in your database, you can skip this step): - -```terminal -npm run env -- npx prisma migrate dev --name init -``` - -#### 5. Use Prisma Client in your Worker to send a query to the database - -Here is a sample code snippet that you can use to instantiate `PrismaClient` and send a query to your database: - -```ts -import { PrismaClient } from '@prisma/client' -import { PrismaPg } from '@prisma/adapter-pg' -import { Pool } from 'pg' - -export default { - async fetch(request, env, ctx) { - const pool = new Pool({ connectionString: env.DATABASE_URL }) - const adapter = new PrismaPg(pool) - const prisma = new PrismaClient({ adapter }) - - const users = await prisma.user.findMany() - const result = JSON.stringify(users) - return new Response(result) - }, -} -``` - -#### 6. Run the Worker locally - -To run the Worker locally, you can run the `wrangler dev` command: - -```terminal -npx wrangler dev -``` - -#### 7. Set the `DATABASE_URL` environment variable and deploy the Worker - -To deploy the Worker, you first need to the `DATABASE_URL` environment variable [via the `wrangler` CLI](https://developers.cloudflare.com/workers/configuration/secrets/#secrets-on-deployed-workers): - -```terminal -npx wrangler secret put DATABASE_URL -``` - -The command is interactive and will ask you to enter the value for the `DATABASE_URL` env var as the next step in the terminal. - -> **Note**: This command requires you to be authenticated, and will ask you to log in to your Cloudflare account in case you are not. - -Then you can go ahead then deploy the Worker: - -```terminal -npx wrangler deploy -``` - -The command will output the URL where you can access the deployed Worker. - -### PlanetScale - -If you are using a PlanetScale database, you need to: - -- use the `@prisma/adapter-planetscale` database adapter (via the `driverAdapters` Preview feature) -- manually remove the conflicting `cache` field ([learn more]()): - - ```ts - export default { - async fetch(request, env, ctx) { - const client = new Client({ - url: env.DATABASE_URL, - // see https://github.com/cloudflare/workerd/issues/698 - fetch(url, init) { - delete init['cache'] - return fetch(url, init) - }, - }) - const adapter = new PrismaPlanetScale(client) - const prisma = new PrismaClient({ adapter }) - - // ... - }, - } - ``` - -#### 1. Configure Prisma schema & database connection - -First, ensure that the database connection is configured properly. In your Prisma schema, set the `url` of the `datasource` block to the `DATABASE_URL` environment variable. You also need to enable the `driverAdapters` feature flag: - -```prisma file=schema.prisma showLineNumbers -generator client { - provider = "prisma-client-js" - previewFeatures = ["driverAdapters"] -} - -datasource db { - provider = "mysql" - url = env("DATABASE_URL") - relationMode = "prisma" // required for PlanetScale (as by default foreign keys are disabled) -} -``` - -Next, you need to set the `DATABASE_URL` environment variable to the value of your database connection string. You'll do this in a file called `.dev.vars` used by Cloudflare: - -```bash file=.dev.vars showLineNumbers -DATABASE_URL="mysql://32qxa2r7hfl3102wrccj:password@us-east.connect.psdb.cloud/demo-cf-worker-ps?sslaccept=strict" -``` - -Because the Prisma CLI by default is only compatible with `.env` files, you can adjust your `package.json` with the following script that loads the env vars from `.dev.vars`. You can then use this script to load the env vars before executing a `prisma` command. - -Add this script to your `package.json`: - -```js file=package.json highlight=5;add showLineNumbers -{ - // ... - "scripts": { - // .... - //add-next-line - "env": "dotenv -e .dev.vars" - }, - // ... -} -``` - -Now you can execute Prisma CLI commands as follows while ensuring that the command has access to the env vars in `.dev.vars`: - -```terminal -npm run env -- npx prisma -``` - -#### 2. Install dependencies - -Next, install the required packages: - -```terminal -npm install @prisma/adapter-planetscale -npm install @planetscale/database -``` - -#### 3. Migrate your database schema (if applicable) - -If you ran `npx prisma init` above, you need to migrate your database schema to create the `User` table that's defined in your Prisma schema (if you already have all the tables you need in your database, you can skip this step): - -```terminal -npm run env -- npx prisma db push -``` - -#### 4. Use Prisma Client in your Worker to send a query to the database - -Here is a sample code snippet that you can use to instantiate `PrismaClient` and send a query to your database: - -```ts -import { PrismaClient } from '@prisma/client' -import { PrismaPlanetScale } from '@prisma/adapter-planetscale' -import { Client } from '@planetscale/database' - -export default { - async fetch(request, env, ctx) { - const client = new Client({ - url: env.DATABASE_URL, - // see https://github.com/cloudflare/workerd/issues/698 - fetch(url, init) { - delete init['cache'] - return fetch(url, init) - }, - }) - const adapter = new PrismaPlanetScale(client) - const prisma = new PrismaClient({ adapter }) - - const users = await prisma.user.findMany() - const result = JSON.stringify(users) - return new Response(result) - }, -} -``` - -#### 6. Run the Worker locally - -To run the Worker locally, you can run the `wrangler dev` command: - -```terminal -npx wrangler dev -``` - -#### 7. Set the `DATABASE_URL` environment variable and deploy the Worker - -To deploy the Worker, you first need to the `DATABASE_URL` environment variable [via the `wrangler` CLI](https://developers.cloudflare.com/workers/configuration/secrets/#secrets-on-deployed-workers): - -```terminal -npx wrangler secret put DATABASE_URL -``` - -The command is interactive and will ask you to enter the value for the `DATABASE_URL` env var as the next step in the terminal. - -> **Note**: This command requires you to be authenticated, and will ask you to log in to your Cloudflare account in case you are not. - -Then you can go ahead then deploy the Worker: - -```terminal -npx wrangler deploy -``` - -The command will output the URL where you can access the deployed Worker. - -### Neon - -If you are using a Neon database, you need to: - -- use the `@prisma/adapter-neon` database adapter (via the `driverAdapters` Preview feature) - -#### 1. Configure Prisma schema & database connection - -First, ensure that the database connection is configured properly. In your Prisma schema, set the `url` of the `datasource` block to the `DATABASE_URL` environment variable. You also need to enable the `driverAdapters` feature flag: - -```prisma file=schema.prisma showLineNumbers -generator client { - provider = "prisma-client-js" - previewFeatures = ["driverAdapters"] -} - -datasource db { - provider = "postgresql" - url = env("DATABASE_URL") -} -``` - -Next, you need to set the `DATABASE_URL` environment variable to the value of your database connection string. You'll do this in a file called `.dev.vars` used by Cloudflare: - -```bash file=.dev.vars showLineNumbers -DATABASE_URL="postgresql://janedoe:password@ep-nameless-pond-a23b1mdz.eu-central-1.aws.neon.tech/neondb?sslmode=require" -``` - -Because the Prisma CLI by default is only compatible with `.env` files, you can adjust your `package.json` with the following script that loads the env vars from `.dev.vars`. You can then use this script to load the env vars before executing a `prisma` command. - -Add this script to your `package.json`: - -```js file=package.json highlight=5;add -{ - // ... - "scripts": { - // .... - //add-next-line - "env": "dotenv -e .dev.vars" - }, - // ... -} -``` - -Now you can execute Prisma CLI commands as follows while ensuring that the command has access to the env vars in `.dev.vars`: - -```terminal -npm run env -- npx prisma -``` - -#### 2. Install dependencies - -Next, install the required packages: - -```terminal -npm install @prisma/adapter-neon -npm install @neondatabase/serverless -``` - -#### 3. Migrate your database schema (if applicable) - -If you ran `npx prisma init` above, you need to migrate your database schema to create the `User` table that's defined in your Prisma schema (if you already have all the tables you need in your database, you can skip this step): - -```terminal -npm run env -- npx prisma migrate dev --name init -``` - -#### 5. Use Prisma Client in your Worker to send a query to the database - -Here is a sample code snippet that you can use to instantiate `PrismaClient` and send a query to your database: - -```ts -import { PrismaClient } from '@prisma/client' -import { PrismaNeon } from '@prisma/adapter-neon' -import { Pool } from '@neondatabase/serverless' - -export default { - async fetch(request, env, ctx) { - const neon = new Pool({ connectionString: env.DATABASE_URL }) - const adapter = new PrismaNeon(neon) - const prisma = new PrismaClient({ adapter }) - - const users = await prisma.user.findMany() - const result = JSON.stringify(users) - return new Response(result) - }, -} -``` - -#### 6. Run the Worker locally - -To run the Worker locally, you can run the `wrangler dev` command: - -```terminal -npx wrangler dev -``` - -#### 7. Set the `DATABASE_URL` environment variable and deploy the Worker - -To deploy the Worker, you first need to the `DATABASE_URL` environment variable [via the `wrangler` CLI](https://developers.cloudflare.com/workers/configuration/secrets/#secrets-on-deployed-workers): - -```terminal -npx wrangler secret put DATABASE_URL -``` - -The command is interactive and will ask you to enter the value for the `DATABASE_URL` env var as the next step in the terminal. - -> **Note**: This command requires you to be authenticated, and will ask you to log in to your Cloudflare account in case you are not. - -Then you can go ahead then deploy the Worker: - -```terminal -npx wrangler deploy -``` - -The command will output the URL where you can access the deployed Worker. - -### D1 - -[Coming soon](https://github.com/prisma/prisma/issues/13310). diff --git a/content/200-orm/300-prisma-migrate/200-understanding-prisma-migrate/600-legacy-migrate.mdx b/content/200-orm/300-prisma-migrate/200-understanding-prisma-migrate/600-legacy-migrate.mdx index 7d0c02c04f..42e90fdc81 100644 --- a/content/200-orm/300-prisma-migrate/200-understanding-prisma-migrate/600-legacy-migrate.mdx +++ b/content/200-orm/300-prisma-migrate/200-understanding-prisma-migrate/600-legacy-migrate.mdx @@ -3,7 +3,7 @@ title: 'Legacy Prisma Migrate' metaTitle: 'Legacy Prisma Migrate (Reference)' metaDescription: 'Legacy Prisma Migrate is a declarative data modeling and schema migration tool that is available via the Prisma CLI.' tocDepth: 3 -hidePage: true +unlisted: true --- diff --git a/content/300-accelerate/650-troubleshoot.mdx b/content/300-accelerate/650-troubleshoot.mdx index 409ed6ce19..972f8ace80 100644 --- a/content/300-accelerate/650-troubleshoot.mdx +++ b/content/300-accelerate/650-troubleshoot.mdx @@ -12,11 +12,11 @@ When working with Prisma Accelerate, you may encounter errors often highlighted -## `[P6009](/orm/reference/error-reference#p6009-responsesizelimitexceeded)` (`ResponseSizeLimitExceeded`) +## [`P6009`](/orm/reference/error-reference#p6009-responsesizelimitexceeded) (`ResponseSizeLimitExceeded`) This error is triggered when the response size from a database query exceeds the 5MB limit. We've implemented this restriction to safeguard your application performance, as retrieving data over 5MB can significantly slow down your application due to multiple network layers. Typically, transmitting more than 5MB of data is common when conducting ETL (Extract, Transform, Load) operations. However, for other scenarios such as transactional queries, real-time data fetching for user interfaces, bulk data updates, or aggregating large datasets for analytics outside of ETL contexts, it should generally be avoided. These use cases, while essential, can often be optimised to work within the 5MB limit, ensuring smoother performance and a better user experience. -### Possible causes for `[P6009](/orm/reference/error-reference#p6009-responsesizelimitexceeded)` +### Possible causes for [`P6009`](/orm/reference/error-reference#p6009-responsesizelimitexceeded) #### Transmitting images/files in response @@ -36,13 +36,13 @@ In many data processing workflows, especially those involving ETL (Extract-Trans **Suggested solution:** Consider splitting your query to fetch data in batches to prevent the 5MB limit from being reached. By splitting your query to retrieve data in batches, you ensure that each operation fetches only a portion of the total data volume, thereby not exceeding the size limit for a single fetch operation. -## `[P6004](/orm/reference/error-reference#p6004-querytimeout)` (`QueryTimeout`) +## [`P6004`](/orm/reference/error-reference#p6004-querytimeout) (`QueryTimeout`) This error occurs when a database query fails to return a response within 10 seconds. The 10-second limit includes the duration of waiting for a connection from the pool, network latency to the database, and the execution time of the query itself. We enforce this limit to prevent unintentional long-running queries that can overload system resources. > The time for Accelerate's cross-region networking is excluded from the 10-second limit. -### Possible causes for `[P6004](/orm/reference/error-reference#p6004-querytimeout)` +### Possible causes for [`P6004`](/orm/reference/error-reference#p6004-querytimeout) This error could be caused by numerous reasons. Some of the prominent ones are: @@ -73,7 +73,7 @@ Users often rely on CPU and memory usage metrics to gauge database load, which c Moreover, it's crucial to periodically scrutinize and refine essential queries and verify that tables are properly indexed. This proactive approach minimizes the vulnerability of these queries to slowdowns caused by competing workloads. -### Considerations for `[P6009](/orm/reference/error-reference#p6009-responsesizelimitexceeded)` and `[P6004](/orm/reference/error-reference#p6004-querytimeout)` errors +### Considerations for [`P6009`](/orm/reference/error-reference#p6009-responsesizelimitexceeded) and [`P6004`](/orm/reference/error-reference#p6004-querytimeout) errors For runtimes that support Prisma ORM natively, you could consider creating two `PrismaClient` Instances. One with the Accelerate connection string (prefixed with `prisma://`) and the other one with the direct database connection string (prefixed with `postgres://`, `mysql://` etc). The main idea behind this approach is to bypass Accelerate for certain specific queries. @@ -102,11 +102,11 @@ This setup allows you to strategically direct certain operations through the dir > Also see [**why doesn’t Accelerate fall back to the direct connection string during a service disruption?**](/accelerate/faq#why-doesnt-accelerate-fall-back-to-the-direct-connection-string-during-a-service-disruption) -## `[P6008](/orm/reference/error-reference#p6008-connectionerrorenginestarterror)` (`ConnectionError|EngineStartError`) +## [`P6008`](/orm/reference/error-reference#p6008-connectionerrorenginestarterror) (`ConnectionError|EngineStartError`) This error indicates that Prisma Accelerate cannot establish a connection to your database, potentially due to several reasons. -### Possible causes for `[P6008](/orm/reference/error-reference#p6008-connectionerrorenginestarterror)` +### Possible causes for [`P6008`](/orm/reference/error-reference#p6008-connectionerrorenginestarterror) #### Database Not Publicly accessible diff --git a/content/400-pulse/250-database-setup/100-general-database-instructions.mdx b/content/400-pulse/250-database-setup/100-general-database-instructions.mdx index f4dee6dea4..340763b869 100644 --- a/content/400-pulse/250-database-setup/100-general-database-instructions.mdx +++ b/content/400-pulse/250-database-setup/100-general-database-instructions.mdx @@ -10,11 +10,7 @@ toc: true Prepare your database to work with Pulse. - - -Prisma Pulse requires a publicly accessible PostgreSQL (**version 12+**) database with logical replication enabled. To configure specific database providers for Prisma Pulse, visit [here](/pulse/database-setup#provider-specific-instructions). - - +> Prisma Pulse requires a publicly accessible PostgreSQL (**version 12+**) database with logical replication enabled. To configure specific database providers for Prisma Pulse, visit [here](/pulse/database-setup#provider-specific-instructions). @@ -36,37 +32,29 @@ You will need to restart the database after changing this setting. ##### Optional settings -###### `[wal_keep_size](https://www.postgresql.org/docs/current/runtime-config-replication.html)` +###### [`wal_keep_size`](https://www.postgresql.org/docs/current/runtime-config-replication.html) Setting `wal_keep_size` increases the memory usage of the [write-ahead log](https://www.postgresql.org/docs/current/wal-intro.html) on your PostgreSQL database. We recommend setting a value for `wal_keep_size` tailored to your database's storage capacity. This ensures smooth operation of both your database and Prisma Pulse. - - -We suggest setting these values initially and adjusting them if necessary. - - +> We suggest setting these values initially and adjusting them if necessary. ```sql ALTER SYSTEM SET wal_keep_size = 2048; ``` -###### `[max_replication_slots](https://www.postgresql.org/docs/current/runtime-config-replication.html)` +###### [`max_replication_slots`](https://www.postgresql.org/docs/current/runtime-config-replication.html) Prisma Pulse only needs one replication slot available. You can set the `max_replication_slots` if you have other replications in use. - - -We suggest setting these values initially and adjusting them if necessary. - - +> We suggest setting these values initially and adjusting them if necessary. ```sql ALTER SYSTEM SET max_replication_slots = 20; ``` -###### `[REPLICA IDENTITY](https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY)` +###### [`REPLICA IDENTITY`](https://www.postgresql.org/docs/current/sql-altertable.html#SQL-ALTERTABLE-REPLICA-IDENTITY) To get the **before** values of **all fields** in the record for some events, you must set `REPLICA IDENTITY` to `FULL` on the table(s) you want to get field values for. If this is not configured, defining a filter for those events will only be possible on the primary key. @@ -179,8 +167,4 @@ If you are managing your replications independently and choose to disable Prisma SELECT * FROM pg_publication_tables; ``` - - -💡 To configure specific database providers for Prisma Pulse, visit [here](/pulse/database-setup#provider-specific-instructions). - - +> 💡 To configure specific database providers for Prisma Pulse, visit [here](/pulse/database-setup#provider-specific-instructions). diff --git a/content/400-pulse/250-database-setup/300-railway.mdx b/content/400-pulse/250-database-setup/300-railway.mdx index 57a907e869..f06626f51f 100644 --- a/content/400-pulse/250-database-setup/300-railway.mdx +++ b/content/400-pulse/250-database-setup/300-railway.mdx @@ -110,15 +110,15 @@ To see an event in action, you need to make changes to the `User` table. You can You can run these queries using a tool such as [pgAdmin](https://www.pgadmin.org/), [dbeaver](https://dbeaver.io/), or any other way you might run queries on your database. - - Set the `[wal_level](https://www.postgresql.org/docs/current/runtime-config-wal.html)` to `logical`: + - Set the [`wal_level`](https://www.postgresql.org/docs/current/runtime-config-wal.html) to `logical`: ```sql ALTER SYSTEM SET wal_level = logical; ``` - - Set the `[max_replication_slots](https://www.postgresql.org/docs/current/runtime-config-replication.html)` to `20`: + - Set the [`max_replication_slots`](https://www.postgresql.org/docs/current/runtime-config-replication.html) to `20`: ```sql ALTER SYSTEM SET max_replication_slots = 20; ``` - - Set the `[wal_keep_size](https://www.postgresql.org/docs/current/runtime-config-replication.html)` to `2048`: + - Set the [`wal_keep_size`](https://www.postgresql.org/docs/current/runtime-config-replication.html) to `2048`: ```sql ALTER SYSTEM SET wal_keep_size = 2048; ``` diff --git a/docusaurus.config.ts b/docusaurus.config.ts index a8d9d2ec4c..cdf99293f1 100644 --- a/docusaurus.config.ts +++ b/docusaurus.config.ts @@ -8,7 +8,7 @@ const config: Config = { favicon: 'img/favicon.png', // Set the production url of your site here - url: 'https://prisma.io', + url: 'https://www.prisma.io', // Set the // pathname under which your site is served // For GitHub pages deployment, it is often '//' baseUrl: '/',