Merge branch 'beta' into alpha

Author: mavilein

README.md

@@ -1,4 +1,4 @@
-<p align="center"><a href="https://www.prisma.io"><img src="https://i.imgur.com/wD4rVt4.png" alt="Prisma" height="160px"></a></p>
+<p align="center"><a href="https://www.prisma.io"><img src="https://i.imgur.com/QgwDieO.png" alt="Prisma" height="230px"></a></p>
 
 [Website](https://www.prisma.io) • [Docs](https://www.prisma.io/docs/) • [Blog](https://www.prisma.io/blog) • [Forum](https://www.prisma.io/forum) • [Slack](https://slack.prisma.io/) • [Twitter](https://twitter.com/prisma) • [OSS](https://oss.prisma.io/) • [Learn](https://www.howtographql.com)
 

ROADMAP.md

@@ -12,23 +12,20 @@ The following lists represent a number of smaller-scope issues and improvements
 
 #### Improvements
 
-- [Unstable tie breaking for cursor based pagination #3258](https://github.com/prisma/prisma/issues/3258)
-- [Nested upsert in create mutations (correct: nested connectOrCreate) #2194](https://github.com/prisma/prisma/issues/2194)
-- [Use sensible migration values for existing nodes when adding required fields #2323](https://github.com/prisma/prisma/issues/2323)
-- [Allow for custom IDs to be submitted in a create-mutation #3839](https://github.com/prisma/prisma/issues/3839)
-- [Support cascading delete with deleteMany #1936](https://github.com/prisma/prisma/issues/1936)
-- [[Mongo] improve relational link design to enhance performance #3754](https://github.com/prisma/prisma/issues/3754)
-- [Add inner connection fields #1780](https://github.com/prisma/prisma/issues/1780)
-- [Order by multiple fields #62](https://github.com/prisma/prisma/issues/62)
+- [ ] [Nested upsert in create mutations (correct: nested connectOrCreate) #2194](https://github.com/prisma/prisma/issues/2194)
+- [ ] [Use sensible migration values for existing nodes when adding required fields #2323](https://github.com/prisma/prisma/issues/2323)
+- [ ] [Allow for custom IDs to be submitted in a create-mutation #3839](https://github.com/prisma/prisma/issues/3839)
+- [ ] [Support cascading delete with deleteMany #1936](https://github.com/prisma/prisma/issues/1936)
+- [ ] [[Mongo] improve relational link design to enhance performance #3754](https://github.com/prisma/prisma/issues/3754)
+- [ ] [Add inner connection fields #1780](https://github.com/prisma/prisma/issues/1780)
+- [ ] [Order by multiple fields #62](https://github.com/prisma/prisma/issues/62)
 
 #### Bug fixes
 
-- [Updating Scalar List Values of a Node does not trigger a change of the updatedAt value of a Node #2053](https://github.com/prisma/prisma/issues/2053)
-- [Export import fails #3183](https://github.com/prisma/prisma/issues/3183)
-- [Introspect postgres: "Could not connect to database. Prisma Config doesn't have any database connection" #3136](https://github.com/prisma/prisma/issues/3136)
-- [SDL declare order with relation. #3698](https://github.com/prisma/prisma/issues/3698)
-- [Unstable tie breaking for cursor based pagination #3258](https://github.com/prisma/prisma/issues/3258)
-- [Multiple pgRelation on connect mutation #3041](https://github.com/prisma/prisma/issues/3041)
+- [x] [Updating Scalar List Values of a Node does not trigger a change of the updatedAt value of a Node #2053](https://github.com/prisma/prisma/issues/2053)
+- [x] [Unstable tie breaking for cursor based pagination #3258](https://github.com/prisma/prisma/issues/3258)
+- [ ] [Export import fails #3183](https://github.com/prisma/prisma/issues/3183)
+- [ ] [Introspect postgres: "Could not connect to database. Prisma Config doesn't have any database connection" #3136](https://github.com/prisma/prisma/issues/3136)
 
 ### Specification phase
 
@@ -59,4 +56,4 @@ While the following features are currently not listed in the `Q1/Q2 2019`-sectio
 - Observability & monitoring
 - Caching
 - Subscriptions & clustering
-- Query analytics
+- Query analytics

cli/packages/prisma-cli-engine/src/Client/Client.ts

@@ -114,15 +114,18 @@ export class Client {
             ) {
               if (!process.env.PRISMA_MANAGEMENT_API_SECRET) {
                 throw new Error(
-                  `Server at ${
-                    this.env.activeCluster.baseUrl
-                  } requires a cluster secret. Please provide it with the env var PRISMA_MANAGEMENT_API_SECRET`,
+                  `Server at ${chalk.bold(
+                    this.env.activeCluster.name
+                  )
+                  } requires the Management API secret. Please set the the ${chalk.bold('PRISMA_MANAGEMENT_API_SECRET')} environment variable.
+
+                  Learn more about this error in the docs: https://bit.ly/authentication-and-security-docs`,
                 )
               } else {
                 throw new Error(
-                  `Cluster secret in env var PRISMA_MANAGEMENT_API_SECRET does not match for cluster ${
-                    this.env.activeCluster.name
-                  }`,
+                  `Can not authenticate against Prisma server. It seems that your ${chalk.bold('PRISMA_MANAGEMENT_API_SECRET')} environment variable is set incorrectly. Please make sure that it matches the value that was used when the Prisma server was deployed.
+
+                  For more info visit: https://bit.ly/authentication-and-security-docs`,
                 )
               }
             }

cli/packages/prisma-cli-engine/src/commands/help.ts

@@ -97,7 +97,7 @@ export default class Help extends Command {
     offset: number = 1,
   ) {
     const color = this.out.color
-    this.out.log(`\nGraphQL Database Gateway (${chalk.underline(
+    this.out.log(`\nPrisma replaces traditional ORMs (${chalk.underline(
       'https://www.prisma.io',
     )})
     

docs/1.27/datamodel-and-migrations/datamodel-MONGO-knun.mdx

@@ -18,7 +18,7 @@ The datamodel of your service configuration has two major roles:
 - **Define the underlying database schema** (the defined models are mapped to MonogDB [collections](https://docs.mongodb.com/manual/reference/glossary/#term-collection)).
 - It is the foundation for the **auto-generated CRUD and realtime operations** of your Prisma API. [Learn more](#data-model-vs-prisma-graphql-schema).
 
-The datamodel is written in the GraphQL [Schema Definition Language](https://www.prisma.io/blog/graphql-sdl-schema-definition-language-6755bcb9ce51/) (SDL) and stored in one or more [`.prisma`-files](#files). These `.prisma`-files need to be referenced in your [1](5cy7) under the `datamodel` property. For example:
+The datamodel is written using a subset of the GraphQL [Schema Definition Language](https://www.prisma.io/blog/graphql-sdl-schema-definition-language-6755bcb9ce51/) (SDL) and stored in one or more [`.prisma`-files](#files). These `.prisma`-files need to be referenced in your [1](5cy7) under the `datamodel` property. For example:
 
 <Code lines="2">
 
@@ -33,21 +33,10 @@ datamodel: datamodel.prisma
 
 There are several available building blocks to shape your datamodel.
 
-- [**Types**](#object-types) consist of multiple [fields](#fields) and typically represent entities from your application domain (e.g. `User`, `Car`, `Order`). Each non-embedded type in your datamodel is mapped to a MongoDB collection and CRUD operations are added to the GraphQL schema.
+- [**Types**](#object-types) consist of multiple [fields](#fields) and typically represent entities from your application domain (e.g. `User`, `Car`, `Order`). Each non-embedded type in your datamodel is mapped to a MongoDB collection and CRUD operations are exposed in the generated Prisam client API.
 - [**Relations**](#relations) describe _relationships_ between types. With MongoDB, a relation can be modeled as an [embedded type](#embedded-types) or as [link relation](#link-relations).
 - [**Directives**](#graphql-directives) covering different use cases such as type constraints or cascading delete behaviour.
 
-### Why SDL?
-
-The main reason why SDL is used for data modeling is twofold:
-
-- SDL is an **intuitive, simple and concise** way to express type definitions and therefore contributes to a **great developer experience**.
-- Using GraphQL SDL to define models that are used as foundation for a GraphQL API is an **idiomatic** approach.
-
-There is no hard technical requirement that would dictate the use of SDL and Prisma might allow for other approaches to provide model definitions in the future.
-
-> To learn more about the SDL, you can check out the official [GraphQL documentation](http://graphql.org/learn/schema/#type-language) or read the actual [specification](http://facebook.github.io/graphql/draft/#sec-Type-System).
-
 ## Example
 
 A simple example `datamodel.prisma` file:
@@ -132,62 +121,11 @@ Applying changes... (22/22)
 Applying changes... 0.4s
 ```
 
-## Datamodel vs Prisma GraphQL schema
-
-When starting out with GraphQL and Prisma, the amount of SDL-files you're working with can be confusing. Yet, it's crucial to understand what the role of each of them is.
-
-Looking only at Prisma, there are two SDL-files that are relevant:
-
-- The **datamodel** containing the _model definitions_ for your Prisma APIs, typically called `datamodel.prisma`.
-- The **Prisma GraphQL schema** defining the actual CRUD/realtime _operations_ of the service's API, typically called `prisma.graphql`.
-
-The Prisma database database schema is generated based on the datamodel:
-
-![](https://i.imgur.com/jHkNjKU.png)
-
-The illustration shows a simplified version of the generated Prisma GraphQL schema, you can find the full schema [here](https://gist.github.com/gc-codesnippets/f302c104f2806f9e13f41d909e07d82d).
-
-<Collapse title="Learn more about GraphQL schemas">
-
-A [GraphQL schema](https://www.prisma.io/blog/graphql-server-basics-the-schema-ac5e2950214e/) defines the operations of a GraphQL API. It effectively is a collection of _types_ written in SDL (SDL also supports primitives like interfaces, enums, union types and more, you can learn everything about GraphQL's type system [here](http://graphql.org/learn/schema/#type-system)).
-
-A GraphQL schema has three special _root types_: `Query`, `Mutation` and `Subscription`. These types define the _entry points_ for the API and define what operations the API will accept. To learn more about GraphQL schema, check out this [article](https://www.prisma.io/blog/graphql-server-basics-the-schema-ac5e2950214e/).
-
-</Collapse>
-
-### The datamodel
-
-The datamodel is written manually by the developers of the Prisma service. It defines the models and structures the developer wants to use in their API.
-
-Strictly speaking, the **datamodel is not a valid GraphQL schema** because it does not contain any of GraphQL's root types (`Query`, `Mutation`, `Subscription`) and therefore does not define any API operations.
-
-The datamodel only serves as _foundation_ for the generation of the actual GraphQL schema that defines the GraphQL API of your Prisma service.
-
-### The Prisma GraphQL schema
-
-The Prisma GraphQL schema can be dowloaded from a Prisma service using the `graphql-schema` generator in your 1:
-
-```yml
-generate:
-  - generator: `graphql-schema`
-    output: ./prisma-schema
-```
-
-Now you can run `prisma generate` and the Prisma CLI will stored the Prisma GraphQLS schema in `./prisma-schema/prisma.graphql`.
-
-### A note on the application schema
-
-If you've already looked into building your own GraphQL server based on Prisma, you might have come across another `.graphql`-file which is referred to as your **application schema** (typically called `schema.graphql` or `app.graphql`).
-
-This is a valid GraphQL schema (meaning it contains the `Query`, `Mutation` and `Subscription` root types) that defines the API of your _application layer_. In contrast to Prisma's _generic_ CRUD API, the application layer's API should expose _domain-specific_ operations that are tailored to the needs of your client applications.
-
-The application layer uses Prisma as a _data access layer_ and delegates incoming requests to the service's Prisma API where they're actually resolved against the database.
-
 ## Files
 
 You can write your datamodel in a single `.prisma`-file or split it accross multiple ones.
 
-The `.prisma`-files containing the datamodel need to be specified in your 1 under the `datamodel` property. For example:
+The `.prisma`-files containing the datamodel need to be referenced in your `prisma.yml` under the `datamodel` property. For example:
 
 ```yml
 datamodel:
@@ -214,8 +152,6 @@ A type has a _name_ and one or multiple [_fields_](#fields). Type names can only
 
 An instantiation of a type is called a _node_. This term refers to a node inside your _data graph_.
 
-Every type you define in your datamodel will be available as an analogous type in the generated _Prisma GraphQL schema_.
-
 ### Defining an object type
 
 A object type is defined in the datamodel with the keyword `type`:
@@ -373,7 +309,7 @@ type User {
 
 ### Type modifiers
 
-In a field definition, a type can be annotated with a _type modifier_. GraphQL supports two type modifiers:
+In a field definition, a type can be annotated with a _type modifier_. SDL supports two type modifiers:
 
 - **Required fields:** Annotate the type with a `!`, e.g. `name: String!`
 - **Lists:** Annotate the type with a pair of enclosing `[]`, e.g. `friends: [User]`
@@ -392,7 +328,7 @@ type Article {
 
 Notice the two `!` type modifiers, here is what they express:
 
-- The first `!` type modifier (right after `String`) means that no item in the list can be `null`, e.g. this value for `tags` would not be valid: `["Software", null, "GraphQL"]`
+- The first `!` type modifier (right after `String`) means that no item in the list can be `null`, e.g. this value for `tags` would not be valid: `["Software", null, "Prisma"]`
 - The second `!` type modifier (after the closing square bracket) means that the list itself can never be `null`, it might be _empty_ though. Consequently, `null` is not a valid value for the `tags` field but `[]` is.
 
 #### Required
@@ -448,7 +384,7 @@ For every field that's annotated with `@unique`, you're able to query the corres
 
 For example, considering the above datamodel, you can now retrieve a particular `User` node by its `email` address:
 
-<Code languages={["TypeScript", "JavaScript", "Flow", "Go", "GraphQL"]}>
+<Code languages={["TypeScript", "JavaScript", "Flow", "Go"]}>
 
 ```ts
 const user = await prisma.user({
@@ -475,19 +411,8 @@ userByEmail, err := client.User(prisma.UserWhereUniqueInput{
 }).Exec(ctx)
 ```
 
-```graphql
-query {
-  user(where: {
-    email: "alice@prisma.io"
-  }) {
-    name
-  }
-}
-```
-
 </Code>
 
-
 #### More constraints
 
 More database constraints will be added soon. Please join the discussion in this [feature request](https://github.com/prisma/prisma/issues/728) if you have wish to see certain constraints implemented in Prisma.
@@ -523,14 +448,6 @@ Values for fields annotated with the `@id`-directive have the following properti
 * Always start with a (lowercase) letter, e.g. `c`
 * Follows [cuid](https://github.com/ericelliott/cuid) (_collision resistant unique identifiers_) scheme
 
-Notice that all model types in the Prisma GraphQL schema will implement the `Node` interface. This is what the `Node` interface looks like:
-
-```graphql
-interface Node {
-  id: ID! @id
-}
-```
-
 #### System fields: `createdAt` and `updatedAt`
 
 The datamodel further provides two special directives which you can add to your fields:
@@ -689,7 +606,7 @@ Note that in this case the relation needs to be annotated with the [`@relation`
 
 For a _to-one_ relation field, you can configure whether it is _required_ or _optional_. The `!` type modifier means that this field can never be `null`. A field for the address of a user would therefore be of type `Address` or `Address!`.
 
-Nodes for a type that contains a required _to-one_ relation field can only be created using a [nested mutation](qwe2#nested-mutations) to ensure the respective field will not be `null`.
+Nodes for a type that contains a required _to-one_ relation field can only be created using a [nested mutation](rsc6#nested-object-writes) to ensure the respective field will not be `null`.
 
 Consider again the following relation:
 
@@ -708,7 +625,7 @@ type Car {
 
 A `Car` can never be created without a `User` and the other way around because that would violate the required constraint. You therefore need to create both at the same time using a declarative nested write:
 
-<Code languages={["TypeScript", "JavaScript", "Flow", "Go", "GraphQL"]}>
+<Code languages={["TypeScript", "JavaScript", "Flow", "Go"]}>
 
 ```ts
 const newUser = await prisma
@@ -756,23 +673,6 @@ newUser, err := client.CreateUser(prisma.UserCreateInput{
 }).Exec(ctx)
 ```
 
-```graphql
-mutation {
-  createUser(data: {
-    car: {
-      create: {
-        color: "Yellow"
-      }
-    }
-  }) {
-    id
-    car {
-      id
-    }
-  }
-}
-```
-
 </Code>
 
 Note that a _to-many_ relation field is always set to required. For example, a field that contains many user addresses always uses the type `[Address!]!` and can never be of type `[Address!]`, `[Address]!` or `[Address]`.
@@ -876,13 +776,6 @@ Let's investigate the deletion behaviour for the three types:
   - the related `Blog` node continues to exist and the deleted `Comment` node is removed from its `comments` list.
   - the related `User` node continues to exist and the deleted `Comment` node is removed from its `comments` list.
 
-### Generated API operations for relations
-
-The relations that are included in your schema affect the available operations in the [Prisma API](/use-prisma-api). Here is an overview of the generated CRUD and realtime operations for every relation in your Prisma API:
-
-- [Relation queries](qwe1#querying-data-across-relations) allow you to query data across types or aggregated for a relation (note that this is also possible using [Relay](https://facebook.github.io/relay/)'s [connection model](qwe1#connection-queries)).
-- [Nested mutations](qwe2#nested-mutations) allow you to create, connect, update, upsert and delete multiple related nodes within the same mutation.
-- [Relation subscriptions](qwe3#relation-subscriptions) allow you to get notified of changes to a relation.
 
 ## SDL directives
 
@@ -952,12 +845,12 @@ In this section, we describe further SDL features that are not yet supported for
 
 ### Interfaces
 
-"Like many type systems, GraphQL supports interfaces. An interface is an abstract type that includes a certain set of fields that a type must include to implement the interface." From the official [GraphQL Documentation](http://graphql.org/learn/schema/#interfaces)
+"Like many type systems, [SDL] supports interfaces. An interface is an abstract type that includes a certain set of fields that a type must include to implement the interface." From the official [Documentation](http://graphql.org/learn/schema/#interfaces)
 
 To learn more about when and how interfaces are coming to Prisma, check out this [feature request](https://github.com/prisma/prisma/issues/83).
 
 ### Union types
 
-"Union types are very similar to interfaces, but they don't get to specify any common fields between the types." From the official [GraphQL Documentation](http://graphql.org/learn/schema/#union-types)
+"Union types are very similar to interfaces, but they don't get to specify any common fields between the types." From the official [Documentation](http://graphql.org/learn/schema/#union-types)
 
 To learn more about when and how union types are coming to Prisma, check out this [feature request](https://github.com/prisma/prisma/issues/165).