feat: new codegen

Author: timsuchanek

Diff for: README.md

@@ -10,11 +10,11 @@ GraphQL Binding for Prisma services (GraphQL Database)
 
 Here is how it works:
 
-1. Create your Prisma service by defining data model
-1. Download generated database schema definition `prisma.graphql` (contains the full CRUD API)
-1. Define your application schema, typically called `app.graphql`
-1. Instantiate `Prisma` with information about your Prisma service (such as its endpoint and the path to the database schema definition)
-1. Implement the resolvers for your application schema by delegating to the underlying Prisma service using the generated delegate resolver functions
+1.  Create your Prisma service by defining data model
+1.  Download generated database schema definition `prisma.graphql` (contains the full CRUD API)
+1.  Define your application schema, typically called `app.graphql`
+1.  Instantiate `Prisma` with information about your Prisma service (such as its endpoint and the path to the database schema definition)
+1.  Implement the resolvers for your application schema by delegating to the underlying Prisma service using the generated delegate resolver functions
 
 > **Note**: If you're using a [GraphQL boilerplate](https://github.com/graphql-boilerplates/) project (e.g. with `graphql create`), the Prisma binding will already be configured and a few example resolvers implemented for you. You can either try the _dynamic binding_ (e.g. in the [`node-basic`](https://github.com/graphql-boilerplates/node-graphql-server/tree/master/basic) boilerplate) or a _static binding_ (e.g in the [`typescript-basic`](https://github.com/graphql-boilerplates/typescript-graphql-server/tree/master/basic) boilerplate).
 
@@ -73,8 +73,8 @@ The API also allows to ask whether a specific node exists in your Prisma databas
 prisma.exists.Post({
   id: 'abc',
   author: {
-    name: 'Sarah'
-  }
+    name: 'Sarah',
+  },
 })
 ```
 
@@ -84,13 +84,13 @@ prisma.exists.Post({
 
 The `PrismaOptions` type has the following fields:
 
-| Key | Required |  Type | Default | Note |
-| ---  | --- | --- | --- | --- |
-| `typeDefs` | Yes | `string` |  - | Type definition string or file path to the schema definition of your Prisma service (typically a file called `database.graphql`) |
-| `endpoint` | Yes | `string` |  - | The endpoint of your Prisma service |
-| `secret` | Yes | `string` |  - | The secret of your Prisma service |
-| `fragmentReplacements` | No | `FragmentReplacements` |  `null` | A list of GraphQL fragment definitions, specifying fields that are required for the resolver to function correctly |
-| `debug` | No | `boolean` |  `false` | Log all queries/mutations to the console |
+| Key                    | Required | Type                   | Default | Note                                                                                                                             |
+| ---------------------- | -------- | ---------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------- |
+| `typeDefs`             | Yes      | `string`               | -       | Type definition string or file path to the schema definition of your Prisma service (typically a file called `database.graphql`) |
+| `endpoint`             | Yes      | `string`               | -       | The endpoint of your Prisma service                                                                                              |
+| `secret`               | Yes      | `string`               | -       | The secret of your Prisma service                                                                                                |
+| `fragmentReplacements` | No       | `FragmentReplacements` | `null`  | A list of GraphQL fragment definitions, specifying fields that are required for the resolver to function correctly               |
+| `debug`                | No       | `boolean`              | `false` | Log all queries/mutations to the console                                                                                         |
 
 ### `query` and `mutation`
 
@@ -106,10 +106,10 @@ Delegate resolver have the following interface:
 
 The input arguments are used as follows:
 
-- `args`: An object carrying potential arguments for the query/mutation
-- `info`: An object representing the selection set of the query/mutation, either expressed directly as a string or in the form of `GraphQLResolveInfo` (you can find more info about the `GraphQLResolveInfo` type [here](http://graphql.org/graphql-js/type/#graphqlobjecttype))
+* `args`: An object carrying potential arguments for the query/mutation
+* `info`: An object representing the selection set of the query/mutation, either expressed directly as a string or in the form of `GraphQLResolveInfo` (you can find more info about the `GraphQLResolveInfo` type [here](http://graphql.org/graphql-js/type/#graphqlobjecttype))
 
-The generic type `T` corresponds to the type of the respective field. 
+The generic type `T` corresponds to the type of the respective field.
 
 ### `exists`
 
@@ -135,8 +135,7 @@ const query = `
 
 const variables = { userId: 'abc' }
 
-prisma.request(query, variables)
-  .then(result => console.log(result))
+prisma.request(query, variables).then(result => console.log(result))
 // sample result:
 // {"data": { "user": { "id": "abc", "name": "Sarah" } } }
 ```
@@ -146,12 +145,12 @@ prisma.request(query, variables)
 If you just want to forward a query to the exact same underlying prisma query, you can use `forwardTo`:
 
 ```js
-const {forwardTo} = require('prisma-binding')
+const { forwardTo } = require('prisma-binding')
 
 const resolvers = {
   Query: {
-    posts: forwardTo('db')
-  }
+    posts: forwardTo('db'),
+  },
 }
 
 const server = new GraphQLServer({
@@ -168,17 +167,14 @@ const server = new GraphQLServer({
   }),
 })
 
-server.start(
-  () => console.log(`Server is running on http://localhost:4000`),
-)
+server.start(() => console.log(`Server is running on http://localhost:4000`))
 ```
 
-
 ## Usage
 
-- [graphql-boilerplate](https://github.com/graphcool/graphql-boilerplate).
-- [graphql-server-example](https://github.com/graphcool/graphql-server-example).
+* [graphql-boilerplate](https://github.com/graphcool/graphql-boilerplate).
+* [graphql-server-example](https://github.com/graphcool/graphql-server-example).
 
 ## Next steps
 
-- Code generation at build-time for the auto-generated delegate resolvers
+* Code generation at build-time for the auto-generated delegate resolvers

Diff for: packages/graphql-codegen-prisma-binding/README.md

@@ -0,0 +1,34 @@
+# graphql-codegen-binding
+
+## Usage
+
+### CLI
+
+```sh
+$ npm install -g graphql-codegen-binding
+$ graphql-codegen-binding
+
+Usage: graphql-codegen-binding -s [schema] -e [endpoint] -h [headers] -g [generator] -t [target]
+
+Options:
+  --help           Show help                                           [boolean]
+  --version        Show version number                                 [boolean]
+  --schema, -s     Path to schema.graphql file                          [string]
+  --endpoint, -e   GraphQL endpoint to fetch schema from                [string]
+  --headers, -h    Header to use for downloading the schema (with endpoint URL)
+                                                                        [string]
+  --generator, -g  Type of the generator. Available generators: typescript,
+                   javascript                                [string] [required]
+  --target, -t     Target file. Example: schema.ts           [string] [required]
+```
+
+### Typescript
+
+```ts
+import { generateCode } from 'graphql-codegen-binding'
+import * as fs from 'fs'
+
+const code = generateCode(fs.readFileSync('schema.graphql'), 'typescript')
+
+fs.writeFileSync('MyBinding.ts', code)
+```

Diff for: packages/graphql-codegen-prisma-binding/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "graphql-codegen-prisma-binding",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "url": "https://github.com/graphcool/graphql-codegen-binding.git"
+  },
+  "bin": {
+    "graphql-codegen-prisma-binding": "./dist/bin.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "contributors": [
+    {
+      "name": "Tim Suchanek",
+      "email": "suchanek@prisma.io"
+    }
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/graphql": "^0.13.0",
+    "@types/jest": "^22.2.2",
+    "@types/node": "^9.6.2",
+    "jest": "^22.4.3",
+    "prettier": "^1.10.2",
+    "ts-jest": "^22.4.2",
+    "tslint": "^5.6.0",
+    "typescript": "^2.6.2"
+  },
+  "scripts": {
+    "test": "jest",
+    "build": "tsc -d && chmod +x dist/bin.js",
+    "lint": "tslint src/**/*.ts",
+    "precommit": "lint-staged",
+    "prepublishOnly": "yarn lint && yarn test && yarn build"
+  },
+  "peerDependencies": {
+    "graphql": "^0.11.0 || ^0.12.0 || ^0.13.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "json"
+    ],
+    "rootDir": "./src",
+    "transform": {
+      "^.+\\.(ts|tsx)$": "../node_modules/ts-jest/preprocessor.js"
+    },
+    "testMatch": [
+      "**/*.test.(ts|js)"
+    ],
+    "globals": {
+      "ts-jest": {
+        "tsConfigFile": "../tsconfig.json"
+      }
+    }
+  },
+  "dependencies": {
+    "graphql": "^0.11.0 || ^0.12.0 || ^0.13.0",
+    "graphql-codegen-binding": "^0.0.15",
+    "graphql-config": "2.0.1",
+    "mkdirp": "^0.5.1",
+    "yargs": "^11.0.0"
+  }
+}

Diff for: packages/graphql-codegen-prisma-binding/src/bin.ts

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import * as yargs from 'yargs'
+import { generateCode } from '.'
+
+const argv = yargs
+  .usage(
+    `Usage: $0 -s [schema] -e [endpoint] -h [headers] -g [generator] -t [target]`,
+  )
+  .options({
+    schema: {
+      alias: 's',
+      describe: 'Path to schema.graphql file',
+      type: 'string',
+    },
+    endpoint: {
+      alias: 'e',
+      describe: 'GraphQL endpoint to fetch schema from',
+      type: 'string',
+    },
+    headers: {
+      alias: 'h',
+      describe: 'Header to use for downloading the schema (with endpoint URL)',
+      type: 'string',
+    },
+    generator: {
+      alias: 'g',
+      describe:
+        'Type of the generator. Available generators: typescript, javascript',
+      type: 'string',
+    },
+    target: {
+      alias: 't',
+      describe: 'Target file. Example: schema.ts',
+      type: 'string',
+    },
+  })
+  .demandOption(['g', 't']).argv
+
+run(argv)
+
+async function run(argv) {
+  const endpointHeaders = {}
+  const headers = argv.headers
+    ? Array.isArray(argv.headers) ? argv.headers : [argv.headers]
+    : undefined
+  if (headers) {
+    Object.assign(
+      endpointHeaders,
+      ...headers.map(h => ({ [h.split('=')[0]]: h.split('=')[1] })),
+    )
+  }
+
+  const { generator, target, endpoint } = argv
+  await generateCode({
+    schemaPath: argv.schema,
+    generator,
+    target,
+    endpoint,
+    headers: endpointHeaders,
+  })
+
+  console.log('Done generating binding')
+}

Diff for: packages/graphql-codegen-prisma-binding/src/generateCode.ts

@@ -0,0 +1,42 @@
+import * as fs from 'fs'
+import { GraphQLEndpoint } from 'graphql-config'
+import { makeBinding } from './makeBinding'
+import { GeneratorType } from './types'
+import * as mkdirp from 'mkdirp'
+import * as path from 'path'
+
+export interface CodeGenerationInput {
+  schemaPath?: string
+  schema?: string
+  endpoint?: string
+  generator: GeneratorType
+  target: string
+  headers?: any
+}
+
+export async function generateCode(argv: CodeGenerationInput) {
+  if (!argv.schema && !argv.schemaPath && !argv.endpoint) {
+    throw new Error(
+      'Please either provide the schema or the endpoint you want to get the schema from.',
+    )
+  }
+
+  const schema = argv.schema
+    ? argv.schema
+    : argv.schemaPath
+      ? fs.readFileSync(argv.schemaPath, 'utf-8')
+      : await downloadFromEndpointUrl(argv)
+
+  const code = makeBinding(schema, argv.generator)
+  mkdirp(path.dirname(argv.target))
+  fs.writeFileSync(argv.target, code)
+}
+
+function downloadFromEndpointUrl(argv) {
+  const endpoint = new GraphQLEndpoint({
+    url: argv.endpoint,
+    headers: argv.headers,
+  })
+
+  return endpoint.resolveSchemaSDL()
+}

Diff for: packages/graphql-codegen-prisma-binding/src/generators/__snapshots__/javascript.test.ts.snap

@@ -0,0 +1,8 @@
+import { generator as typescriptGenerator } from './typescript'
+import { generator as javascriptGenerator } from './javascript'
+import { Generator } from 'graphql-codegen-binding'
+
+export const generators: { [key: string]: Generator } = {
+  typescript: typescriptGenerator,
+  javascript: javascriptGenerator,
+}

Diff for: packages/graphql-codegen-prisma-binding/src/generators/__snapshots__/typescript.test.ts.snap

@@ -0,0 +1,7 @@
+import { makeBinding } from '../makeBinding'
+import * as fs from 'fs'
+
+const schema = fs.readFileSync(__dirname + '/fixtures/schema.graphql', 'utf-8')
+test('typescript generator', () => {
+  expect(makeBinding(schema, 'javascript')).toMatchSnapshot()
+})

Diff for: packages/graphql-codegen-prisma-binding/src/generators/fixtures/schema.graphql

@@ -0,0 +1,93 @@
+import { GraphQLObjectType, GraphQLFieldMap } from 'graphql'
+
+import { javascriptGenerator, Generator } from 'graphql-codegen-binding'
+import { isWrappingType } from 'graphql'
+import { isListType } from 'graphql'
+import { GraphQLInputObjectType } from 'graphql'
+
+export const generator: Generator = {
+  ...javascriptGenerator,
+  Main: renderMainMethod,
+  Header: renderHeader,
+}
+
+const scalarMapping = {
+  Int: 'number',
+  String: 'string',
+  ID: 'string | number',
+  Float: 'number',
+  Boolean: 'boolean',
+}
+
+export function renderExistsFields(fields: GraphQLFieldMap<any, any>): string {
+  return Object.keys(fields)
+    .map(f => {
+      const field = fields[f]
+      let type = field.type
+      let foundList = false
+      // Traverse the wrapping types (if any)
+      while (isWrappingType(type)) {
+        type = type.ofType
+        // One of those wrappings need to be a GraphQLList for this field to qualify
+        foundList = foundList || isListType(type)
+      }
+      if (foundList) {
+        const whereType = (field.args.find(a => a.name === 'where')!
+          .type as GraphQLInputObjectType).name
+        return `    ${
+          type.name
+        }: (where: ${whereType}): Promise<boolean> => super.existsDelegate('query', '${
+          field.name
+        }', { where }, {}, '{ id }')`
+      }
+    })
+    .filter(f => f)
+    .join(',\n')
+}
+
+function renderHeader(schema: string): string {
+  return `const { Prisma } = require('prisma-binding')
+const { GraphQLResolveInfo } = require('graphql')
+const typeDefs = \`
+${schema}\``
+}
+
+function renderMainMethod(
+  queryType: GraphQLObjectType,
+  mutationType?: GraphQLObjectType | null,
+  subscriptionType?: GraphQLObjectType | null,
+) {
+  return `module.exports.Prisma = class Binding extends Prisma {
+  
+  constructor({ endpoint, secret, fragmentReplacements, debug }) {
+    super({ typeDefs, endpoint, secret, fragmentReplacements, debug });
+    var self = this
+    this.exists = {
+${renderExistsFields(queryType.getFields())}
+    }
+    this.query = {
+${javascriptGenerator.MainFields!('query', queryType.getFields())}
+    }${
+      mutationType
+        ? `
+      
+    this.mutation = {
+${javascriptGenerator.MainFields!('mutation', mutationType.getFields())}
+    }`
+        : ''
+    }${
+    subscriptionType
+      ? `
+      
+    this.subscription = {
+${javascriptGenerator.MainSubscriptionFields!(subscriptionType.getFields())}
+    }`
+      : ''
+  }
+  }
+  
+  delegate(operation, field, args, context, info) {
+    return super.delegate(operation, field, args, context, info)
+  }
+}`
+}

Diff for: packages/graphql-codegen-prisma-binding/src/generators/index.ts

@@ -0,0 +1,7 @@
+import { makeBinding } from '../makeBinding'
+import * as fs from 'fs'
+
+const schema = fs.readFileSync(__dirname + '/fixtures/schema.graphql', 'utf-8')
+test('typescript generator', () => {
+  expect(makeBinding(schema, 'typescript')).toMatchSnapshot()
+})

Diff for: packages/graphql-codegen-prisma-binding/src/generators/javascript.test.ts

@@ -0,0 +1,91 @@
+import { GraphQLObjectType, GraphQLFieldMap } from 'graphql'
+
+import { typescriptGenerator, Generator } from 'graphql-codegen-binding'
+import { isWrappingType } from 'graphql'
+import { isListType } from 'graphql'
+import { GraphQLInputObjectType } from 'graphql'
+
+export const generator: Generator = {
+  ...typescriptGenerator,
+  Main: renderMainMethod,
+  Header: renderHeader,
+}
+
+const scalarMapping = {
+  Int: 'number',
+  String: 'string',
+  ID: 'string | number',
+  Float: 'number',
+  Boolean: 'boolean',
+}
+
+export function renderExistsFields(fields: GraphQLFieldMap<any, any>): string {
+  return Object.keys(fields)
+    .map(f => {
+      const field = fields[f]
+      let type = field.type
+      let foundList = false
+      // Traverse the wrapping types (if any)
+      while (isWrappingType(type)) {
+        type = type.ofType
+        // One of those wrappings need to be a GraphQLList for this field to qualify
+        foundList = foundList || isListType(type)
+      }
+      if (foundList) {
+        const whereType = (field.args.find(a => a.name === 'where')!
+          .type as GraphQLInputObjectType).name
+        return `    ${
+          type.name
+        }: (where: ${whereType}): Promise<boolean> => super.existsDelegate('query', '${
+          field.name
+        }', { where }, {}, '{ id }')`
+      }
+    })
+    .filter(f => f)
+    .join(',\n')
+}
+
+function renderHeader(schema: string): string {
+  return `import { Prisma as BasePrisma, BasePrismaOptions } from 'prisma-binding'
+import { GraphQLResolveInfo } from 'graphql'
+
+export const typeDefs = \`
+${schema}\``
+}
+
+function renderMainMethod(
+  queryType: GraphQLObjectType,
+  mutationType?: GraphQLObjectType | null,
+  subscriptionType?: GraphQLObjectType | null,
+) {
+  return `export class Prisma extends BasePrisma {
+  
+  constructor({ endpoint, secret, fragmentReplacements, debug }: BasePrismaOptions) {
+    super({ typeDefs, endpoint, secret, fragmentReplacements, debug });
+  }
+
+  exists = {
+${renderExistsFields(queryType.getFields())}
+  }
+
+  query: Query = {
+${typescriptGenerator.MainFields!('query', queryType.getFields())}
+  }${
+    mutationType
+      ? `
+
+  mutation: Mutation = {
+${typescriptGenerator.MainFields!('mutation', mutationType.getFields())}
+  }`
+      : ''
+  }${
+    subscriptionType
+      ? `
+
+  subscription: Subscription = {
+${typescriptGenerator.MainSubscriptionFields!(subscriptionType.getFields())}
+  }`
+      : ''
+  }
+}`
+}

Diff for: packages/graphql-codegen-prisma-binding/src/generators/javascript.ts

@@ -0,0 +1,2 @@
+export { generateCode } from './generateCode'
+export { makeBinding } from './makeBinding'

Diff for: packages/graphql-codegen-prisma-binding/src/generators/typescript.test.ts

@@ -0,0 +1,31 @@
+import {
+  DocumentNode,
+  Kind,
+  ObjectTypeDefinitionNode,
+  OperationTypeDefinitionNode,
+  parse,
+} from 'graphql'
+import { GraphQLSchema } from 'graphql/type/schema'
+import { buildASTSchema } from 'graphql/utilities/buildASTSchema'
+import { generators } from './generators'
+import { GeneratorType } from './types'
+import { makeBinding as makeGraphQLBinding } from 'graphql-codegen-binding'
+
+/**
+ * The schema contains incompatible characters sometimes, e.g.
+ * data types in comments are emphasized with "`", which represents
+ * template strings in ES2015 and TypeScript. This function
+ * replaces those characters with sane defaults.
+ *
+ * @param schema {String} The serialized schema
+ * @returns {String}
+ *
+ */
+const sanitizeSchema = (schema: string) => schema.replace(/\`/g, "'")
+
+export function makeBinding(
+  schema: string,
+  generatorName: GeneratorType,
+): string {
+  return makeGraphQLBinding(schema, generators[generatorName])
+}

Diff for: packages/graphql-codegen-prisma-binding/src/generators/typescript.ts

@@ -0,0 +1 @@
+export type GeneratorType = 'typescript' | 'javascript'

Diff for: packages/graphql-codegen-prisma-binding/src/index.ts

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "forceConsistentCasingInFileNames": true,
+    "strictNullChecks": true,
+    "sourceMap": true,
+    "outDir": "dist",
+    "moduleResolution": "node",
+    "lib": ["es2017", "dom", "esnext.asynciterable"],
+    "target": "es5",
+    "rootDir": "src",
+    "skipLibCheck": true
+  },
+  "exclude": ["node_modules", "dist"]
+}

Diff for: packages/graphql-codegen-prisma-binding/src/makeBinding.ts

@@ -0,0 +1,5 @@
+node_modules
+.idea
+dist
+.DS_Store
+*.log

Diff for: packages/graphql-codegen-prisma-binding/src/types.ts

@@ -0,0 +1,184 @@
+# prisma-binding
+
+[![CircleCI](https://circleci.com/gh/graphcool/prisma-binding.svg?style=shield)](https://circleci.com/gh/graphcool/prisma-binding) [![npm version](https://badge.fury.io/js/prisma-binding.svg)](https://badge.fury.io/js/prisma-binding)
+
+GraphQL Binding for Prisma services (GraphQL Database)
+
+## Overview
+
+`prisma-binding` provides a convenience layer for building GraphQL servers on top of Prisma services. In short, it simplifies implementing your GraphQL resolvers by _delegating_ execution of queries (or mutations) to the API of the underlying Prisma database service.
+
+Here is how it works:
+
+1. Create your Prisma service by defining data model
+1. Download generated database schema definition `prisma.graphql` (contains the full CRUD API)
+1. Define your application schema, typically called `app.graphql`
+1. Instantiate `Prisma` with information about your Prisma service (such as its endpoint and the path to the database schema definition)
+1. Implement the resolvers for your application schema by delegating to the underlying Prisma service using the generated delegate resolver functions
+
+> **Note**: If you're using a [GraphQL boilerplate](https://github.com/graphql-boilerplates/) project (e.g. with `graphql create`), the Prisma binding will already be configured and a few example resolvers implemented for you. You can either try the _dynamic binding_ (e.g. in the [`node-basic`](https://github.com/graphql-boilerplates/node-graphql-server/tree/master/basic) boilerplate) or a _static binding_ (e.g in the [`typescript-basic`](https://github.com/graphql-boilerplates/typescript-graphql-server/tree/master/basic) boilerplate).
+
+## Install
+
+```sh
+yarn add prisma-binding
+# or
+npm install --save prisma-binding
+```
+
+## Example
+
+Consider the following data model for your Prisma service:
+
+```graphql
+type User {
+  id: ID! @unique
+  name: String
+}
+```
+
+If you instantiate `Prisma` based on this service, you'll be able to send the following queries/mutations:
+
+```js
+// Instantiate `Prisma` based on concrete service
+const prisma = new Prisma({
+  typeDefs: 'schemas/database.graphql',
+  endpoint: 'https://us1.prisma.sh/demo/my-service/dev'
+  secret: 'my-super-secret-secret'
+})
+
+// Retrieve `name` of a specific user
+prisma.query.user({ where { id: 'abc' } }, '{ name }')
+
+// Retrieve `id` and `name` of all users
+prisma.query.users(null, '{ id name }')
+
+// Create new user called `Sarah` and retrieve the `id`
+prisma.mutation.createUser({ data: { name: 'Sarah' } }, '{ id }')
+
+// Update name of a specific user and retrieve the `id`
+prisma.mutation.updateUser({ where: { id: 'abc' }, data: { name: 'Sarah' } }, '{ id }')
+
+// Delete a specific user and retrieve the `name`
+prisma.mutation.deleteUser({ where: { id: 'abc' } }, '{ id }')
+```
+
+Under the hood, each of these function calls is simply translated into an actual HTTP request against your Prisma service (using [`graphql-request`](https://github.com/graphcool/graphql-request)).
+
+The API also allows to ask whether a specific node exists in your Prisma database:
+
+```js
+// Ask whether a post exists with `id` equal to `abc` and whose
+// `author` is called `Sarah` (return boolean value)
+prisma.exists.Post({
+  id: 'abc',
+  author: {
+    name: 'Sarah'
+  }
+})
+```
+
+## API
+
+### `constructor(options: PrismaOptions): Prisma`
+
+The `PrismaOptions` type has the following fields:
+
+| Key | Required |  Type | Default | Note |
+| ---  | --- | --- | --- | --- |
+| `typeDefs` | Yes | `string` |  - | Type definition string or file path to the schema definition of your Prisma service (typically a file called `database.graphql`) |
+| `endpoint` | Yes | `string` |  - | The endpoint of your Prisma service |
+| `secret` | Yes | `string` |  - | The secret of your Prisma service |
+| `fragmentReplacements` | No | `FragmentReplacements` |  `null` | A list of GraphQL fragment definitions, specifying fields that are required for the resolver to function correctly |
+| `debug` | No | `boolean` |  `false` | Log all queries/mutations to the console |
+
+### `query` and `mutation`
+
+`query` and `mutation` are public properties on your `Prisma` instance. They both are of type `Query` and expose a number of auto-generated delegate resolver functions that are named after the fields on the `Query` and `Mutation` types in your Prisma database schema.
+
+Each of these delegate resolvers in essence provides a convenience API for sending queries/mutations to your Prisma service, so you don't have to spell out the full query/mutation from scratch and worry about sending it over HTTP. This is all handled by the delegate resolver function under the hood.
+
+Delegate resolver have the following interface:
+
+```js
+(args: any, info: GraphQLResolveInfo | string): Promise<T>
+```
+
+The input arguments are used as follows:
+
+- `args`: An object carrying potential arguments for the query/mutation
+- `info`: An object representing the selection set of the query/mutation, either expressed directly as a string or in the form of `GraphQLResolveInfo` (you can find more info about the `GraphQLResolveInfo` type [here](http://graphql.org/graphql-js/type/#graphqlobjecttype))
+
+The generic type `T` corresponds to the type of the respective field. 
+
+### `exists`
+
+`exists` also is a public property on your `Prisma` instance. Similar to `query` and `mutation`, it also exposes a number of auto-generated functions. However, it exposes only a single function per type. This function is named according to the root field that allows the retrieval of a single node of that type (e.g. `User` for a type called `User`). It takes a `where` object as an input argument and returns a `boolean` value indicating whether the condition expressed with `where` is met.
+
+This function enables you to easily check whether a node of a specific type exists in your Prisma database.
+
+### `request`
+
+The `request` method lets you send GraphQL queries/mutations to your Prisma service. The functionality is identical to the auto-generated delegate resolves, but the API is more verbose as you need to spell out the full query/mutation. `request` uses [`graphql-request`](https://github.com/graphcool/graphql-request) under the hood.
+
+Here is an example of how it can be used:
+
+```js
+const query = `
+  query ($userId: ID!){
+    user(id: $userId) {
+      id
+      name
+    }
+  }
+`
+
+const variables = { userId: 'abc' }
+
+prisma.request(query, variables)
+  .then(result => console.log(result))
+// sample result:
+// {"data": { "user": { "id": "abc", "name": "Sarah" } } }
+```
+
+### `forwardTo`
+
+If you just want to forward a query to the exact same underlying prisma query, you can use `forwardTo`:
+
+```js
+const {forwardTo} = require('prisma-binding')
+
+const resolvers = {
+  Query: {
+    posts: forwardTo('db')
+  }
+}
+
+const server = new GraphQLServer({
+  typeDefs: './src/schema.graphql',
+  resolvers,
+  context: req => ({
+    ...req,
+    db: new Prisma({
+      typeDefs: 'src/generated/prisma.graphql',
+      endpoint: '...',
+      secret: 'mysecret123',
+    }),
+    debug: true,
+  }),
+})
+
+server.start(
+  () => console.log(`Server is running on http://localhost:4000`),
+)
+```
+
+
+## Usage
+
+- [graphql-boilerplate](https://github.com/graphcool/graphql-boilerplate).
+- [graphql-server-example](https://github.com/graphcool/graphql-server-example).
+
+## Next steps
+
+- Code generation at build-time for the auto-generated delegate resolvers

Diff for: packages/graphql-codegen-prisma-binding/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-binding",
-  "version": "0.0.0-semantic-release",
+  "version": "1.6.0-beta.1",
   "main": "dist/src/index.js",
   "typings": "./dist/src/index.d.ts",
   "files": [
@@ -30,7 +30,7 @@
     "apollo-link-error": "1.0.7",
     "apollo-link-ws": "1.0.7",
     "cross-fetch": "2.0.0",
-    "graphql-binding": "1.2.5",
+    "graphql-binding": "^1.4.0-beta.1",
     "graphql-import": "0.4.5",
     "graphql-tools": "2.21.0",
     "http-link-dataloader": "^0.1.2",

Diff for: packages/graphql-codegen-prisma-binding/yarn.lock

@@ -0,0 +1,3 @@
+{
+  "extends": ["config:base", "docker:disable"]
+}

Diff for: packages/prisma-binding/.gitignore

@@ -1,4 +1,4 @@
-import { Binding } from 'graphql-binding'
+import { Binding, Handler, SubscriptionHandler } from 'graphql-binding'
 import { Exists, PrismaOptions, QueryMap, SubscriptionMap } from './types'
 import { sign } from 'jsonwebtoken'
 import { makePrismaLink } from './link'
@@ -8,7 +8,6 @@ import { importSchema } from 'graphql-import'
 import { GraphQLNamedType, GraphQLSchema } from 'graphql'
 import { SharedLink } from './SharedLink'
 import { makeRemoteExecutableSchema } from 'graphql-tools'
-import { Handler, SubscriptionHandler } from './Handler'
 
 const typeDefsCache: { [schemaPath: string]: string } = {}
 const remoteSchemaCache: { [typeDefs: string]: GraphQLSchema } = {}
@@ -62,11 +61,17 @@ export class Prisma extends Binding<QueryMap, SubscriptionMap> {
       sharedLink.setInnerLink(link)
     }
 
-    super({ schema: remoteSchema, fragmentReplacements, before, handler: Handler, subscriptionHandler: SubscriptionHandler })
+    super({
+      schema: remoteSchema,
+      fragmentReplacements,
+      before,
+      handler: Handler,
+      subscriptionHandler: SubscriptionHandler,
+    })
 
     this.exists = new Proxy(
       {},
-      new ExistsHandler(remoteSchema, this.existsDelegate.bind(this))
+      new ExistsHandler(remoteSchema, this.existsDelegate.bind(this)),
     )
   }
 
@@ -82,18 +87,21 @@ export class Prisma extends Binding<QueryMap, SubscriptionMap> {
     info?: GraphQLResolveInfo | string,
   ): Promise<boolean> {
     this.before()
-    return this
-      .delegate(operation, fieldName, args, context, info)
-      .then(res => res.length > 0)
+    return this.delegate(operation, fieldName, args, info, context).then(
+      res => res.length > 0,
+    )
   }
 }
 
 class ExistsHandler implements ProxyHandler<Prisma> {
-  constructor(private schema: GraphQLSchema, private delegate: any) { }
+  constructor(private schema: GraphQLSchema, private delegate: any) {}
 
   get(target: any, typeName: string) {
     return async (where: { [key: string]: any }): Promise<boolean> => {
-      const rootFieldName: string = this.findRootFieldName(typeName, this.schema)
+      const rootFieldName: string = this.findRootFieldName(
+        typeName,
+        this.schema,
+      )
       const args = { where }
       const info = buildExistsInfo(rootFieldName, this.schema)
       return this.delegate('query', rootFieldName, args, {}, info)
@@ -135,8 +143,8 @@ function getCachedTypeDefs(schemaPath: string): string {
 }
 
 function getCachedRemoteSchema(
-  typeDefs: string, 
-  link: SharedLink
+  typeDefs: string,
+  link: SharedLink,
 ): GraphQLSchema {
   if (remoteSchemaCache[typeDefs]) {
     return remoteSchemaCache[typeDefs]

Diff for: packages/prisma-binding/README.md

@@ -1379,19 +1379,27 @@ graceful-fs@^4.1.11, graceful-fs@^4.1.2:
   version "4.1.11"
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658"
 
-graphql-binding@1.2.5:
-  version "1.2.5"
-  resolved "https://registry.yarnpkg.com/graphql-binding/-/graphql-binding-1.2.5.tgz#1c45b9da055cb0722f0348b6354be2e11b0a8c17"
+graphql-binding@^1.4.0-beta.1:
+  version "1.4.0-beta.1"
+  resolved "https://registry.yarnpkg.com/graphql-binding/-/graphql-binding-1.4.0-beta.1.tgz#7c7ba01e7fc08fd4e56089264a4dda89c2c94a71"
   dependencies:
+    graphql-import "^0.5.0"
     graphql-tools "2.21.0"
     iterall "1.2.2"
+    object-path-immutable "^1.0.1"
 
 graphql-import@0.4.5:
   version "0.4.5"
   resolved "https://registry.yarnpkg.com/graphql-import/-/graphql-import-0.4.5.tgz#e2f18c28d335733f46df8e0733d8deb1c6e2a645"
   dependencies:
     lodash "^4.17.4"
 
+graphql-import@^0.5.0:
+  version "0.5.0"
+  resolved "https://registry.yarnpkg.com/graphql-import/-/graphql-import-0.5.0.tgz#5f678a6d4636d02a829308884aa1f2fa2197f06d"
+  dependencies:
+    lodash "^4.17.4"
+
 graphql-tools@2.21.0:
   version "2.21.0"
   resolved "https://registry.yarnpkg.com/graphql-tools/-/graphql-tools-2.21.0.tgz#c0d0fbda6f40a87c8d267a2989ade2ae8b9a288e"
@@ -2196,6 +2204,10 @@ object-assign@^4.0.1, object-assign@^4.1.0:
   version "4.1.1"
   resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863"
 
+object-path-immutable@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/object-path-immutable/-/object-path-immutable-1.0.1.tgz#3c424052be3c54ec82def03f1b11b0c6e085c7ff"
+
 object.omit@^2.0.0:
   version "2.0.1"
   resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa"