async function createGraphcoolUser(
  api: GraphQLClient,
  email: string,
  password: string,
): Promise<string> {
  const mutation = `
    mutation createGraphcoolUser($email: String!, $password: String!) {
      createUser(
        email: $email,
        password: $password
      ) {
        id
      }
    }
  `;

  const variables = {
    email,
    password: password,
  };

  return api
    .request<{ createUser: User }>(mutation, variables)
    .then(r => r.createUser.id);
}

async function getUser(api: GraphQLClient, email: string): Promise<{ User }> {
  const query = `
    query getUser($email: String!) {
      User(email: $email) {
        id
      }
    }
  `;

  const variables = {
    email,
  };

  return api.request<{ User }>(query, variables);
}

async function getUser(api: GraphQLClient, id: string): Promise<{ User }> {
  const query = `
    query getUser($id: ID!) {
      User(id: $id) {
        id
      }
    }
  `

  const variables = {
    id,
  }

  return api.request<{ User }>(query, variables)
}

import Deploy from './deploy'
import { changedDefaultDefinition } from '../../examples'
import { mockDefinition, Config } from 'prisma-cli-engine'
import default_definition from './nocks/default_definition'
import local_instance from './nocks/local_instance'
import { MockGraphQLClient } from '../../test/mock-client'

jest.mock('graphql-request')
const GraphQLClient = require('graphql-request').GraphQLClient
GraphQLClient.mockImplementation(MockGraphQLClient)

const mockEnv = {
  stages: {
    default: 'dev',
    dev: 'cj8be5ct201is0140cq7qp23b',
  },
}

const localMockEnv = {
  clusters: {
    default: 'local',
    local: {
      token:
        'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpYXQiOjE1MDcwMjM3NzMsImNsaWVudElkIjoiY2o4YTAxZHN1MDAwMDAxMjM1aWF1aTFoYiJ9.WscmbACu0HqPEDSk_U66TNOskGddmt2plJAew6XCyNw',
      host: 'http://localhost:4466',
    },
  },
}

describe.skip('deploy', () => {
  test('from empty to default definition', async () => {

 async authenticateUser (accessToken: string): Promise<AuthenticatedUser> {
   const mutation = `
     mutation ($accessToken: String!) {
       authenticateUser(
         accessToken: $accessToken
       ) {
         id
         token
         email
       }
     }
   `
   return this.client.request<{ authenticateUser: AuthenticatedUser }>(mutation, { accessToken })
     .then((response) => response.authenticateUser)
 }

  async getDatabases(): Promise<string[]> {
    const result = await this.client.request<any>(
      `{
      __type(name: "PrismaDatabase") {
        kind
        enumValues {
          name
        }
      }
    }`,
    )

    if (result && result.__type && result.__type.enumValues) {
      return result.__type.enumValues.map(v => v.name)
    }

    return []
  }

 async getRecipients (userId: string): Promise<[Recipient]> {
   const query = `
     query ($userId: ID!) {
       allRecipients(filter: {
         user: {
           id: $userId
         }
       }) {
         id
         tags
         phoneNumber
         name
         createdAt
       }
     }
   `
   return this.client.request<{allRecipients: [Recipient]}>(query, { userId })
     .then((response) => response.allRecipients)
 }

docNames.subscribe(x => {
  let key = path.basename(x, ".md");

  if (!srcData[key])
    return;

  let vars = {
    "path": "lib/" + srcData[key].path
  };

  client.request(query, vars).then(data => {
      let nodes = data["repository"].ref.target.history.nodes;

      let lastReviewDate = getDocReviewDate(x);//(key + ".md");

      let numUsefulCommits = extractCommitInfo(nodes, lastReviewDate, stoplist);
      let dateString = lastReviewDate.format("YYYY-MM-DD");
      let score = priorityScore(lastReviewDate, numUsefulCommits).toPrecision(3);

      console.log(`'${key}','${dateString}','${numUsefulCommits}','${score}'`);
  });
});

  async query(query: string, variables: string[] = []): Promise<any> {
    const finalQuery = this.replace(query, variables)
    const databases = await this.getDatabases()

    if (!databases || !databases[0]) {
      throw new Error(`Prisma Config doesn't have any database connection`)
    }

    return this.client.request(
      `
      mutation executeRaw($query: String! $database: PrismaDatabase) {
        rows: executeRaw(
          database: $database
          query: $query
        )
      }
    `,
      {
        query: finalQuery,
        database: databases[0],
      },
    )
  }

const gqlRequest = async (request: string, variables: any) => {
  return await graphQLClient.request(request, variables)
}