diff --git a/.gitignore b/.gitignore index 494becda23..d815957f75 100644 --- a/.gitignore +++ b/.gitignore @@ -21,4 +21,4 @@ yarn-error.log* # wrangler project .dev.vars -.wrangler/ \ No newline at end of file +.wrangler/ diff --git a/docs/400-pulse/100-what-is-pulse.mdx b/docs/400-pulse/100-what-is-pulse.mdx new file mode 100644 index 0000000000..85b4266ea2 --- /dev/null +++ b/docs/400-pulse/100-what-is-pulse.mdx @@ -0,0 +1,21 @@ +--- +title: 'What is Pulse' +metaTitle: 'What is Pulse' +metaDescription: 'Learn about Pulse, a managed Change Data Capture service that lets you build real-time applications with ease.' +tocDepth: 3 +toc: true +--- + + + +[Pulse](https://www.prisma.io/data-platform/pulse) is a managed [change data capture (CDC)](https://en.wikipedia.org/wiki/Change_data_capture) service that captures change events from your database and delivers them instantly to your applications. With Pulse, you can quickly build real-time applications in a type-safe manner using [Prisma Client](/orm/prisma-client). + + + +Pulse is currently in [Early Access](/platform/maturity-levels#early-access). Although we already have high confidence in it, the nature of an Early Access product is that significant iterations might happen at any time. Therefore, we advise against using it in a system that requires stability.

+ +We strongly recommend evaluating Pulse with a dedicated database instance that is exclusively used for Pulse and where downtime and data loss would be acceptable. Prisma assumes no responsibility for downtime or data loss. + + + + diff --git a/docs/400-pulse/200-getting-started.mdx b/docs/400-pulse/200-getting-started.mdx new file mode 100644 index 0000000000..f63608c33a --- /dev/null +++ b/docs/400-pulse/200-getting-started.mdx @@ -0,0 +1,209 @@ +--- +title: 'Getting started' +metaTitle: 'Getting started with Pulse' +metaDescription: 'Learn how to get up and running with Pulse.' +tocDepth: 3 +toc: true +--- + + + +## Prerequisites + +To participate in Pulse's Early Access program, you need to meet the following prerequisites: + +- A GitHub account. +- Pulse requires [Prisma Client](/orm/prisma-client) version `4.16.1` or higher and [`@prisma/extension-pulse`](https://www.npmjs.com/package/@prisma/extension-pulse) version `v0.2.1` or higher. +- A publicly accessible PostgreSQL database. +- Ability to use the superuser account of the database instance. In the future, we will support the ability to connect to your database from Pulse with a limited access, non-superuser account. + +You will also need a database with the following configurations: + +- PostgreSQL version 12+. +- Ensure your database is publicly accessible. +- [Set the `wal_level` setting in PostgreSQL to `logical`](/pulse/getting-started#wal_level). +- A database superuser that can be used for connections inside Pulse. +- Connect to the database using `sslmode=disable` if the database provider uses self-signed certificates. + +## 1. Database setup + +### General database configuration + +#### Required settings + +##### [wal_level](https://www.postgresql.org/docs/current/runtime-config-wal.html) + +Some providers may not allow direct access to this setting. If you are unable to change this setting, please refer to the provider-specific guides for further assistance. + +```sql +ALTER SYSTEM SET wal_level = logical; +``` + +You will need to restart the database after changing this setting. + +#### Optional settings + +The following increases the memory usage of the [write-ahead log](https://www.postgresql.org/docs/current/wal-intro.html) on your PostgreSQL database. We suggest setting these values initially and adjusting them if necessary. + +##### [max_replication_slots](https://www.postgresql.org/docs/current/runtime-config-replication.html) + +```sql +ALTER SYSTEM SET max_replication_slots = 20; +``` + +##### [wal_keep_size](https://www.postgresql.org/docs/current/runtime-config-replication.html) + +```sql +ALTER SYSTEM SET wal_keep_size = 2048; +``` + +### Provider specific configuration + +To learn about the database providers that Pulse supports, visit [here](/pulse/faq#what-database-providers-are-supported-with-pulse). + +#### Railway + +[Railway.app](https://railway.app) offers an excellent [templates feature](https://railway.app/templates). If you wish to quickly start with Pulse, you can use either of two templates: + +- [Prisma Pulse DB Only](https://railway.app/template/pulse-pg): Provides a fresh, pre-configured PostgreSQL database which you can use with Pulse. +- [Prisma Pulse DB & App](https://railway.app/template/pulse-starter): Provides a pre-configured PostgreSQL database and a [Pulse starter app](https://github.com/prisma/pulse-starter). + +##### Setup without using a template + +
+1. Change the PostgreSQL database settings + +You can run these queries in the Railway Database **Query** tab, using the [railway cli](https://docs.railway.app/databases/postgresql), or any other way you might run queries on your database. + +1. Drop the Timescale extension: + +```sql +DROP EXTENSION timescaledb; +``` + +2. Set the [wal_level](https://www.postgresql.org/docs/current/runtime-config-wal.html) to `logical`: + +```sql +ALTER SYSTEM SET wal_level = logical; +``` + +3. 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; +``` + +4. 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; +``` + +5. Reload the PostgreSQL configuration: + +```sql +SELECT pg_reload_conf(); +``` + +
+
+2. Restart your database + +1. Click on your database. + +2. Navigate to the Deployments tab. + +3. Go into the three-dots menu on the latest deployment and click the `Restart` option. + +
+ +##### SSL mode + +As Railway uses a self-signed certificate, you have to use [`sslmode=disable`](/orm/overview/databases/postgresql#configuring-an-ssl-connection) with Pulse. + +## 2. Enable Pulse in a project + +Log into the [Prisma Data Platform](https://console.prisma.io/login), create a new project and enable Pulse for that new project. + +> An API key will be created after you enable and setup Pulse in your [project](/platform/concepts/projects). + +## 3. Use Pulse in your application + + + +We have created an [example repository](https://github.com/prisma/pulse-starter) on GitHub to help you get started using Pulse. If you would like to start there, you can do so. + + + +The following will show how you can utilize Pulse in an existing application. We will be adding Pulse to the [hello-prisma](/getting-started/setup-prisma/start-from-scratch/relational-databases-typescript-postgresql) example from our documentation. + +### 3.1. Install the Pulse Prisma Client extension + +In a project using [Prisma Client](/orm/prisma-client), run the following command to install the Pulse extension: + +```terminal +npm install @prisma/extension-pulse +``` + +### Store your Pulse API key in your .env file + +The Pulse extension requires you to use an API key. + + + +You should have received an API key when you added Prisma Pulse to your project in the Platform Console. + + + +In `.env`, add a variable named `PULSE_API_KEY`: + +```env file=.env +PULSE_API_KEY="YOUR-API-KEY" + +# Example: +# PULSE_API_KEY="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhcGlfa2V5IjoiNGMxNzM0MGItMmFhYy00MGMxLWE1ZDctNzYyNmRjNjg3NjM4IiwidGVuYW50X2lkIjoiY2VhZjE0NThkZGUyYzJmNTU0ZmNkNTI2MmFmOWY1ODljMWJiZmRhNDU0N2UxMjM1ODk3MGQ2MGI1ZjRlNTU0OCIsImludGVybmFsX3NlY3JldCI6ImM1ZTcxYjJhLTE0NzdawdwDliZS1hM2IzLTczODFkNDM5ZmEwZSJ9.wCUlghC_suFBr2vnk0q_5I8iRNRDyEQo0W9rnhf6mCw" +``` + +### 3.2. Create a Pulse-enabled Prisma Client + +To use Pulse, you must extend Prisma Client with the Pulse extension. +Add the following to extend your existing Prisma Client instance with the Pulse extension: + +```ts +import { PrismaClient } from '@prisma/client' +import { withPulse } from '@prisma/extension-pulse' + +const prisma = new PrismaClient().$extends( + withPulse({ apiKey: process.env.PULSE_API_KEY }) +) +``` + +### 3.3. Create your first Pulse subscription + +With the Pulse extension applied, you may now use Pulse's `subscribe()` method on any model defined in your Prisma Schema to subscribe to data change events. + +In the example below, a subscription is made on a `user` table that listens for _any_ change event on that table: + +```ts +const prisma = new PrismaClient().$extends(withPulse({ apiKey: apiKey })) + +async function main() { + const subscription = await prisma.user.subscribe({}) + + if (subscription instanceof Error) { + throw subscription + } + + for await (const event of subscription) { + console.log('just received an event:', event) + } +} + +main() +``` + + + +Refer to the [API Reference](/pulse/api-reference) section for more detail on the filtering options available to the `subscribe()` method. + + diff --git a/docs/400-pulse/300-concepts.mdx b/docs/400-pulse/300-concepts.mdx new file mode 100644 index 0000000000..022f04ee44 --- /dev/null +++ b/docs/400-pulse/300-concepts.mdx @@ -0,0 +1,23 @@ +--- +title: 'Concepts' +metaTitle: 'Pulse: Concepts' +metaDescription: 'Learn about the concepts that are important to understand when using Pulse.' +tocDepth: 3 +toc: true +--- + + + +## Change data capture + +[Change data capture (CDC)](https://en.wikipedia.org/wiki/Change_data_capture) is a technique used to track and capture changes in a database enabling real-time updates. It allows applications to be informed about the modifications in the database, ensuring data consistency between multiple applications. + +## Logical replication + +Logical replication is a method of replicating data objects and their changes based on their replication identity (usually a primary key). You can read more about logical replication and how it pertains to your database in Postgres' documentation [here](https://www.postgresql.org/docs/current/logical-replication.html). + +## Write-ahead log + +A [write-ahead log (WAL)](https://www.postgresql.org/docs/current/wal-intro.html) is a standard way of ensuring data integrity by only allowing updates to the data in a database _after_ a log has been written to permanent storage describing the change to take place. + +This enhances data integrity because all changes to a database are recorded in these log files. In the event of a database crash, the database is recoverable using those logs and can even be recovered to a specific point in time. diff --git a/docs/400-pulse/400-api-reference.mdx b/docs/400-pulse/400-api-reference.mdx new file mode 100644 index 0000000000..c6a3246039 --- /dev/null +++ b/docs/400-pulse/400-api-reference.mdx @@ -0,0 +1,287 @@ +--- +title: 'API Reference' +metaTitle: 'Pulse: API Reference' +metaDescription: 'API reference documentation for Pulse.' +tocDepth: 4 +toc: true +--- + + + +The Pulse API reference documentation is based on the following schema: + +```prisma +model User { + id Int @id @default(autoincrement()) + name String? + email String @unique +} +``` + +All example are based on the `User` model. + + + +## subscribe + +`subscribe` returns all data change events related to the table you call this method on: + +```ts +const subscription = await prisma.user.subscribe() +``` + +### Remarks + +Passing an empty object to the `subscribe` function will also behaves the same as passing no argument to the function: + +```ts +const subscription = await prisma.user.subscribe({}) +``` + +### Database event filters + +Inside of the `subscribe()` method you can use filters to get specific events and data. The three filter options currently supported are described below: + +#### create + +You can use the `create` filter to retrieve all _create_ events on a table. A create event is triggered when a new record is created in a table. + +Pulse returns the values of the new record as an object named `after`. + +##### Example + + + + +```ts +const subscription = await prisma.user.subscribe({ + create: {}, +}) +``` + + + + +```ts no-copy +{ + action: 'create', + after: { + id: 1, + email: 'marc@prisma.io', + name: 'Marc' + } +} +``` + + + + +#### update + +You can use the `update` filter to retrieve all _update_ events on a table. An update event is triggered when a value in a database record has changed. + +Pulse returns the values of the changed record as an object named `after`. This represents the state of the record _after_ the change event. + +##### Example + + + + +```ts +const subscription = await prisma.user.subscribe({ + update: {}, +}) +``` + + + + +```ts no-copy +{ + action: 'update', + after: { + id: 1, + email: 'updated@prisma.io', + name: 'Marc' + } +} +``` + + + + +#### delete + +You can use the `delete` filter to retrieve all _delete_ events on a table. A delete event is triggered when a record has been removed from the database. + +Pulse returns the values of the changed record as an object named `before`. This represents the state of the record _before_ the change event. + +##### Example + + + + +```ts +const subscription = await prisma.user.subscribe({ + delete: {}, +}) +``` + + + + +```ts no-copy +{ + action: 'delete', + before: { + id: 1, + email: '', + name: null + } +} +``` + + + + + + +By default, the response for `delete` events will only return the primary key of the record. To get the _before_ values of all fields in the record, 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 deletes will only be possible on the primary key.

+For example, running the following SQL command will set the `REPLICA IDENTITY` to `FULL` on a table named `User`: + +```sql +ALTER TABLE public."User" REPLICA IDENTITY FULL; +``` + + + +### Filter conditions and operators + +Pulse allows you to subscribe to change events based on filter conditions and operators. Pulse supports all of Prisma Client’s [supported filter conditions and operators](/orm/reference/prisma-client-reference#filter-conditions-and-operators) except for `search` and `mode`. You also won't be able to define filters that reference other models via relations. + +You must wrap your filter criteria inside a `before` or `after` object depending on the type of event your subscription is listening for: + +- `before`: `delete` events +- `after`: `create` and `update` events + +This makes it explicit that the specified filter criteria apply to the `before` or `after` state of the change event. + + + +In the future, Pulse may support the ability to return both the `before` and `after` state of `update` change events and filter on either state. If these are features you’re interested in, please let us know on the [#pulse-feedback](https://prisma.slack.com/archives/C058GKE3C1E) channel in our community Slack. + + + +#### Usage in the after state filter + +Using a filter inside of `after` will return changed records that match your filter criteria as applied to the state of the record after the change event. + +##### Examples + +Get `create` events where the value of name is equal to `'Jim'` after the event has occurred: + + + + +```ts +const subscription = await prisma.user.subscribe({ + create: { + after: { + name: 'Jim', + }, + }, +}) +``` + + + + +```ts no-copy +{ + action: 'create', + after: { + id: 6, + email: 'test@test.com', + name: 'Jim' + } +} +``` + + + + +Get `update` events where the value of name is equal to `Jim` after the event has occurred: + + + + +```ts +const subscription = await prisma.user.subscribe({ + update: { + after: { + name: 'Jim', + }, + }, +}) +``` + + + + +```ts no-copy +{ + action: 'update', + after: { + id: 6, + email: 'updated@test.com', + name: 'Jim', + } +} +``` + + + + +#### Usage in the before state filter + +Using a filter inside of `before` will return changed records that match your filter criteria as applied to the state of the record before the change event. + +##### Example + +Get delete events where the value of name was equal to Marc. + + + + +```ts +const subscription = await prisma.user.subscribe({ + delete: { + before: { + name: 'Jim', + }, + }, +}) +``` + + + + +```ts no-copy +{ + action: 'update', + after: { + id: 6, + email: 'updated@test.com', + name: 'Jim', + } +} +``` + + + + + + +Specifying a filter condition for delete events only works if you’ve set the table’s `REPLICA IDENTITY` to `FULL`. See [this section](/pulse/api-reference#delete) for more details. + + diff --git a/docs/400-pulse/500-current-limitations.mdx b/docs/400-pulse/500-current-limitations.mdx new file mode 100644 index 0000000000..832685c361 --- /dev/null +++ b/docs/400-pulse/500-current-limitations.mdx @@ -0,0 +1,63 @@ +--- +title: 'Current limitations' +metaTitle: 'Pulse: Current limitations' +metaDescription: 'Learn about current limitations of Pulse.' +tocDepth: 3 +toc: true +--- + + + +Below are descriptions of known limitations when using Pulse. If you are aware of any limitations that are missing, please let us know on the [#pulse-feedback](https://prisma.slack.com/archives/C058GKE3C1E) channel in our community Slack. + + + +## Superuser account required + +You must connect to your database instance from Pulse using a superuser account. In the future, we will enable non-superuser accounts with limited access privileges to be used with Pulse. + +## Limited throughput of change events + +While in Early Access, there may be limits to the throughput of change events that can be captured and delivered. We plan to provide transparent scale-up capabilities in the future. + +## Limited to 10 active subscriptions per table + +Initially you will be limited to 10 active subscriptions per table. This limitation will be lifted in the future. + +## Change events are not persisted + +Pulse does not persist change events and does not provide delivery guarantees with regards to ordering or exact-once/at-least-once delivery. + +An application must maintain an active connection to Pulse using the `subscribe()` method to capture change events; change events that occur while a Prisma Client is not subscribed will not be delivered. + +## Front-end use is not possible + +Pulse cannot be used in the front-end portion of an application. + + + +If you would find this capability valuable, please share your thoughts on the[#pulse-feedback](https://prisma.slack.com/archives/C058GKE3C1E) channel on our community Slack. + + + +## Limited to Postgres versions 12 or higher + +Pulse is currently supported with Postgres versions 12 or higher. It should work with most Postgres providers that expose Postgres’ native logical replication feature. We plan on adding support for MySQL in our GA release. + + + +If you have questions about whether your database is supported, please reach out to us on the [#pulse-feedback](https://prisma.slack.com/archives/C058GKE3C1E) channel on our community Slack. + + + +## Pulse will not attempt a reconnect or give an indication of the network is disconnected + +Currently, if there is some type of network disconnect while Prisma Client is subscribed to Pulse, there will be no attempts to reconnect or indicate the connection has dropped. + +For example, if you are evaluating Pulse from an application running on your laptop and it goes to sleep resulting in a network disruption, it can appear as though the Prisma Client instance is still subscribed to Pulse when it is not. + +We will soon add heart-beating capability that throws an error to the Prisma Client when the connection is no longer active so the application can reconnect. + +## Self-signed certificates are not supported yet + +Prisma Pulse is not compatible with self-signed certificates yet. Cloud providers using these certificates will only work if the [`sslmode`](/orm/overview/databases/postgresql#configuring-an-ssl-connection) is set to `sslmode=disable`. Pulse works with any certificate provided the `sslmode` is set to `disable`. diff --git a/docs/400-pulse/600-faq.mdx b/docs/400-pulse/600-faq.mdx new file mode 100644 index 0000000000..7cde2af090 --- /dev/null +++ b/docs/400-pulse/600-faq.mdx @@ -0,0 +1,48 @@ +--- +title: 'FAQ' +metaTitle: 'Pulse: FAQ' +metaDescription: 'Frequently asked questions about Pulse.' +tocDepth: 3 +toc: true +--- + +Below are frequently asked questions about Pulse. + +## Does Pulse work in a serverless environment? + +Pulse will natively support serverless environments soon after it launches to [General Availability](/platform/maturity-levels#general-availability). + +While in [Early Access](/platform/maturity-levels#early-access), Pulse works best when it is able to maintain a long-running active connection with your application. However, many serverless runtime providers limit the duration of serverless functions. We’re actively working on improving the experience in serverless applications. + + + +Please reach out to us on the [#pulse-feedback](https://prisma.slack.com/archives/C058GKE3C1E) channel on our community Slack if having a more native serverless approach to getting data change events is important to you. + + + +## How does Pulse handle schema changes in the database? + +Pulse is designed to work seamlessly with schema changes in your database by utilizing [Change data capture (CDC)](https://en.wikipedia.org/wiki/Change_data_capture) techniques and combining that with the power of schema-driven data access using [Prisma Client](/orm/prisma-client). When your Prisma schema is updated, Pulse automatically adapts to the changes, ensuring that your real-time data synchronization remains consistent and reliable. + +Pulse leverages the type information generated by Prisma to create type-safe database subscriptions, allowing you to catch potential issues at compile time and maintain the integrity of your data throughout the development process. This approach allows Pulse to efficiently capture and propagate data changes while maintaining compatibility with evolving database structures. + +## What databases are supported with Pulse? + +The Pulse Early Access release supports PostgreSQL with plans to extend support to MySQL in the near future. + +Pulse primarily interfaces with a database's write-ahead log (Postgres) or binlog (MySQL) to efficiently capture data change events, offering a more performant solution than regular polling through scheduled queries. Note that Pulse may not work with every Postgres-compatible database, as compatibility depends on the exposure of Postgres-native logical replication capabilities required for change data capture. + + + +Pulse’s database compatibility list will be different from Prisma Client's database compatibility list. If you want to use Pulse with an existing Prisma application, please verify the database and hosting provider are supported by Pulse. + + + +## What database providers are supported with Pulse? + +| Provider | Support | Notes | +| -------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| Railway | ✅ | Requires [`sslmode=disable`](/orm/overview/databases/postgresql#configuring-an-ssl-connection) due to the use of a self-signed certificate for database connections by Railway. | +| Supabase | ✅ | Requires [`sslmode=disable`](/orm/overview/databases/postgresql#configuring-an-ssl-connection) due to the use of a self-signed certificate for database connections by Supabase. | +| Neon | _Coming_ | Support details coming soon. | +| AWS RDS | _Coming_ | Support details coming soon. | diff --git a/docs/400-pulse/700-feedback.mdx b/docs/400-pulse/700-feedback.mdx new file mode 100644 index 0000000000..defdda8d95 --- /dev/null +++ b/docs/400-pulse/700-feedback.mdx @@ -0,0 +1,13 @@ +--- +title: 'Feedback' +metaTitle: 'Pulse: Feedback' +metaDescription: 'Learn where to submit feedback about Pulse.' +tocDepth: 3 +toc: true +--- + + + +You can submit any feedback about Pulse in the [#pulse-feedback](https://prisma.slack.com/archives/C058GKE3C1E) channel in our community Slack. + + diff --git a/docs/400-pulse/index.mdx b/docs/400-pulse/index.mdx new file mode 100644 index 0000000000..c8072bcb67 --- /dev/null +++ b/docs/400-pulse/index.mdx @@ -0,0 +1,17 @@ +--- +title: 'Pulse' +metaTitle: 'Prisma Pulse' +metaDescription: 'Prisma Pulse enables real-time database events with type-safe Prisma Client subscriptions.' +toc: false +earlyaccess: true +--- + + + +[Prisma Pulse](https://www.prisma.io/data-platform/pulse) enables real-time database events with type-safe Prisma Client subscriptions. + + + +## In this section + + diff --git a/docs/500-platform/10-about.mdx b/docs/500-platform/10-about.mdx new file mode 100644 index 0000000000..430005b288 --- /dev/null +++ b/docs/500-platform/10-about.mdx @@ -0,0 +1,16 @@ +--- +title: 'About' +metaTitle: 'Platform Console: About' +metaDescription: '' +--- + + + +Platform Console enables you to integrate the latest Prisma Data Platform products into your application + +- [Accelerate](/accelerate/what-is-accelerate): Global database cache with scalable connection pooling +- [Pulse](/pulse/what-is-pulse): A managed Change Data Capture (CDC) service that enables real-time database subscriptions + +[Launch Platform Console](https://console.prisma.io) + + diff --git a/docs/500-platform/20-concepts/10-workspaces.mdx b/docs/500-platform/20-concepts/10-workspaces.mdx new file mode 100644 index 0000000000..910b3f6f04 --- /dev/null +++ b/docs/500-platform/20-concepts/10-workspaces.mdx @@ -0,0 +1,19 @@ +--- +title: 'Workspaces' +metaTitle: 'Platform Console: Workspaces' +metaDescription: 'Learn how to manage workspaces via Platform Console.' +tocDepth: 3 +toc: true +--- + + + +Workspaces provide a unified space for team collaboration on projects. Manage membership and billing directly within each Workspace. + + + +## Billing + +For your Workspace, you can choose a subscription plan that aligns closely with your requirements. Every project within a Workspace adds to the collective usage, ensuring a holistic view of consumption. + +More details on our subscription plans will be available soon. diff --git a/docs/500-platform/20-concepts/20-projects.mdx b/docs/500-platform/20-concepts/20-projects.mdx new file mode 100644 index 0000000000..7af0f03a13 --- /dev/null +++ b/docs/500-platform/20-concepts/20-projects.mdx @@ -0,0 +1,17 @@ +--- +title: 'Projects' +metaTitle: 'Platform Console: Projects' +metaDescription: 'Learn how to manage projects via Platform Console.' +tocDepth: 3 +toc: true +--- + + + +Projects embody your applications integrated with our products. Each project is associated with a Workspace and can be configured independently from one another. + + + +## API Keys + +A project API key is required to authenticate requests from your Prisma Client to products such as Accelerate and Pulse. You may generate multiple API keys per project and manage those via the **Settings** tab of a project's page. diff --git a/docs/500-platform/20-concepts/index.mdx b/docs/500-platform/20-concepts/index.mdx new file mode 100644 index 0000000000..2e62e7a25e --- /dev/null +++ b/docs/500-platform/20-concepts/index.mdx @@ -0,0 +1,14 @@ +--- +title: 'Concepts' +metaTitle: 'Platform Console: Concepts' +metaDescription: '' +tocDepth: 4 +--- + + + +Learn about the main building blocks of Platform Console, such as workspaces, projects, and billing. + + + + diff --git a/docs/500-platform/30-maturity-levels.mdx b/docs/500-platform/30-maturity-levels.mdx new file mode 100644 index 0000000000..e878bf221a --- /dev/null +++ b/docs/500-platform/30-maturity-levels.mdx @@ -0,0 +1,43 @@ +--- +title: 'Maturity levels' +metaTitle: 'Platform Console: Maturity levels' +metaDescription: '' +--- + + + +Prisma releases updates to Prisma Data Platform multiple times per week, as opposed to the Prisma ORM that we release on a set schedule every few weeks. This is why we consider the lifecycle and process for maturing features in Prisma Data Platform differently. + +You can [check out the releases and maturity process for the Prisma ORM](/orm/more/releases) for further details. + + + +## + +### Early Access + +If a feature on the Prisma Data Platform is labeled as **Early Access**: + +- We have validated a problem and are considering a solution to it but are not certain whether that solution is complete or a perfect fit. +- We want to gather more feedback and adjust the solution as necessary, knowing that users are prepared for significant breaking changes +- We reserve ourselves the right to throttle or remove access to a feature in Early Access to preserve the stability of the platform, or enforcing its use to stay within the scope defined in our [Terms of Service](https://pris.ly/privacy). + +As always, your feedback in our [Slack](https://slack.prisma.io/) or [Discord](https://pris.ly/discord) is invaluable to shape the design of the features. This will help us ensure that they can solve your problems in the best way possible. + +### Preview + +If a feature on the Prisma Data Platform is labeled as **Preview**: + +- We have refined the software based on the valuable feedback we obtained during the Early Access phase. +- We developed the feature further, bringing it closer to the final version, though it's not completely ready for production usage. +- We have lifted the invite gate, so users no longer need an invitation to access the feature. Users just need to sign up to gain access. +- We have increased the stability of the software compared to the Early Access phase. While there might still be some issues, they should be less frequent and less critical. +- We use the Preview phase as a final stress test to ensure the product is ready for heavy production workloads. + +We recommend testing the product in a staging environment and welcome any feedback in our [Slack](https://slack.prisma.io/) or [Discord](https://pris.ly/discord). This will assist us in improving the product for its final release. + +### General Availability + +If a feature in the Prisma Data Platform is Generally Available: + +- The solution has undergone extensive testing and, based on significant feedback, is deemed stable and ready for production use cases. diff --git a/docs/500-platform/40-limits.mdx b/docs/500-platform/40-limits.mdx new file mode 100644 index 0000000000..888e642bd0 --- /dev/null +++ b/docs/500-platform/40-limits.mdx @@ -0,0 +1,12 @@ +--- +title: 'Limits' +metaTitle: 'Platform Console: Limits' +tocDepth: 3 +toc: true +--- + + + +More details on limits will be available soon. + + diff --git a/docs/500-platform/50-support.mdx b/docs/500-platform/50-support.mdx new file mode 100644 index 0000000000..d058d632d7 --- /dev/null +++ b/docs/500-platform/50-support.mdx @@ -0,0 +1,31 @@ +--- +title: 'Support' +metaTitle: 'Platform console: Support' +metaDescription: '' +tocDepth: 3 +toc: true +--- + + + +Your feedback is invaluable, and we encourage you to share your experiences with us on [Discord](https://pris.ly/discord). + + + +### Community Support + +Reach out to us in our [Discord](https://pris.ly/discord). + +### Standard Support + +- Email support, support@prisma.io +- Mon-Fri, 9am-5pm CET + +### Premium Support + +- Email support, support@prisma.io +- 24/7 + +### Dedicated Support + +Dedicated contact person. diff --git a/docs/500-platform/index.mdx b/docs/500-platform/index.mdx new file mode 100644 index 0000000000..05c12f5fc3 --- /dev/null +++ b/docs/500-platform/index.mdx @@ -0,0 +1,17 @@ +--- +title: 'Platform' +metaTitle: 'Platform' +metaDescription: 'Get started with the Prisma Data Platform with its official documentation, and learn more about its features with reference documentation, guides, and more.' +toc: false +# earlyaccess: false +--- + + + +Learn about the main concepts and workflows of the [Prisma Data Platform](https://prisma.io/data-platform/). + + + +## In this section + +