Support File Arrays

Signed-off-by: Frank Jogeleit <frank.jogeleit@lovoo.com>

.github/dependabot.yml

@@ -0,0 +1,10 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "monthly"
+  - package-ecosystem: 'npm'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

.github/workflows/build-action.yml

@@ -0,0 +1,35 @@
+name: Build Action
+on:
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: The branch
+        type: string
+        default: main
+        required: true
+jobs:
+  build:
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout repo
+      uses: actions/checkout@v4
+      with:
+        ref: ${{ inputs.ref }}
+    - uses: actions/setup-node@v4
+      with:
+        node-version: '16'
+    - name: Install dependencies
+      run: |
+        npm ci
+    - name: Build Action
+      run: |
+        npm run build
+    - name: Update dist
+      run: |
+        git config user.name 'github-actions[bot]'
+        git config user.email 'github-actions[bot]@users.noreply.github.com'
+        git add ./dist &&
+        git commit -m "Update dist"
+        git push origin HEAD:${{ inputs.ref }}

.github/workflows/ci.yml

@@ -0,0 +1,184 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+      - 'releases/*'
+
+jobs:
+  build:
+    if: >
+      github.event_name == 'pull_request' &&
+      github.event.pull_request.user.login == 'dependabot[bot]'
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+    - id: ref
+      run: |
+        if [[ -n '${{ github.event.ref }}' ]]; then
+          branch="${{ github.event.ref }}"
+          echo "branch=$branch" >> $GITHUB_OUTPUT
+        else
+          branch="${{ github.event.pull_request.head.ref }}"
+          echo "branch=$branch" >> $GITHUB_OUTPUT
+        fi
+    - name: checkout repo
+      uses: actions/checkout@v4
+      with:
+        ref: ${{ steps.ref.outputs.branch }}
+    - uses: actions/setup-node@v4
+      with:
+        node-version: '16'
+    - name: Install dependencies
+      run: |
+        npm ci
+    - name: Build Action
+      run: |
+        npm run build
+    - name: Update dist
+      run: |
+        git config user.name 'github-actions[bot]'
+        git config user.email 'github-actions[bot]@users.noreply.github.com'
+        git add ./dist
+        if ! git diff --quiet dist; then
+          git commit -m "Update dist"
+          git push origin HEAD:${{ steps.ref.outputs.branch }}
+        fi
+  integrity:
+    if: >
+      !failure() &&
+      !cancelled()
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    steps:
+    - name: checkout repo
+      uses: actions/checkout@v4
+      with:
+        persist-credentials: false
+    - uses: actions/setup-node@v4
+      with:
+        node-version: '16.17.0'
+    - name: Build action
+      run: |
+        npm ci
+        npm run build
+    - name: Repository Integrity Check
+      run: |
+        git diff --quiet dist
+  test:
+    if: >
+      !failure() &&
+      !cancelled()
+    needs:
+      - integrity
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.ref }}
+
+      - name: Request Postman Echo GET
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/get'
+          method: 'GET'
+      
+      - name: Request Postman Echo POST
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          method: 'POST'
+          data: '{ "key": "value" }'
+      
+      - name: Request Postman Echo POST with Unescaped Newline
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          method: 'POST'
+          escapeData: 'true'
+          data: >-
+            {
+              "key":"multi line\ntest
+              text"
+            }
+      
+      - name: Request Postman Echo BasicAuth
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/basic-auth'
+          method: 'GET'
+          username: 'postman'
+          password: 'password'
+      
+      - name: Request Postman Echo with 404 Response and ignore failure code
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/status/404'
+          method: 'GET'
+          ignoreStatusCodes: '404'
+      
+      - name: Create Test File
+        run: |
+          echo "test" > testfile1.txt
+          echo "test" > testfile2.txt
+
+      - name: Request Postman Echo POST Multipart
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          method: 'POST'
+          data: '{ "key": "value" }'
+          files: '{ "file": "${{ github.workspace }}/testfile1.txt" }'
+
+      - name: Request Postman Echo POST Multipart File Array
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          method: 'POST'
+          data: '{ "key": "value" }'
+          files: '{ "file": ["${{ github.workspace }}/testfile1.txt", "${{ github.workspace }}/testfile2.txt"] }'
+
+      - name: Request Postman Echo POST and persist response
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          method: 'POST'
+          file: "${{ github.workspace }}/testfile1.txt"
+          responseFile: "${{ github.workspace }}/response.json"
+      - name: Output responseFile
+        run: |
+          cat "${{ github.workspace }}/response.json"
+
+      - name: Request Postman Echo POST Multipart without data
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          method: 'POST'
+          files: '{ "file": "${{ github.workspace }}/testfile1.txt" }'
+
+      - name: Request Postman Echo POST single file
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          method: 'POST'
+          file: "${{ github.workspace }}/testfile1.txt"
+
+      - name: Request Postman Echo POST URLEncoded string data
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          contentType : 'application/x-www-form-urlencoded'
+          method: 'POST'
+          data: 'key=value'
+
+      - name: Request Postman Echo POST URLEncoded json data
+        uses: ./
+        with:
+          url: 'https://postman-echo.com/post'
+          contentType : 'application/x-www-form-urlencoded'
+          method: 'POST'
+          data: '{"key":"value"}'

.gitignore

@@ -1 +1,2 @@
 node_modules
+.vscode

README.md

@@ -1,34 +1,102 @@
 # HTTP Request Action
 
-Create any kind of HTTP Requests in your GitHub actions to trigger Tools like Ansible AWX
+**Create HTTP Requests from GitHub Actions.** This action allows GitHub events to engage with tools like Ansible AWX that use HTTP APIs.
 
-Exmaple Usage:
-```
+### Example
+```yaml
 jobs:
-    deployment
-        - name: Deploy Stage
-            uses: fjogeleit/http-request-action@master
-            with:
-                url: 'https://ansible.io/api/v2/job_templates/84/launch/'
-                method: 'POST'
-                username: ${{ secrets.AWX_USER }}
-                password: ${{ secrets.AWX_PASSWORD }}
+  deployment:
+    runs-on: ubuntu-latest
+    steps:
+    - name: Deploy Stage
+      uses: fjogeleit/http-request-action@v1
+      with:
+        url: 'https://ansible.io/api/v2/job_templates/84/launch/'
+        method: 'POST'
+        username: ${{ secrets.AWX_USER }}
+        password: ${{ secrets.AWX_PASSWORD }}
+        customHeaders: '{"Content-Type": "application/json"}'
+        data: '{"key_1": "value_1", "key_2": "value_2"}'
 ```
 
-### Input Arguments
+### Versioning
+
+`master` branch is deprecated. Please use `main` or `v1` to get the latest version of this action. It is recommended to use a fixed version.
+
+### Request Configuration
 
 |Argument|  Description  |  Default  |
 |--------|---------------|-----------|
 |url     | Request URL   | _required_ Field |
 |method  | Request Method| POST |
 |contentType  | Request ContentType| application/json |
-|data    | Request Body Content as JSON String, only for POST / PUT / PATCH Requests | '{}' |
+|data    | Request Body Content:<br>- text content like JSON or XML<br>- key=value pairs separated by '&' or JSON data and contentType: application/x-www-form-urlencoded<br><br>only for POST / PUT / PATCH Requests | '{}' |
+|files    | Map of key / absolute file paths send as multipart/form-data request to the API, if set the contentType is set to multipart/form-data, values provided by data will be added as additional FormData values, nested objects are not supported. **Example provided in the _test_ Workflow of this Action** | '{}' |
+|file    | Single absolute file path send as `application/octet-stream` request to the API, if set the contentType is set to `application/octet-stream`. This input will be ignored if either `data` or `files` input is present. **Example provided in the _test_ Workflow of this Action** ||
 |timeout| Request Timeout in ms | 5000 (5s) |
 |username| Username for Basic Auth ||
 |password| Password for Basic Auth ||
 |bearerToken| Bearer Authentication Token (without Bearer Prefix) ||
 |customHeaders| Additional header values as JSON string, keys in this object overwrite default headers like Content-Type |'{}'|
+|escapeData| Escape newlines in data string content. Use 'true' (string) as value to enable it ||
+|preventFailureOnNoResponse| Prevent this Action to fail if the request respond without an response. Use 'true' (string) as value to enable it ||
+|ignoreStatusCodes| Prevent this Action to fail if the request respond with one of the configured Status Codes. Example: '404,401' ||
+|httpsCA| Certificate authority as string in PEM format ||
+|httpsCert| Client Certificate as string ||
+|httpsKey| Client Certificate Key as string ||
+|responseFile| Persist the response data to the specified file path ||
+|retry| optional amount of retries if the request is failing, does not retry if the status code is ignored ||
+|retryWait| time between each retry in millseconds | 3000 |
 
-### Output
+### Response
 
-- `response` Request Response as JSON String
+| Variable |  Description  |
+|---|---|
+`response` | Response as JSON String
+`headers` | Headers
+
+To display HTTP response data in the GitHub Actions log give the request an `id` and access its `outputs`. You can also access specific field from the response data using [fromJson()](https://docs.github.com/en/actions/learn-github-actions/expressions#fromjson) expression.
+
+```yaml
+steps:
+  - name: Make Request
+    id: myRequest
+    uses: fjogeleit/http-request-action@v1
+    with:
+      url: "http://yoursite.com/api"
+  - name: Show Response
+    run: |
+      echo ${{ steps.myRequest.outputs.response }}
+      echo ${{ steps.myRequest.outputs.headers }}
+      echo ${{ fromJson(steps.myRequest.outputs.response).field_you_want_to_access }}
+```
+
+### Additional Information
+
+Additional information is available if debug logging is enabled:
+- Instance Configuration (Url / Timeout / Headers)
+- Request Data (Body / Auth / Method)
+
+To [enable debug logging in GitHub Actions](https://docs.github.com/en/actions/managing-workflow-runs/enabling-debug-logging) create a secret `ACTIONS_RUNNER_DEBUG` with a value of `true`
+
+#### Local Usage
+
+* You can execute this tool locally with the provided CLI `bin/http-action`.
+
+```bash
+bin/http-action --help                   
+Positionals:
+  url  request URL                                                     [string]
+
+Optionen:
+      --help           helper text                                     [boolean]
+  -d, --data           request body data                               [string] [default: "{}"]
+  -f, --files          request files, send as multipart/form-data      [string] [default: "{}"]
+      --file           single file, send as application/octet-stream   [string]
+  -h, --customHeaders  custom request headers                          [string] [default: "{}"]
+  -m, --method         request method (GET, POST, PATCH, PUT, DELETE)  [string] [default: "POST"]
+  -t, --contentType    request content type                            [string] [default: "application/json"]
+      --bearerToken    bearer token without Bearer prefix, added as
+                       Authorization header                            [string]
+      --timeout        request timeout                                 [number] [default: 5000]
+```

action.yml

@@ -11,11 +11,17 @@ inputs:
     contentType:
         description: 'Content Type'
         required: false
-        default: 'application/json'
     data:
         description: 'Request Body as JSON String'
         required: false
         default: '{}'
+    files:
+        description: 'Map of absolute file paths as JSON String'
+        required: false
+        default: '{}'
+    file:
+        description: 'A single absolute file path'
+        required: false
     username:
         description: 'Auth Username'
         required: false
@@ -29,9 +35,41 @@ inputs:
     bearerToken:
         description: 'Bearer Authentication Token'
         required: false
+    customHeaders:
+        description: 'Custom HTTP Headers'
+        required: false
+    preventFailureOnNoResponse:
+        description: 'Prevent this Action to fail if the request respond without an response'
+        required: false
+    ignoreStatusCodes:
+        description: 'Prevent this Action to fail if the request respond with one of the configured StatusCodes'
+        required: false
+    escapeData:
+        description: 'Escape newlines in data string content'
+        required: false
+    httpsCA:
+        description: 'Certificate authority as string in PEM format'
+        required: false
+    httpsCert:
+        description: 'Client Certificate as string'
+        required: false
+    httpsKey:
+        description: 'Client Certificate Key as string'
+        required: false
+    responseFile:
+        description: 'Persist the response data to the specified file path'
+        required: false
+    retry:
+        description: 'optional amount of retries if the request fails'
+        required: false
+    retryWait:
+        description: 'wait time between retries in milliseconds'
+        required: false
 outputs:
     response:
         description: 'HTTP Response Content'
+    headers:
+        description: 'HTTP Response Headers'
 runs:
-    using: 'node12'
+    using: 'node16'
     main: 'dist/index.js'

bin/http-action

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+const yargs = require('yargs/yargs')
+const { hideBin } = require('yargs/helpers')
+const { LogActions } = require('../src/githubActions.js')
+const { request } = require('../src/httpClient');
+
+const argv = yargs(hideBin(process.argv))
+    .option('data', { alias: 'd', type: 'string', description: 'request body data', default: '{}' })
+    .option('files', { alias: 'f', type: 'string', description: 'request files, send as multipart/form-data', default: '{}' })
+    .option('file', { type: 'string', description: 'single file, send as application/octet-stream' })
+    .option('customHeaders', { alias: 'h', type: 'string', description: 'custom request headers', default: '{}' })
+    .option('method', { alias: 'm', type: 'string', description: 'request method (GET, POST, PATCH, PUT, DELETE)', default: 'POST' })
+    .option('contentType', { alias: 't', type: 'string', description: 'request content type', default: 'application/json' })
+    .option('bearerToken', { type: 'string', description: 'bearer token without Bearer prefix, added as Authorization header' })
+    .option('timeout', { type: 'number', description: 'request timeout', default: 5000 })
+    .positional('url', { type: 'string', description: 'URL', description: 'request URL' })
+    .parse()
+
+let customHeaders = {}
+
+if (!!argv.customHeaders) {
+    try {
+        customHeaders = JSON.parse(argv.customHeaders);
+    } catch(error) {
+        console.error('Could not parse customHeaders string value')
+    }
+}
+    
+const headers = { 'Content-Type': argv.contentType || 'application/json' }
+
+if (!!argv.bearerToken) {
+    headers['Authorization'] = `Bearer ${argv.bearerToken}`;
+}
+
+const instanceConfig = {
+    baseURL: argv._[0],
+    timeout: parseInt(argv.timeout || 5000, 10),
+    headers: { ...headers, ...customHeaders }
+}
+
+request({ 
+    data: argv.data,
+    method: argv.method,
+    instanceConfig,
+    files: argv.files,
+    file: argv.file,
+    actions: new LogActions(),
+    options: {
+        ignoredCodes: [],
+        escapeData: false,
+        preventFailureOnNoResponse: false,
+        retry: 0,
+        retryWait: 0
+    }
+})

package.json

@@ -1,6 +1,6 @@
 {
   "name": "http-request-action",
-  "version": "1.0.0",
+  "version": "1.14.2",
   "description": "",
   "main": "src/index.js",
   "private": false,
@@ -13,16 +13,23 @@
   },
   "keywords": [],
   "author": "",
-  "license": "ISC",
+  "license": "MIT",
   "bugs": {
     "url": "https://github.com/fjogeleit/http-request-action/issues"
   },
   "homepage": "https://github.com/fjogeleit/http-request-action#readme",
   "devDependencies": {
-    "@actions/core": "^1.2.2"
+    "@vercel/ncc": "^0.38.1",
+    "axios": "^1.6",
+    "form-data": "^4.0.0",
+    "yargs": "^17.7.2"
   },
   "dependencies": {
-    "@zeit/ncc": "^0.21.1",
-    "axios": "^0.19.2"
+    "@actions/core": "^1.10.1",
+    "install": "^0.13.0",
+    "npm": "^10.2.4"
+  },
+  "engines": {
+    "node": ">=16.0.0"
   }
 }

src/githubActions.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const core = require("@actions/core");
+
+class GithubActions {
+  debug(message) {
+    core.debug(message)
+  }
+
+  info(message) {
+    core.info(message)
+  }
+
+  warning(message) {
+    core.warning(message)
+  }
+
+  setOutput(name, output) {
+    core.setOutput(name, output)
+  }
+
+  setFailed(message) {
+    core.setFailed(message)
+  }
+}
+
+class LogActions {
+  info(message) {
+    console.info(message)
+  }
+
+  debug(message) {
+    console.info(message)
+  }
+
+  warning(message) {
+    console.warn(message)
+  }
+
+  setOutput(name, output) {
+    console.log(name, output)
+  }
+
+  setFailed(message) {
+    console.error(message)
+  }
+}
+
+module.exports = { GithubActions, LogActions }

src/handler/persist.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const axios = require('axios');
+const fs = require('fs');
+const { GithubActions } = require('../githubActions');
+
+/**
+ * @param {string} filePath
+ * @param {GithubActions} actions
+ * 
+ * @returns {(response: axios.AxiosResponse) => void}
+ */
+const createPersistHandler = (filePath, actions) => (response) => {
+    let data = response.data
+
+    if (typeof data == 'object') {
+        data = JSON.stringify(data)
+    }
+
+    fs.writeFile(filePath, data, err => {
+        if (!err) {
+            actions.info(`response persisted successfully at ${filePath}`)
+            return
+        }
+    
+        actions.warning(JSON.stringify({ message: error.message, data: response.data }))
+    })
+}
+
+module.exports = { createPersistHandler }

src/helper.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const { GithubActions } = require('./githubActions');
+const FormData = require('form-data');
+const fs = require('fs');
+
+/**
+ * @param {string} value
+ *
+ * @returns {Object}
+ */
+const convertToJSON = (value) => {
+  try {
+    return JSON.parse(value) || {};
+  } catch (e) {
+    return {};
+  }
+};
+
+/**
+ * @param {{ [key: string]: string }}  data
+ * @param {{ [key: string]: string }}  files
+ * @param {boolean} convertPaths
+ *
+ * @returns {FormData}
+ */
+const convertToFormData = async (data, files, convertPaths) => {
+  const formData = new FormData();
+
+  for (const [key, value] of Object.entries(data)) {
+    formData.append(key, value);
+  }
+
+  for (const [key, value] of Object.entries(files)) {
+    if (Array.isArray(value)) {
+      value.forEach(v => formData.append(key, fs.createReadStream(v)))
+    } else {
+      formData.append(key, fs.createReadStream(value));
+    }
+  }
+
+  return formData;
+};
+
+/**
+ * @param {() => Promise} callback
+ * @param {{ retry: number; sleep: number; actions: GithubActions }} options
+ *
+ * @returns {Promise}
+ */
+const retry = async (callback, options) => {
+  let lastErr = null;
+  let i = 0;
+
+  do {
+    try {
+      return await callback();
+    } catch (err) {
+      lastErr = err;
+    }
+
+    if (i < options.retries) {
+      options.actions.warning(`#${i + 1} request failed: ${err}`);
+      await sleep(options.sleep);
+    }
+
+    i++;
+  } while (i <= options.retry);
+
+  throw lastErr;
+};
+
+function sleep(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+module.exports = {
+  convertToJSON,
+  convertToFormData,
+  retry,
+};

src/httpClient.js

@@ -0,0 +1,214 @@
+'use strict'
+
+const axios = require('axios');
+const FormData = require('form-data');
+const fs = require('fs');
+const url = require('url');
+const { GithubActions } = require('./githubActions');
+const { convertToJSON, convertToFormData, retry } = require('./helper');
+
+const METHOD_GET = 'GET'
+const METHOD_POST = 'POST'
+
+const HEADER_CONTENT_TYPE = 'Content-Type'
+
+const CONTENT_TYPE_URLENCODED = 'application/x-www-form-urlencoded'
+
+/**
+ * @param {Object} param0
+ * @param {string} param0.method HTTP Method
+ * @param {axios.AxiosRequestConfig} param0.instanceConfig
+ * @param {string} param0.data Request Body as string, default {}
+ * @param {string} param0.files Map of Request Files (name: absolute path) as JSON String, default: {}
+ * @param {string} param0.file Single request file (absolute path)
+ * @param {GithubActions} param0.actions 
+ * @param {{ 
+ *  ignoredCodes: number[];
+ *  preventFailureOnNoResponse: boolean,
+ *  escapeData: boolean;
+ *  retry: number;
+ *  retryWait: number;
+ * }} param0.options
+ *
+ * @returns {Promise<axios.AxiosResponse>}
+ */
+const request = async({ method, instanceConfig, data, files, file, actions, options }) => {
+  actions.debug(`options: ${JSON.stringify(options)}`)
+  
+  try {
+    if (options.escapeData) {
+      data = data.replace(/"[^"]*"/g, (match) => { 
+        return match.replace(/[\n\r]\s*/g, "\\n");
+      }); 
+    }
+
+    if (method === METHOD_GET) {
+      data = undefined;
+    }
+
+    if (files && files !== '{}') {
+      let filesJson = convertToJSON(files)
+      let dataJson = convertToJSON(data)
+
+      if (Object.keys(filesJson).length > 0) {
+        try {
+          data = convertToFormData(dataJson, filesJson)
+          instanceConfig = await updateConfig(instanceConfig, data, actions)
+        } catch(error) {
+          actions.setFailed(JSON.stringify({ message: `Unable to convert Data and Files into FormData: ${error.message}`, data: dataJson, files: filesJson }))
+          return
+        }
+      }
+    }
+
+    // Only consider file if neither data nor files provided
+    if ((!data || data === '{}') && (!files || files === '{}') && file) {
+      data = fs.createReadStream(file)
+      updateConfigForFile(instanceConfig, file, actions)
+    }
+
+    if (instanceConfig.headers[HEADER_CONTENT_TYPE] === CONTENT_TYPE_URLENCODED) {
+      let dataJson = convertToJSON(data)
+      if (typeof dataJson === 'object' && Object.keys(dataJson).length) {
+        data = (new url.URLSearchParams(dataJson)).toString();
+      }
+    }
+
+    const requestData = {
+      method,
+      data,
+      maxContentLength: Infinity,
+      maxBodyLength: Infinity
+    }
+
+    actions.debug('Instance Configuration: ' + JSON.stringify(instanceConfig))
+    
+    /** @type {axios.AxiosInstance} */
+    const instance = axios.create(instanceConfig);
+
+    actions.debug('Request Data: ' + JSON.stringify(requestData))
+
+    const execRequest = async () => {
+      try {
+        return await instance.request(requestData)
+      } catch(error) {
+        if (error.response && options.ignoredCodes.includes(error.response.status)) {
+          actions.warning(`ignored status code: ${JSON.stringify({ code: error.response.status, message: error.response.data })}`)
+          
+          return null
+        }
+        
+        if (!error.response && error.request && options.preventFailureOnNoResponse) {
+          actions.warning(`no response received: ${JSON.stringify(error)}`);
+
+          return null
+        }
+
+        throw error
+      }
+    }
+
+    /** @type {axios.AxiosResponse|null} */
+    const response = await retry(execRequest, {
+      actions,
+      retry: options.retry || 0,
+      sleep: options.retryWait // wait time after each retry
+    })
+
+    if (!response) {
+      return null
+    }
+
+    actions.setOutput('response', JSON.stringify(response.data))
+    actions.setOutput('headers', response.headers)
+
+    return response
+  } catch (error) {
+    if ((typeof error === 'object') && (error.isAxiosError === true)) {
+      const { name, message, code, response } = error
+      actions.setOutput('requestError', JSON.stringify({ name, message, code, status: response && response.status ? response.status : null }));
+    }
+
+    if (error.response) {
+      actions.setFailed(JSON.stringify({ code: error.response.status, message: error.response.data }))
+    } else if (error.request) {
+      actions.setFailed(JSON.stringify({ error: "no response received" }));
+    } else {
+      actions.setFailed(JSON.stringify({ message: error.message, data }));
+    }
+  }
+}
+
+/**
+ * @param {{ baseURL: string; timeout: number; headers: { [name: string]: string } }} instanceConfig
+ * @param {FormData} formData
+ * @param {*} actions
+ *
+ * @returns {Promise<{ baseURL: string; timeout: number; headers: { [name: string]: string } }>}
+ */
+const updateConfig = async (instanceConfig, formData, actions) => {
+  try {
+    const formHeaders = formData.getHeaders()
+    const contentType = formHeaders['content-type']
+
+    delete formHeaders['content-type']
+
+    return { 
+      ...instanceConfig, 
+      headers: { 
+        ...instanceConfig.headers, 
+        ...formHeaders,
+        'Content-Length': await contentLength(formData),
+        'Content-Type': contentType
+      }
+    }
+  } catch(error) {
+    actions.setFailed({ message: `Unable to read Content-Length: ${error.message}`, data, files })
+  }
+}
+
+/**
+ * @param instanceConfig
+ * @param filePath
+ * @param {*} actions
+ *
+ * @returns {{ baseURL: string; timeout: number; headers: { [name: string]: string } }}
+ */
+const updateConfigForFile = (instanceConfig, filePath, actions) => {
+  try {
+    const { size } = fs.statSync(filePath)
+
+    return {
+      ...instanceConfig,
+      headers: {
+        ...instanceConfig.headers,
+        'Content-Length': size,
+        'Content-Type': 'application/octet-stream'
+      }
+    }
+  } catch(error) {
+    actions.setFailed({ message: `Unable to read Content-Length: ${error.message}`, data, files })
+  }
+}
+
+/**
+ * @param {FormData} formData
+ *
+ * @returns {Promise<number>}
+ */
+const contentLength = (formData) => new Promise((resolve, reject) => {
+  formData.getLength((err, length) => {
+    if (err) {
+      reject (err)
+      return
+    }
+
+    resolve(length)
+  })
+})
+
+module.exports = {
+  request,
+  METHOD_POST,
+  METHOD_GET,
+}

src/index.js

@@ -1,48 +1,95 @@
-const core = require("@actions/core");
-const axios = require("axios");
+'use strict'
+
+const core = require('@actions/core');
+const axios = require('axios');
+const https = require('https');
+const { request, METHOD_POST } = require('./httpClient');
+const { GithubActions } = require('./githubActions');
+const { createPersistHandler } = require('./handler/persist');
 
-const auth = {}
 let customHeaders = {}
 
 if (!!core.getInput('customHeaders')) {
   try {
     customHeaders = JSON.parse(core.getInput('customHeaders'));
   } catch(error) {
-    core.error('Could not parse customHeaders string value')
+    core.debug(`Invalid customHeaders string: ${core.getInput('customHeaders')}`)
+    core.error(`Could not parse customHeaders string value: ${error}`)
   }
 }
 
 const headers = { 'Content-Type': core.getInput('contentType') || 'application/json' }
 
-if (!!core.getInput('username')) {
-  auth.username = core.getInput('username');
-}
-
-if (!!core.getInput('password')) {
-  auth.password = core.getInput('password');
-}
-
 if (!!core.getInput('bearerToken')) {
-  headers['Authentication'] = `Bearer ${core.getInput('bearerToken')}`;
+  headers['Authorization'] = `Bearer ${core.getInput('bearerToken')}`;
 }
 
-const instance = axios.create({
+/** @type {axios.AxiosRequestConfig} */
+const instanceConfig = {
   baseURL: core.getInput('url', { required: true }),
   timeout: parseInt(core.getInput('timeout') || 5000, 10),
   headers: { ...headers, ...customHeaders }
-});
+}
 
+if (!!core.getInput('httpsCA') || !!core.getInput('httpsCert')) {
+  instanceConfig.httpsAgent = new https.Agent({ 
+    ca: core.getInput('httpsCA') || undefined,
+    cert: core.getInput('httpsCert') || undefined,
+    key: core.getInput('httpsKey') || undefined
+  })
+}
 
-(async() => {
-  try {
-    const response = await instance.request({
-      auth,
-      method: core.getInput('method') || 'POST',
-      data: JSON.parse(core.getInput('data') || '{}')
-    })
+if (!!core.getInput('username') || !!core.getInput('password')) {
+  core.debug('Add BasicHTTP Auth config')
 
-    core.setOutput('response', JSON.stringify(response.data))
-  } catch (error) {
-    core.setFailed(JSON.stringify({ code: error.response.code, message: error.response.data }))
+  instanceConfig.auth = {
+    username: core.getInput('username'),
+    password: core.getInput('password')
   }
-})()
+}
+
+let retry = 0
+if (!!core.getInput('retry')) {
+  retry = parseInt(core.getInput('retry'))
+}
+
+let retryWait = 3000
+if (!!core.getInput('retryWait')) {
+  retry = parseInt(core.getInput('retryWait'))
+}
+
+const data = core.getInput('data') || '{}';
+const files = core.getInput('files') || '{}';
+const file = core.getInput('file')
+const responseFile = core.getInput('responseFile')
+const method = core.getInput('method') || METHOD_POST;
+const preventFailureOnNoResponse = core.getInput('preventFailureOnNoResponse') === 'true';
+const escapeData = core.getInput('escapeData') === 'true';
+
+const ignoreStatusCodes = core.getInput('ignoreStatusCodes');
+let ignoredCodes = [];
+
+if (typeof ignoreStatusCodes === 'string' && ignoreStatusCodes.length > 0) {
+  ignoredCodes = ignoreStatusCodes.split(',').map(statusCode => parseInt(statusCode.trim()))
+}
+
+const handler = [];
+const actions = new GithubActions();
+
+if (!!responseFile) {
+  handler.push(createPersistHandler(responseFile, actions))
+}
+
+const options = {
+  ignoredCodes,
+  preventFailureOnNoResponse,
+  escapeData,
+  retry,
+  retryWait
+}
+
+request({ data, method, instanceConfig, files, file, actions, options }).then(response => {
+  if (typeof response == 'object') {
+    handler.forEach(h => h(response))
+  }
+})