Kulala.nvim

https://neovim.getkulala.net/docs/
Admin
Kulala.nvim is a minimal HTTP client interface for Neovim that allows users to make REST API...
Tokens:42,745
Snippets:272
Trust Score:4.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### HTTP Request Examples

Source: https://neovim.getkulala.net/docs/usage/demos

Demonstrates basic HTTP request methods like GET, POST, PUT, and DELETE. It shows how to send requests with query parameters and JSON bodies. Useful for understanding fundamental HTTP interactions.

```http
### Simple GET request  
  
GET https://httpbin.org/get HTTP/1.1  
  
### GET with query parameters  
  
GET https://httpbin.org/get?name=kulala&age=25 HTTP/1.1  
  
### POST with JSON body  
  
POST https://httpbin.org/post HTTP/1.1  
  
  
{
  "name": "John Doe",
  "email": "john@example.com"
}
  
### PUT with headers  
  
PUT https://httpbin.org/put HTTP/1.1  
  
  
  
{
  "id": 1,
  "status": "updated"
}
  
### DELETE request  
  
DELETE https://httpbin.org/delete HTTP/1.1  
  
### GET with multiple headers  
  
GET https://httpbin.org/headers HTTP/1.1  
  
  

```

--------------------------------

### Basic HTTP Requests

Source: https://neovim.getkulala.net/docs/usage/demos

Demonstrates fundamental HTTP methods like GET, POST, PUT, and DELETE, including examples with query parameters and JSON bodies.

```APIDOC
## GET /get

### Description
Performs a simple GET request to retrieve data.

### Method
GET

### Endpoint
https://httpbin.org/get

### Parameters
#### Query Parameters
- **name** (string) - Optional - The name parameter.
- **age** (string) - Optional - The age parameter.

### Request Example
```
GET https://httpbin.org/get?name=kulala&age=25 HTTP/1.1
```

### Response
#### Success Response (200)
- **args** (object) - Query parameters.
- **headers** (object) - Request headers.
- **origin** (string) - Client IP address.
- **url** (string) - The requested URL.

#### Response Example
```json
{
  "args": {
    "name": "kulala",
    "age": "25"
  },
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org"
  },
  "origin": "127.0.0.1",
  "url": "https://httpbin.org/get?name=kulala&age=25"
}
```

## POST /post

### Description
Sends a POST request with a JSON body to create or update a resource.

### Method
POST

### Endpoint
https://httpbin.org/post

### Parameters
#### Request Body
- **name** (string) - Required - The name of the user.
- **email** (string) - Required - The email of the user.

### Request Example
```json
{
  "name": "John Doe",
  "email": "john@example.com"
}
```

### Response
#### Success Response (200)
- **args** (object) - Query parameters.
- **data** (string) - The request body as a string.
- **files** (object) - Uploaded files (if any).
- **form** (object) - Form data (if any).
- **headers** (object) - Request headers.
- **json** (object) - The request body parsed as JSON.
- **origin** (string) - Client IP address.
- **url** (string) - The requested URL.

#### Response Example
```json
{
  "args": {},
  "data": "{\"name\": \"John Doe\", \"email\": \"john@example.com\"}",
  "files": {},
  "form": {},
  "headers": {
    "Accept": "*/*",
    "Content-Length": "40",
    "Content-Type": "application/json",
    "Host": "httpbin.org"
  },
  "json": {
    "name": "John Doe",
    "email": "john@example.com"
  },
  "origin": "127.0.0.1",
  "url": "https://httpbin.org/post"
}
```

## PUT /put

### Description
Sends a PUT request with a JSON body to update a resource.

### Method
PUT

### Endpoint
https://httpbin.org/put

### Parameters
#### Request Body
- **id** (integer) - Required - The ID of the resource to update.
- **status** (string) - Required - The new status of the resource.

### Request Example
```json
{
  "id": 1,
  "status": "updated"
}
```

### Response
#### Success Response (200)
- **args** (object) - Query parameters.
- **data** (string) - The request body as a string.
- **files** (object) - Uploaded files (if any).
- **form** (object) - Form data (if any).
- **headers** (object) - Request headers.
- **json** (object) - The request body parsed as JSON.
- **origin** (string) - Client IP address.
- **url** (string) - The requested URL.

#### Response Example
```json
{
  "args": {},
  "data": "{\"id\": 1, \"status\": \"updated\"}",
  "files": {},
  "form": {},
  "headers": {
    "Accept": "*/*",
    "Content-Length": "28",
    "Content-Type": "application/json",
    "Host": "httpbin.org"
  },
  "json": {
    "id": 1,
    "status": "updated"
  },
  "origin": "127.0.0.1",
  "url": "https://httpbin.org/put"
}
```

## DELETE /delete

### Description
Sends a DELETE request to remove a resource.

### Method
DELETE

### Endpoint
https://httpbin.org/delete

### Response
#### Success Response (200)
- **args** (object) - Query parameters.
- **data** (string) - The request body as a string.
- **files** (object) - Uploaded files (if any).
- **form** (object) - Form data (if any).
- **headers** (object) - Request headers.
- **json** (object) - The request body parsed as JSON.
- **origin** (string) - Client IP address.
- **url** (string) - The requested URL.

#### Response Example
```json
{
  "args": {},
  "data": "",
  "files": {},
  "form": {},
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org"
  },
  "json": null,
  "origin": "127.0.0.1",
  "url": "https://httpbin.org/delete"
}
```

## GET /headers

### Description
Sends a GET request to retrieve information about the request headers.

### Method
GET

### Endpoint
https://httpbin.org/headers

### Response
#### Success Response (200)
- **headers** (object) - The headers received by the server.

#### Response Example
```json
{
  "headers": {
    "Accept": "*/*",
    "Host": "httpbin.org"
  }
}
```
```

--------------------------------

### Cookie Management

Source: https://neovim.getkulala.net/docs/usage/demos

Demonstrates how to set cookies using a GET request and how subsequent requests can utilize these cookies.

```APIDOC
## GET /cookies/set

### Description
Sets sample and test cookies in the client's browser.

### Method
GET

### Endpoint
https://httpbin.org/cookies/set

### Parameters
#### Query Parameters
- **sample** (string) - Required - The value for the 'sample' cookie.
- **test** (string) - Required - The value for the 'test' cookie.

### Request Example
```
GET https://httpbin.org/cookies/set?sample=cookie123&test=cookie456 HTTP/1.1
```

## GET /cookies

### Description
Retrieves the cookies that the client has sent with the request.

### Method
GET

### Endpoint
https://httpbin.org/cookies

### Response
#### Success Response (200)
- **cookies** (object) - An object containing the cookies sent by the client.

#### Response Example
```json
{
  "cookies": {
    "sample": "cookie123",
    "test": "cookie456"
  }
}
```
```

--------------------------------

### Configure Kulala.nvim with lazy.nvim (Lua)

Source: https://neovim.getkulala.net/docs/getting-started/install

This snippet demonstrates the basic configuration for the kulala.nvim plugin using the lazy.nvim package manager in Neovim. It includes setting up keybindings, filetype detection, and plugin options. Ensure Neovim version 0.10.0+ is installed.

```lua
require("lazy").setup({
  {
    "mistweaverco/kulala.nvim",
    keys = {
      { "<leader>Rs", desc = "Send request" },
      { "<leader>Ra", desc = "Send all requests" },
      { "<leader>Rb", desc = "Open scratchpad" },
    },
    ft = { "http", "rest" },
    opts = {
      -- your configuration comes here
      global_keymaps = false,
      global_keymaps_prefix = "<leader>R",
      kulala_keymaps_prefix = "",
    },
  },
})

```

--------------------------------

### HTTP Cookie Management

Source: https://neovim.getkulala.net/docs/usage/demos

Demonstrates how to set cookies using a GET request with cookie parameters and then how to access a protected resource that requires these cookies. This is useful for managing session state in HTTP requests.

```http
### Set cookies  
  
### setCookies  
GET https://httpbin.org/cookies/set?sample=cookie123&test=cookie456 HTTP/1.1  
  
### Call protected resource with cookies  
  
GET https://httpbin.org/cookies HTTP/1.1  
  

```

--------------------------------

### Fetch Kulala-FMT submodule (Bash)

Source: https://neovim.getkulala.net/docs/getting-started/install

This command is used to fetch the Kulala-FMT submodule, which is required for Kulala's built-in formatter for HTTP files. This is necessary if your package manager does not automatically handle submodules.

```bash
git fetch --recurse-submodules

```

--------------------------------

### Example gRPC Request: SayHello

Source: https://neovim.getkulala.net/docs/usage/grpc

This example demonstrates a complete gRPC request using specific flags and parameters. It includes importing proto files and calling the SayHello method of the Greeter service.

```shell
# @grpc-global-import-path ../protos   
# @grpc-global-proto helloworld.proto  
GRPC localhost:50051 helloworld.Greeter/SayHello  
  
  
{"name": "world"}  
  

```

--------------------------------

### Kulala CLI Execution Examples

Source: https://neovim.getkulala.net/docs/usage/cli-ci

Demonstrates practical examples of using the Kulala CLI to execute HTTP requests. These examples showcase filtering by environment, view, name, and line number, as well as listing requests within a file or directory.

```bash
kulala_cli http_examples/cli.http -e prod -v report -n Login Request -l 15 20   
kulala_cli cli.http grpc.http  
kulala_cli http_examples --list  
```

--------------------------------

### Variable Usage and API Integration

Source: https://neovim.getkulala.net/docs/usage/demos

Demonstrates how to use variables for base URLs and API keys, and how to make requests to external APIs like TheCatAPI.

```APIDOC
## GET /v1/images/search

### Description
Retrieves a list of random cat images from TheCatAPI.

### Method
GET

### Endpoint
https://api.thecatapi.com/v1/images/search

### Parameters
#### Query Parameters
- **limit** (integer) - Optional - The maximum number of images to return.

### Request Example
```
@BASE_URL = https://api.thecatapi.com/v1
@API_KEY = your_api_key_here

GET {{BASE_URL}}/images/search?limit=3 HTTP/1.1
```

### Response
#### Success Response (200)
- **id** (string) - Unique identifier for the image.
- **url** (string) - URL of the cat image.

#### Response Example
```json
[
  {
    "id": "2t",
    "url": "https://cdn2.thecatapi.com/images/2t.jpg"
  }
]
```

## GET /v1/breeds

### Description
Retrieves a list of cat breeds.

### Method
GET

### Endpoint
{{FROM_ENV_FILE_URL}}/breeds

### Response
#### Success Response (200)
- **weight** (object) - Weight characteristics of the breed.
- **id** (string) - Unique identifier for the breed.
- **name** (string) - Name of the cat breed.
- **temperament** (string) - Temperament of the cat breed.
- **origin** (string) - Origin country of the cat breed.
- **country_codes** (string) - ISO codes for the country of origin.

#### Response Example
```json
[
  {
    "weight": {
      "imperial": "7-10",
      "metric": "3-5"
    },
    "id": "abys",
    "name": "Abyssinian",
    "temperament": "Active, Energetic, Independent, Intelligent, Playful",
    "origin": "Egypt",
    "country_codes": "EG"
  }
]
```
```

--------------------------------

### Authentication and Token Handling

Source: https://neovim.getkulala.net/docs/usage/demos

Shows how to simulate a login process to obtain an access token and how to use it in subsequent requests, including Bearer tokens and custom headers.

```APIDOC
## POST /post (Login)

### Description
Simulates a user login to obtain an access token.

### Method
POST

### Endpoint
https://httpbin.org/post

### Parameters
#### Request Body
- **username** (string) - Required - The username for login.
- **password** (string) - Required - The password for login.
- **access_token** (string) - Included in the example response, not typically sent.

### Request Example
```json
{
  "username": "demo",
  "password": "demo123"
}
```

### Response
#### Success Response (200)
- **json** (object) - The parsed JSON request body, may include an access token.

#### Response Example
```json
{
  "json": {
    "username": "demo",
    "password": "demo123",
    "access_token": "asdfasdfasdfasdf"
  }
}
```

## GET /bearer

### Description
Accesses a protected resource using a Bearer token in the Authorization header.

### Method
GET

### Endpoint
https://httpbin.org/bearer

### Response
#### Success Response (200)
- **headers** (object) - The headers received by the server, including Authorization.

#### Response Example
```json
{
  "headers": {
    "Accept": "*/*",
    "Authorization": "Bearer your_token_here",
    "Host": "httpbin.org"
  }
}
```

## GET /headers (Custom Token Header)

### Description
Accesses a protected resource using a custom token header.

### Method
GET

### Endpoint
https://httpbin.org/headers

### Response
#### Success Response (200)
- **headers** (object) - The headers received by the server, including the custom token header.

#### Response Example
```json
{
  "headers": {
    "Accept": "*/*",
    "X-Custom-Token": "your_token_here",
    "Host": "httpbin.org"
  }
}
```
```

--------------------------------

### Example gRPC Request: Describe Service

Source: https://neovim.getkulala.net/docs/usage/grpc

This example shows how to use the 'describe' command to inspect a gRPC service. It utilizes the plaintext flag to establish a connection without TLS and queries the helloworld.Greeter service.

```shell
# @grpc-plaintext  
GRPC localhost:50051 describe helloworld.Greeter  
  

```

--------------------------------

### Pre-request and Post-request Scripts

Source: https://neovim.getkulala.net/docs/usage/demos

Illustrates advanced scripting for dynamically setting request variables before a request and processing responses after a request, including setting global variables.

```APIDOC
## POST /post (with Scripts)

### Description
Demonstrates pre-request scripting to set dynamic variables (timestamp, nonce) and post-request scripting to process the response and set global variables.

### Method
POST

### Endpoint
https://httpbin.org/post

### Parameters
#### Request Body
- **username** (string) - Required - The username for login.
- **password** (string) - Required - The password for login.
- **timestamp** (string) - Dynamically set by pre-request script.
- **nonce** (string) - Dynamically set by pre-request script.

### Pre-request Script
```javascript
< % {
  // Pre-request script
  const crypto = require('crypto');
  const timestamp = Date.now();
  const nonce = crypto.randomBytes(8).toString('hex');

  // Set request-scoped variables
  request.variables.set('TIMESTAMP', timestamp);
  request.variables.set('NONCE', nonce);

  console.log('Pre-request variables set:', { timestamp, nonce });
} %
```

### Request Example
```json
{
  "username": "demo",
  "password": "demo123",
  "timestamp": "{{TIMESTAMP}}",
  "nonce": "{{NONCE}}"
}
```

### Post-request Script
```javascript
> %
  // Post-request script
  const token = response.body.json.username + '_' + response.body.json.nonce;

  // Set global variable for use in subsequent requests
  client.global.set('AUTH_TOKEN', token);

  console.log('Received response and set AUTH_TOKEN:', token);
%
```

### Response
#### Success Response (200)
- **json** (object) - The parsed JSON request body.

#### Response Example
```json
{
  "json": {
    "username": "demo",
    "password": "demo123",
    "timestamp": "1678886400000",
    "nonce": "abcdef1234567890"
  }
}
```

## POST /post (Global Variable Setting)

### Description
Sends a POST request and uses a post-request script to write to a file and set a global variable.

### Method
POST

### Endpoint
https://httpbin.org/post

### Post-request Script
```javascript
> %
  var fs = require('fs');
  fs.writeFileSync('TOKEN.txt', "Demo with bilibili");
  client.global.set('GORILLA_TOKEN', response.body.json.token);
  console.log('Received response and set GORILLA_TOKEN:', response.body.json.token);
%
```

### Response
#### Success Response (200)
- **json** (object) - The parsed JSON request body.

#### Response Example
```json
{
  "json": {
    "token": "SOME_TOKEN",
    "deep": {
      "nested": [
        {
          "key": "foo"
        }
      ]
    }
  }
}
```

## POST /post (Using Global Variable)

### Description
Sends a POST request using a global variable set by a previous request.

### Method
POST

### Endpoint
https://httpbin.org/post

### Parameters
#### Request Body
- **gorilla** (string) - The value of the GORILLA_TOKEN global variable.

### Request Example
```json
{
  "gorilla": "{{GORILLA_TOKEN}}"
}
```

## POST /post (Iterative Request)

### Description
Sends a POST request and iterates over a list of results from the response, replaying the request for each item.

### Method
POST

### Endpoint
https://httpbin.org/post

### Request Body
```json
{
  "results": [
    { "id": 1, "desc": "some_username" },
    { "id": 2, "desc": "another_username" }
  ]
}
```

### Post-request Script (Saving Results)
```javascript
> %
  client.global.set("results", response.body.json.results); // save results to global variable, as js does not have access to responses history
%
```

### Pre-request Script (Iterating through Results)
```javascript
< % {
  const results = client.global.get("results");
  if (!results) { return; }

  const item = results[request.iteration() - 1]; // get item by index

  if (!item) {   
    client.global.set("results", null);
    return request.skip(); // skip if no more items  
  }
  
  client.log(item);
  
  const url = "https://httpbin.org/get";
  request.variables.set("url", url + "?" + item.desc); // update url variable, cannot access request.url_raw like in lua
} %
```

## GET (Iterative Request URL)

### Description
This request is dynamically constructed and replayed based on the results from a previous POST request.

### Method
GET

### Endpoint
{{url}}

### Post-request Script (Replaying)
```javascript
> %
  const results = client.global.get("results");
  if (results) { request.replay(); } // replay if there are more results
%
```
```

--------------------------------

### Example gRPC Request: List Methods

Source: https://neovim.getkulala.net/docs/usage/grpc

This example demonstrates how to list available methods for a gRPC service using the 'list' command. It includes the verbose flag to provide more detailed output and shows that the service.method part is optional for list and describe commands.

```shell
# @grpc-v  
GRPC localhost:50051 list  
# service.method is optional when using a command list|describe  
  

```

--------------------------------

### Example gRPC Request: Using ProtoSet File

Source: https://neovim.getkulala.net/docs/usage/grpc

This example illustrates making a gRPC request by referencing a pre-compiled proto set file. The address is optional when using proto files, simplifying the request definition.

```shell
# @grpc-protoset my-protos.bin  
GRPC helloworld.Greeter/SayHello  
# address is optional when using proto files  


```

--------------------------------

### POST Request with File Body

Source: https://neovim.getkulala.net/docs/usage/demos

This example demonstrates how to send a POST request to a specified URL with the request body loaded from a local file. It's useful for sending complex or large JSON payloads without embedding them directly in the script. The file path is relative to the script location.

```http
POST https://httpbin.org/post  
  
  
< ./body-from-file.json
```

--------------------------------

### Pre-request Script Examples

Source: https://neovim.getkulala.net/docs/scripts/lua-scripts

Demonstrates setting environment and global variables, skipping requests, and defining request bodies with variable substitution.

```APIDOC
## Pre-request Script Examples

### REQUEST_ONE (POST https://httpbin.org/post)

#### Description
This request sets environment variables `Token` and `PASSWORD`, a global variable `BONOBO`, and conditionally skips the request if `Auth` is not `Foo`. It then sends a POST request with a JSON body including variable substitutions.

#### Method
POST

#### Endpoint
https://httpbin.org/post

#### Request Body
```json
{
  "token": "{{GORILLA}}",
  "password": "{{PASSWORD}}",
  "deep": {
    "nested": [
      {
        "key": "foo"
      },
      {
        "key": "{{BONOBO}}"
      }
    ]
  }
}
```

### REQUEST_TWO (POST https://httpbin.org/post)

#### Description
This request sends a POST request using values from the previous request's response and global variables.

#### Method
POST

#### Endpoint
https://httpbin.org/post

#### Request Body
```json
{
  "token": "{{REQUEST_ONE.response.body.$.json.token}}",
  "nested": "{{REQUEST_ONE.response.body.$.json.deep.nested[1].key}}",
  "gorilla": "{{GORILLA}}"
}
```
```

--------------------------------

### Use Node.js Modules in Scripts

Source: https://neovim.getkulala.net/docs/scripts/overview

Demonstrates how to use Node.js modules like 'moment' and 'fs' within JavaScript scripts. The 'require' function is used for importing modules. Modules must be installed locally or globally. Shows an example of writing to a file using 'fs.writeFileSync'.

```javascript
const moment = require("moment");

```

```javascript
const fs = require("fs");
fs.writeFileSync("../http/my-file.txt", "Hello, world!");

```

--------------------------------

### Example AWS Signature V4 Request

Source: https://neovim.getkulala.net/docs/usage/authentication

An example HTTP GET request demonstrating the structure for AWS Signature V4 authentication.

```http
GET {{apiUrl}}/ HTTP/1.1
```

--------------------------------

### Pre-request Script with File I/O and Crypto

Source: https://neovim.getkulala.net/docs/scripts/overview

An example of a pre-request script using Node.js modules 'crypto' and 'fs'. It reads a token from 'TOKEN.txt', generates a random password, and sets variables accessible within the current request. Includes examples of setting request variables and reading response data from a previous request.

```javascript
var crypto = require('crypto');
var fs = require('fs');
var TOKEN = fs.readFileSync('TOKEN.txt', 'utf8').trim();
request.variables.set('GORILLA', TOKEN);
request.variables.set('PASSWORD', crypto.randomBytes(16).toString('hex'));

```

--------------------------------

### HTTP Authentication with Tokens

Source: https://neovim.getkulala.net/docs/usage/demos

Shows how to handle authentication using tokens, including simulating a login POST request to obtain a token and then using it in subsequent requests, either as a Bearer token or in a custom header. Demonstrates dynamic setting of environment variables based on response JSON.

```http
### Get token (simulating login)  
  
### login  
POST https://httpbin.org/post HTTP/1.1  
  
  
{
  "username": "demo",
  "password": "demo123",
  "access_token": "asdfasdfasdfasdf"
}
  
### Access protected resource with Bearer token  
  
GET https://httpbin.org/bearer HTTP/1.1  
  
  
### Access protected resource with custom token header  
  
GET https://httpbin.org/headers HTTP/1.1  
  

```

--------------------------------

### HTTP Request with Variables

Source: https://neovim.getkulala.net/docs/usage/demos

Illustrates how to use variables in HTTP requests, including environment variables and custom variables defined within the script. This is essential for managing dynamic configurations and sensitive information.

```http
### Basic GET request  
  
GET https://api.thecatapi.com/v1/images/search HTTP/1.1  
  
@BASE_URL = https://api.thecatapi.com/v1
@API_KEY = your_api_key_here  
  
### GET request with variables and request parameters  
  
GET {{BASE_URL}}/images/search?limit=3 HTTP/1.1  
  
### Request with environment variables  
  
GET {{FROM_ENV_FILE_URL}}/breeds HTTP/1.1  
```

--------------------------------

### Confirm Sending All Requests in Neovim

Source: https://neovim.getkulala.net/docs/usage/recipes

Configures a Neovim keymap to prompt the user for confirmation before sending all requests using the kulala plugin. Requires the kulala plugin to be installed.

```lua
{
  opts = {
    global_keymaps = {
      ["Send all requests"] = {
        "<leader>Ra",
        function()
          vim.ui.input({ prompt = "Send all requests? (y/n)" }, function(input)
            if input == "y" then require("kulala").run_all() end
          end)
        end,
        mode = { "n", "v" },
      },
    },
  }
}
```

--------------------------------

### Negotiate Authentication Example Kulala

Source: https://neovim.getkulala.net/docs/usage/authentication

Illustrates Negotiate Authentication in Kulala, a SPNEGO-based implementation that utilizes default credentials without requiring explicit username and password.

```http
GET https://www/api HTTP/1.1

```

--------------------------------

### Basic Authentication Example Kulala

Source: https://neovim.getkulala.net/docs/usage/authentication

Demonstrates Basic Authentication in Kulala, showing how to send a Base64 encoded username:password in the Authorization header. It also illustrates Kulala's automatic encoding if plain text is provided.

```http
GET https://www/api HTTP/1.1

```

```http
GET https://www/api HTTP/1.1

```

--------------------------------

### Post-request Script Examples

Source: https://neovim.getkulala.net/docs/scripts/lua-scripts

Shows how to modify requests based on responses, replay requests, set global variables, and assert response conditions.

```APIDOC
## Post-request Script Examples

### Example Request (POST https://httpbin.org/post)

#### Description
This request sends a POST request and then executes a post-request script. If the response code is 403, it modifies the URL, sets an environment variable, and replays the request. Otherwise, it sets a global variable and asserts the response code and JSON content.

#### Method
POST

#### Endpoint
https://httpbin.org/post

#### Request Body
```json
{
  "token": "SOME_TOKEN",
  "deep": {
    "nested": [
      {
        "key": "foo"
      }
    ]
  }
}
```

#### Response Example (Success - 200)
(Assumed based on assertion)
```json
{
  "token": "SOME_TOKEN",
  "deep": {
    "nested": [
      {
        "key": "foo"
      }
    ]
  }
}
```
```

--------------------------------

### Example Usage of Request Variables

Source: https://neovim.getkulala.net/docs/usage/request-variables

Illustrates how to define named requests and reference their data in subsequent requests.

```APIDOC
## Example Usage

### REQUEST_ONE
POST https://httpbin.org/post HTTP/1.1


{
  "token": "foobar"
}

###  

### REQUEST_TWO
POST https://httpbin.org/post HTTP/1.1


{
  "token": "{{REQUEST_ONE.response.body.$.json.token}}"
}

###  

POST https://httpbin.org/post HTTP/1.1


{
  "date_header": "{{REQUEST_TWO.response.headers['Date']}}"
}

###  

### REQUEST_GH
GET https://github.com HTTP/1.1

###  

POST https://httpbin.org/post HTTP/1.1


{
  "logged_into_gh": "{{REQUEST_GH.response.cookies.logged_in.value}}"
}

###
```

--------------------------------

### JavaScript Scripting in HTTP Requests

Source: https://neovim.getkulala.net/docs/usage/demos

Illustrates advanced HTTP request handling using JavaScript for pre- and post-request scripting. It shows how to generate dynamic variables (timestamp, nonce), set global variables based on responses, write to files, and replay requests based on dynamic conditions. Supports Node.js environment for script execution.

```javascript
< {%  
  // Pre-request script  
  const crypto = require('crypto');  
  const timestamp = Date.now();  
  const nonce = crypto.randomBytes(8).toString('hex');  
    
  // Set request-scoped variables  
  request.variables.set('TIMESTAMP', timestamp);  
  request.variables.set('NONCE', nonce);  
    
  console.log('Pre-request variables set:', { timestamp, nonce });  
%}  
### login  
POST https://httpbin.org/post HTTP/1.1  
  
  
{
  "username": "demo",
  "password": "demo123",
  "timestamp": "{{TIMESTAMP}}",
  "nonce": "{{NONCE}}"
}
  
> {%  
  // Post-request script  
  const token = response.body.json.username + '_' + response.body.json.nonce;  
    
  // Set global variable for use in subsequent requests  
  client.global.set('AUTH_TOKEN', token);  
    
  console.log('Received response and set AUTH_TOKEN:', token);  
%}  
  
###  
  
### REQUEST_ONE  
POST https://httpbin.org/post HTTP/1.1  
  
  
  
{
  "token": "SOME_TOKEN",
  "deep": {
    "nested": [
      {
        "key": "foo"
      }
    ]
  }
}
  
> {%  
  var fs = require('fs');  
  fs.writeFileSync('TOKEN.txt', "Demo with bilibili");  
  client.global.set('GORILLA_TOKEN', response.body.json.token);  
  console.log('Received response and set GORILLA_TOKEN:', response.body.json.token);  
%}  
  
###  
  
### REQUEST_TWO  
POST https://httpbin.org/post HTTP/1.1  
  
  
  
{
  "gorilla": "{{GORILLA_TOKEN}}"
}
  
> ./post-request.js  
  
###  
  
### REQUEST_THREE  
POST https://httpbin.org/post HTTP/1.1  
  
  
  
{
  "date_header_from_request_two": "{{BONOBO}}"
}
  
### Request_one  
# Get results and iterate over them, replaying the request for each item  
  
POST https://httpbin.org/post HTTP/1.1  
  
  
  
{
  "results": [
    { "id": 1, "desc": "some_username" },
    { "id": 2, "desc": "another_username" }
  ]
}
  
> {%  
  client.global.set("results", response.body.json.results); // save results to global variable, as js does not have access to responses history  
%}
  
### Request_js  
  
< {%  
  const results = client.global.get("results");  
  if (!results) { return; }  
    
  const item = results[request.iteration() - 1]; // get item by index  
  
  if (!item) {   
    client.global.set("results", null);  
    return request.skip(); // skip if no more items  
  }
  
  client.log(item);
  
  const url = "https://httpbin.org/get";  
  request.variables.set("url", url + "?" + item.desc); // update url variable, cannot access request.url_raw like in lua  
%}
  
GET {{url}}
  
> {%  
  const results = client.global.get("results");  
  if (results) { request.replay(); }  
%}  
  
```

--------------------------------

### Iterating Over Results

Source: https://neovim.getkulala.net/docs/scripts/request-reference

Illustrates how to iterate over results and make subsequent requests based on the data obtained. This is a placeholder for a more detailed example.

```APIDOC
### Iterating over results and making requests for each item

```javascript
// Placeholder for example
```
```

--------------------------------

### Content Type Definitions (Lua)

Source: https://neovim.getkulala.net/docs/getting-started/configuration-options

Defines filetypes, formatters, and path resolvers for various content types. This example shows configurations for JSON, GraphQL, JavaScript, Lua, XML, and HTML.

```lua
contenttypes = {
  ["application/json"] = {
    ft = "json",
    formatter = vim.fn.executable("jq") == 1 and {"jq", "."},
    pathresolver = function(...)
      return require("kulala.parser.jsonpath").parse(...)
    end,
  },
  ["application/graphql"] = {
    ft = "graphql",
    formatter = vim.fn.executable("prettier") == 1 and {"prettier", "--stdin-filepath", "file.graphql"},
    pathresolver = nil,
  },
  ["application/javascript"] = {
    ft = "javascript",
    formatter = vim.fn.executable("prettier") == 1 and {"prettier", "--stdin-filepath", "file.js"},
    pathresolver = nil,
  },
  ["application/lua"] = {
    ft = "lua",
    formatter = vim.fn.executable("stylua") == 1 and {"stylua", "-"},
    pathresolver = nil,
  },
  ["application/graphql-response+json"] = "application/json",
  ["application/xml"] = {
    ft = "xml",
    formatter = vim.fn.executable("xmllint") == 1 and {"xmllint", "--format", "-"},
    pathresolver = vim.fn.executable("xmllint") == 1 and {"xmllint", "--xpath", "{{path}}", "-"},
  },
  ["text/html"] = {
    ft = "html",
    formatter = vim.fn.executable("prettier") == 1 and {"prettier", "--stdin-filepath", "file.html"},
    pathresolver = nil,
  },
}
```

--------------------------------

### NTLM Authentication Example Kulala

Source: https://neovim.getkulala.net/docs/usage/authentication

Demonstrates NTLM Authentication in Kulala, showing how to provide username and password. It also covers scenarios where the username is omitted, using the current user's credentials.

```http
GET https://www/api HTTP/1.1

```

```http
GET https://www/api HTTP/1.1

```

```http
GET https://www/api HTTP/1.1

```

--------------------------------

### Request Body Example (POST)

Source: https://neovim.getkulala.net/docs/usage/http-file-spec

Illustrates how to include a request body with a POST request. The body follows a blank line after the request headers (or request line if no headers are present) and can be in various formats like JSON.

```http
POST https://localhost:7220/weatherforecast  



{
    "date": "2023-05-10",
    "temperatureC": 30,
    "summary": "Warm"
}

###  

```

--------------------------------

### Define and Reference a Named Request - Kulala HTTP

Source: https://neovim.getkulala.net/docs/usage/request-variables

This snippet demonstrates defining a named request (`### THIS_IS_AN_EXAMPLE_REQUEST_NAME`) and how other requests can reference its data. It includes an example of a POST request with form data.

```http
### THIS_IS_AN_EXAMPLE_REQUEST_NAME  
POST https://httpbin.org/post HTTP/1.1  
  
  
name=foo&password=bar  

```

--------------------------------

### gRPC Request with Variables

Source: https://neovim.getkulala.net/docs/usage/grpc

This example shows how to use variables to define gRPC request parameters like address, service, and flags. It demonstrates dynamic request construction and the use of a file for the request body.

```shell
@address=localhost:50051  
@service=helloworld.Greeter  
@flags=-import-path ../protos -proto helloworld.proto  -- [!] flags must be prefixed with `-`  
GRPC {{flags}} {{address}} {{service}}/SayHello  
  
  
< /path/to/file.json  


```

--------------------------------

### Configure Kulala Plugin Options (Lua)

Source: https://neovim.getkulala.net/docs/getting-started/configuration-options

Provides a comprehensive example of setting default options for the Kulala Neovim plugin. It covers configurations for external tools like cURL and gRPCurl, request behavior, environment variables, and content type-specific handlers.

```lua
local M = {
  -- cURL path
  -- if you have curl installed in a non-standard path,
  -- you can specify it here
  curl_path = "curl",
  -- additional cURL options
  -- see: https://curl.se/docs/manpage.html
  additional_curl_options = {},
  -- gRPCurl path, get from https://github.com/fullstorydev/grpcurl.git
  grpcurl_path = "grpcurl",
  -- websocat path, get from https://github.com/vi/websocat.git
  websocat_path = "websocat",
  -- openssl path
  openssl_path = "openssl",

  -- set scope for environment and request variables
  -- possible values: b = buffer, g = global
  environment_scope = "b",
  -- dev, test, prod, can be anything
  -- see: https://learn.microsoft.com/en-us/aspnet/core/test/http-files?view=aspnetcore-8.0#environment-files
  default_env = "dev",
  -- enable reading vscode rest client environment variables
  vscode_rest_client_environmentvars = false,

  -- default timeout for the request, set to nil to disable
  request_timeout = nil,
  -- continue running requests when a request failure is encountered
  halt_on_error = true,

  -- certificates
  certificates = {},
  -- Specify how to escape query parameters
  -- possible values: always, skipencoded = keep %xx as is
  urlencode = "always",

  -- Infer content type from the body and add it to the request headers
  infer_content_type = true,

  -- default formatters/pathresolver for different content types
  contenttypes = {
    ["application/json"] = {
      ft = "json",
      formatter = vim.fn.executable("jq") == 1 and {"jq", "."},
      pathresolver = function(...)
        return require("kulala.parser.jsonpath").parse(...)
      end,
    },
    ["application/graphql"] = {
      ft = "graphql",
      formatter = vim.fn.executable("prettier") == 1
        and {"prettier", "--stdin-filepath", "graphql", "--parser", "graphql"},
      pathresolver = nil,
    },
    ["application/xml"] = {
      ft = "xml",
      formatter = vim.fn.executable("xmllint") == 1 and {"xmllint", "--format", "-"},
      pathresolver = vim.fn.executable("xmllint") == 1 and {"xmllint", "--xpath", "{{path}}", "-"},
    },
    ["text/html"] = {
      ft = "html",
      formatter = vim.fn.executable("xmllint") == 1 and {"xmllint", "--format", "--html", "-"},
      pathresolver = nil,
    },
  },

  scripts = {
    -- Resolves "NODE_PATH" environment variable for node scripts. Defaults to the first "node_modules" directory found upwards from "script_file_dir".
    node_path_resolver = nil, ---@type fun(http_file_dir: string, script_file_dir: string, script_data: ScriptData): string|nil
  },

  ui = {
    -- display mode: possible values: "split", "float"
    display_mode = "split",
    -- split direction: possible values: "vertical", "horizontal"
    split_direction = "vertical",
    -- window options to override win_config: width/height/split/vertical.., buffer/window options
    win_opts = { bo = {}, wo = {} }, ---@type kulala.ui.win_config
    -- default view: "body" or "headers" or "headers_body" or "verbose" or fun(response: Response)
    default_view = "body", ---@type "body"|"headers"|"headers_body"|"verbose"|fun(response: Response)
    -- enable winbar
    winbar = true,
    -- Specify the panes to be displayed by default
    -- Current available pane contains { "body", "headers", "headers_body", "script_output", "stats", "verbose", "report", "help" },
    default_winbar_panes = { "body", "headers", "headers_body", "verbose", "script_output", "report", "help" },
    -- enable/disable variable info text
    -- this will show the variable name and value as float
    -- possible values: false, "float"
    show_variable_info_text = false,
    -- icons position: "signcolumn"|"on_request"|"above_request"|"below_request" or nil to disable
    show_icons = "on_request",
    -- default icons
    icons = {
      inlay = {
        loading = "⏳",
        done = "✅",
        error = "❌",
      },
      lualine = "🐼",
      textHighlight = "WarningMsg", -- highlight group for request elapsed time
    },

    -- highlight groups for http syntax highlighting
    ---@type table<string, string|vim.api.keyset.highlight>
    syntax_hl = {
      ["@punctuation.bracket.kulala_http"] = "Number",
      ["@character.special.kulala_http"] = "Special",
      ["@operator.kulala_http"] = "Special",
      ["@variable.kulala_http"] = "String",
    },

    -- enable/disable request summary in the output window
    show_request_summary = true,
    -- disable notifications of script output
    disable_script_print_output = false,

    report = {
      -- possible values: true | false | "on_error"

```

--------------------------------

### HTTP POST with JSON Body and Lua Assertions

Source: https://neovim.getkulala.net/docs/usage/demos

This snippet showcases sending a POST request with a JSON body and then performing assertions on the response using Lua scripting. It includes defining environment variables, sending data, and using `client.test` and `assert` functions for validation of response data, headers, and JSON payloads. The script logs test outcomes.

```http
# Testing and Reporting Demo  
  
# Define environment variables  
@BASE_URL = https://httpbin.org  
@OCCUPATION = Developer  
  
### POST request with JSON body  
POST {{BASE_URL}}/post HTTP/1.1  
  
  
  
{
  "data": {
    "name": "John Doe",
    "occupation": "{{OCCUPATION}}",
    "age": 30
  }
}
  
> {%  
  let json = response.body.json.data;  
  
  client.test("Test suite 1", function() {  
    assert(json.name == "John Doe", "Check if name is correct")  
    assert.same(json.occupation, "Developer", "Check occupation")  
    client.assert.true(json.age == 30, "Age is correct")  
    client.assert.false(json.age == 40, "Age is not 40")  
  });  
  
  client.log("Test Script Output 1")  
  
  client.test("Test suite 2", function() {  
    assert.hasString(json.occupation, "Develop", "Check if occupation contains 'Develop'")  
    assert.responseHas('responseCode', 200, "Check if response code is 200")  
    assert.headersHas('Content-Type', "application/json", "Check content type")  
  });  
  
  assert.jsonHas("json.data.occupation", "Developer", "Check json payload")  
%}
```

--------------------------------

### Lua Pre-request Script for Environment Setup and Control

Source: https://neovim.getkulala.net/docs/scripts/lua-scripts

A Lua script executed before a request, used to set local and global environment variables (e.g., 'Token', 'PASSWORD', 'BONOBO'). It can also conditionally skip requests based on environment variables.

```lua
-- lua
client.log("Pre-request script")

request.environment.Token = "Foo" -- set request local variable
request.environment.PASSWORD = "Bar" -- set request local variable

client.global.BONOBO = "baz" -- set global variable

if not request.environment.Auth == "Foo" then
  request.skip() -- skip the request
end

```

--------------------------------

### Conditional Requests Example

Source: https://neovim.getkulala.net/docs/scripts/request-reference

Demonstrates how to use `request.skip()` and `request.replay()` for conditional request execution, such as retrying a request with modified parameters if an error response is received.

```APIDOC
### Conditional requests

```javascript
< {% 
  // Skip request if no token is available globally
  if (!client.global.get("Token")) {
    request.skip()
  }
%} 

@URL = "500" 
GET https://httpbin.org/status/{{URL}}

> {% 
  console.log(response.responseCode)
  // If the response code is 500, update the URL and replay the request
  if (response.responseCode === 500) {
    request.variables.set('URL', "200");
    request.replay()
  }
%} 
```
```
Tokens:
Raw