constructor(definition: PrismaDefinitionClass) {
    this.cluster = definition.getCluster()!
    this.definition = definition

    if (this.cluster.shared) {
      throw new Error(
        `Cannot introspect demo server. Please use introspection on your self-hosted server.`,
      )
    }
  }

  async connect() {
    await this.cluster
      .request(
        `mutation($input: AddProjectInput!) {
      addProject(input: $input) {
        clientMutationId
      }
    }`,
        {
          input: {
            name: SERVICE_NAME,
            stage: SERVICE_STAGE,
            secrets: [SERVICE_SECRET],
          },
        },
      )
      .then(res => res.json())

    const endpoint = this.cluster.getApiEndpoint(SERVICE_NAME, SERVICE_STAGE)
    const secretsBackup = this.definition.secrets
    this.definition.secrets = [SERVICE_SECRET]
    const token = this.definition.getToken(SERVICE_NAME, SERVICE_STAGE)
    this.definition.secrets = secretsBackup
    this.client = new GraphQLClient(endpoint, {
      headers: token
        ? {
            Authorization: `Bearer ${token}`,
          }
        : {},
    })
  }

  async seed(
    serviceName: string,
    stageName: string,
    reset: boolean = false,
    workspaceSlug?: string,
  ) {
    const seed = this.definition.definition!.seed
    if (!seed) {
      throw new Error(
        `In order to seed, you need to provide a "seed" property in your prisma.yml`,
      )
    }
    if (seed.import && seed.run) {
      throw new Error(
        `Please provider either seed.import or seed.run but not both at the same time`,
      )
    }

    if (seed.import) {
      const source = path.join(this.config.definitionDir, seed.import)

      debug(source)

      if (!source.endsWith('.zip') && !source.endsWith('.graphql')) {
        throw new Error(`Source must end with .zip or .graphql`)
      }

      if (!fs.pathExistsSync(source)) {
        throw new Error(`Path ${source} does not exist`)
      }

      const token = this.definition.getToken(serviceName, stageName)

      if (reset) {
        await this.reset(serviceName, stageName)
      }

      if (source.endsWith('.zip')) {
        await this.import(source, serviceName, stageName, token, workspaceSlug)
      } else if (source.endsWith('.graphql')) {
        await this.executeQuery(
          source,
          serviceName,
          stageName,
          token,
          workspaceSlug,
        )
      }
    }

    if (seed.run) {
      if (reset) {
        await this.reset(serviceName, stageName)
      }

      await this.run(seed.run)
    }
  }

 async reset(serviceName, stageName) {
   const before = Date.now()
   this.out.action.start(
     `Resetting ${chalk.bold(`${serviceName}@${stageName}`)}`,
   )
   await this.client.reset(
     serviceName,
     stageName,
     this.definition.getToken(serviceName, stageName),
   )
   this.out.action.stop(chalk.cyan(`${Date.now() - before}ms`))
 }

 private async import(
   source: string,
   serviceName: string,
   stage: string,
   token?: string,
   workspaceSlug?: string,
 ) {
   await this.definition.load({})
   const typesString = this.definition.typesString!
   const importer = new Importer(
     source,
     typesString,
     this.client,
     this.out,
     this.config,
   )
   await importer.upload(serviceName, stage, token, workspaceSlug)
 }