github.com/nektos/act@v0.2.63/pkg/runner/testdata/actions/node12/node_modules/@octokit/request/dist-web/index.js (about)

     1  import { endpoint } from '@octokit/endpoint';
     2  import { getUserAgent } from 'universal-user-agent';
     3  import { isPlainObject } from 'is-plain-object';
     4  import nodeFetch from 'node-fetch';
     5  import { RequestError } from '@octokit/request-error';
     6  
     7  const VERSION = "5.6.3";
     8  
     9  function getBufferResponse(response) {
    10      return response.arrayBuffer();
    11  }
    12  
    13  function fetchWrapper(requestOptions) {
    14      const log = requestOptions.request && requestOptions.request.log
    15          ? requestOptions.request.log
    16          : console;
    17      if (isPlainObject(requestOptions.body) ||
    18          Array.isArray(requestOptions.body)) {
    19          requestOptions.body = JSON.stringify(requestOptions.body);
    20      }
    21      let headers = {};
    22      let status;
    23      let url;
    24      const fetch = (requestOptions.request && requestOptions.request.fetch) || nodeFetch;
    25      return fetch(requestOptions.url, Object.assign({
    26          method: requestOptions.method,
    27          body: requestOptions.body,
    28          headers: requestOptions.headers,
    29          redirect: requestOptions.redirect,
    30      }, 
    31      // `requestOptions.request.agent` type is incompatible
    32      // see https://github.com/octokit/types.ts/pull/264
    33      requestOptions.request))
    34          .then(async (response) => {
    35          url = response.url;
    36          status = response.status;
    37          for (const keyAndValue of response.headers) {
    38              headers[keyAndValue[0]] = keyAndValue[1];
    39          }
    40          if ("deprecation" in headers) {
    41              const matches = headers.link && headers.link.match(/<([^>]+)>; rel="deprecation"/);
    42              const deprecationLink = matches && matches.pop();
    43              log.warn(`[@octokit/request] "${requestOptions.method} ${requestOptions.url}" is deprecated. It is scheduled to be removed on ${headers.sunset}${deprecationLink ? `. See ${deprecationLink}` : ""}`);
    44          }
    45          if (status === 204 || status === 205) {
    46              return;
    47          }
    48          // GitHub API returns 200 for HEAD requests
    49          if (requestOptions.method === "HEAD") {
    50              if (status < 400) {
    51                  return;
    52              }
    53              throw new RequestError(response.statusText, status, {
    54                  response: {
    55                      url,
    56                      status,
    57                      headers,
    58                      data: undefined,
    59                  },
    60                  request: requestOptions,
    61              });
    62          }
    63          if (status === 304) {
    64              throw new RequestError("Not modified", status, {
    65                  response: {
    66                      url,
    67                      status,
    68                      headers,
    69                      data: await getResponseData(response),
    70                  },
    71                  request: requestOptions,
    72              });
    73          }
    74          if (status >= 400) {
    75              const data = await getResponseData(response);
    76              const error = new RequestError(toErrorMessage(data), status, {
    77                  response: {
    78                      url,
    79                      status,
    80                      headers,
    81                      data,
    82                  },
    83                  request: requestOptions,
    84              });
    85              throw error;
    86          }
    87          return getResponseData(response);
    88      })
    89          .then((data) => {
    90          return {
    91              status,
    92              url,
    93              headers,
    94              data,
    95          };
    96      })
    97          .catch((error) => {
    98          if (error instanceof RequestError)
    99              throw error;
   100          throw new RequestError(error.message, 500, {
   101              request: requestOptions,
   102          });
   103      });
   104  }
   105  async function getResponseData(response) {
   106      const contentType = response.headers.get("content-type");
   107      if (/application\/json/.test(contentType)) {
   108          return response.json();
   109      }
   110      if (!contentType || /^text\/|charset=utf-8$/.test(contentType)) {
   111          return response.text();
   112      }
   113      return getBufferResponse(response);
   114  }
   115  function toErrorMessage(data) {
   116      if (typeof data === "string")
   117          return data;
   118      // istanbul ignore else - just in case
   119      if ("message" in data) {
   120          if (Array.isArray(data.errors)) {
   121              return `${data.message}: ${data.errors.map(JSON.stringify).join(", ")}`;
   122          }
   123          return data.message;
   124      }
   125      // istanbul ignore next - just in case
   126      return `Unknown error: ${JSON.stringify(data)}`;
   127  }
   128  
   129  function withDefaults(oldEndpoint, newDefaults) {
   130      const endpoint = oldEndpoint.defaults(newDefaults);
   131      const newApi = function (route, parameters) {
   132          const endpointOptions = endpoint.merge(route, parameters);
   133          if (!endpointOptions.request || !endpointOptions.request.hook) {
   134              return fetchWrapper(endpoint.parse(endpointOptions));
   135          }
   136          const request = (route, parameters) => {
   137              return fetchWrapper(endpoint.parse(endpoint.merge(route, parameters)));
   138          };
   139          Object.assign(request, {
   140              endpoint,
   141              defaults: withDefaults.bind(null, endpoint),
   142          });
   143          return endpointOptions.request.hook(request, endpointOptions);
   144      };
   145      return Object.assign(newApi, {
   146          endpoint,
   147          defaults: withDefaults.bind(null, endpoint),
   148      });
   149  }
   150  
   151  const request = withDefaults(endpoint, {
   152      headers: {
   153          "user-agent": `octokit-request.js/${VERSION} ${getUserAgent()}`,
   154      },
   155  });
   156  
   157  export { request };
   158  //# sourceMappingURL=index.js.map