TypeScript GraphQLClient.request方法代码示例

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 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 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)
}

  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)
}

export default callbackRuntime(async (event: APIGatewayEvent) => {
  // NOTE currently needed for backward compatibility
  if (event.path.split('/')[1] !== 'v1') {
    try {
      // log projectId of projects using the old API version
      const client = new GraphQLClient(process.env['GRAPHCOOL_ENDPOINT']!, {
        headers: {
          Authorization: `Bearer ${process.env['GRAPHCOOL_PAT']}`,
        },
      })

      await client.request(`mutation {
        createApiUser(projectId: "${event.path.split('/')[1]}") { id }
      }`)
    } catch (e) {
      if (e.response.errors[0].code !== 3010) {
        throw e
      }
    }

    return {
      statusCode: 301,
      body: '',
      headers: {
        Location: `https://images.graph.cool/v1${event.path}`,
      },
    }
  }

  const [paramsErr, params] = parseParams(event.path)

  if (paramsErr) {
    return {
      statusCode: 400,
      body: paramsErr.toString(),
    }
  }

  const { projectId, fileSecret, crop, resize } = params!

  const options = {
    Bucket: process.env['BUCKET_NAME']!,
    Key: `${projectId}/${fileSecret}`,
  }

  const {
    ContentLength,
    ContentType,
    ContentDisposition,
  } = await s3.headObject(options).promise()

  if (ContentLength! > 25 * 1024 * 1024) {
    return {
      statusCode: 400,
      body: 'File too big',
    }
  }

  if (!ContentType!.includes('image')) {
    return {
      statusCode: 400,
      body: 'File not an image',
    }
  }

  // return original for gifs, svgs or no params
  if (
    ContentType === 'image/gif' ||
    ContentType === 'image/svg+xml' ||
    (resize === undefined && crop === undefined)
  ) {
    const obj = await s3.getObject(options).promise()
    const body = (obj.Body as Buffer).toString('base64')
    return base64Response(body, ContentType!, ContentDisposition!)
  }

  const s3Resp = await s3.getObject(options).promise()
  const stream = sharp(s3Resp.Body)

  try {
    const config = getConfig({ resize, crop })

    stream.limitInputPixels(false)

    if (config.crop) {
      stream.extract({
        left: config.crop.x,
        top: config.crop.y,
        width: config.crop.width,
        height: config.crop.height,
      })
    }

    if (config.resize) {
      stream.rotate()
      stream.resize(config.resize.width, config.resize.height)

      if (config.resize.force) {
        stream.ignoreAspectRatio()
      } else {
//.........这里部分代码省略.........