
Security News
Deno 2.2 Improves Dependency Management and Expands Node.js Compatibility
Deno 2.2 enhances Node.js compatibility, improves dependency management, adds OpenTelemetry support, and expands linting and task automation for developers.
HTTP request code snippet generator
GimmeHttp is a library for generating HTTP request code snippets in various languages based on a simple configuration. Quickly output API requests .
Currently body only supports JSON. Need help building out the body support for other types. See Contributions for more details.
Language | Clients | Language | Clients | Language | Clients |
---|---|---|---|---|---|
libcurl | fetch, axios, jQuery | nethttp, faraday | |||
http, restsharp | http, node-fetch | reqwest | |||
curl | curl, guzzle | nsurlsession | |||
http | requests, http |
To install GimmeHttp, simply use npm:
npm install gimmehttp
Here is a quick example of generating a simple GET request in Go:
import { Generate } from 'gimmehttp'
// Create settings
const settings = {
language: 'go',
target: 'native',
http: {
method: 'GET',
url: 'https://example.com'
}
}
// Generate code
const { code, error } = Generate(settings)
if (error) {
console.error(error)
}
// Output generated code
console.log(code)
Output:
package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "https://example.com"
req, _ := http.NewRequest("GET", url, nil)
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
}
The core functionality of GimmeHttp is its Generate
function. This function takes in a request object and returns the generated code snippet as a string. The request object should have the following structure:
Generate(settings: Settings): Outcome
interface Settigns {
language: string // go, javascript, python, etc.
target: string // native, axios, requests, etc.
// HTTP request details
http: {
method: string // 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'
url: string // ex: 'https://example.com'
// Optional request details
headers?: { [key: string]: string }
cookies?: { [key: string]: string }
body?: any
}
// Optional - configuration for the code generation
config?: {
// The character(s) to use for indentation
indent?: string // default: ' '
// The character(s) to use for joining lines
join?: string // default: '\n'
// Whether or not to handle errors in the generated code
// default: false to help keep the generated code simple by default
handleErrors?: boolean // default: false
}
}
The Generate
function returns an Outcome
object. If the object
contains an error
property, an error occurred during code generation.
import { Generate } from 'gimmehttp'
const { code, error, language, client } = Generate(request)
if (error) {
console.error(error)
}
// Output generated code
console.log(code)
console.log(language)
console.log(client)
interface Outcome {
error?: string // An error message if an error occurred
// or //
language?: string // Language used
client?: string // Client used, set to default if not specified
code?: string // Generated code
}
If you want to register a custom language/client, you can do so using the Register
function:
interface Target {
default?: boolean
language: string
target: string
generate: (config: Config, http: Http) => string
}
import { Register, Generate } from 'gimmehttp'
import type { Config, Http } from 'gimmehttp'
const myCustomTarget = {
language: 'html',
target: 'href',
generate(config: Config, http: Http): string {
// Custom code generation logic
return `<a href="${http.url}">${http.method}</a>`
}
}
Register(myCustomTarget)
const settings = {
language: 'html',
target: 'href',
http: {
method: 'GET',
url: 'https://example.com'
}
}
const { code, error } = Generate(settings)
if (error) {
console.error(error)
}
console.log(code)
Output:
<a href="https://example.com">GET</a>
const settings = {
language: 'javascript',
target: 'fetch',
http: {
method: 'POST',
url: 'https://example.com',
headers: {
'Content-Type': 'application/json'
},
body: {
key1: 'value1'
}
}
}
const { code, error } = Generate(settings)
if (error) {
console.error(error)
}
console.log(output)
Output:
fetch("https://example.com", {
method: "POST",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({"key1":"value1"}),
})
.then(response => {
if (!response.ok) {
throw new Error("Network response was not ok");
}
return response.text();
})
.then(data => console.log(data));
GimmeHttp is an open-source project that welcomes contributions from the community. If you would like to contribute, please follow these steps:
Feel free to contribute to the project, suggest improvements, or report issues on our GitHub page!
FAQs
HTTP request code generator
The npm package gimmehttp receives a total of 3 weekly downloads. As such, gimmehttp popularity was classified as not popular.
We found that gimmehttp demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Deno 2.2 enhances Node.js compatibility, improves dependency management, adds OpenTelemetry support, and expands linting and task automation for developers.
Security News
React's CRA deprecation announcement sparked community criticism over framework recommendations, leading to quick updates acknowledging build tools like Vite as valid alternatives.
Security News
Ransomware payment rates hit an all-time low in 2024 as law enforcement crackdowns, stronger defenses, and shifting policies make attacks riskier and less profitable.