DEV Community: K-Sato

Writing a SSG in Go

K-Sato — Fri, 26 Jan 2024 23:50:37 +0000

Overview

Ever since I read this article Writing a Static Blog Generator in Go by @zupzup a few years ago, I've been wanting to do the same.

After not doing it for a few years just like a lot of things in my life rn, I finally gave it a try.

What I Created

Here is the core package(SSG)

K-Sato1995 / go-simple-ssg

Minimalistic SSG(Static Site Generator) in Go

What this is

Yet another SSG in Go. It's not intended to replace any existing SSGs. I created it as a learning exercise and really enjoyed the process.🤗

Heavily inspired by this blog post(Writing a Static Blog Generator in Go) by @zupzup.

Site I created using this

In case you are wondering how to use this, check out the Initialization process below.

Initialization

Install the cli.

go install github.com/K-Sato1995/go-simple-ssg/simple-ssg-cli@latest

run

simple-ssg-cli init

would create a new project that looks somethi ng like this.

./
├── contents/ (Stores markdown files)
├── templates/ (Stores template html files and style files)
├── generated/ (Stores generated files)
├── go.mod
├── go.sum
└── main.go

cd your project and just run

go run main.go

You should be able to see the site running on http://localhost:3001

Todo

CLI To run generating static contents based on the config file
- put all the code in one…

View on GitHub

and here is a static site I created using the ssg.

https://go-simple-ssg.vercel.app

Structure

The core package mainly consists of two parts

Generator: Generate static files based on Markdown and Templates(HTML) files.
CLI: Allows anyone to bootstrap a project.

The core packages looks like this

./
├── parser/ (Part that parses Markdown into HTML)
│ ├── mdToHTML.go
│ └── parseMetaData.go
├── builder/ (Part that generates static files based on the given md and templates)
│ ├── bundleCss.go
│ ├── copyStaticFiles.go
│ ├── generateDetail.go
│ └── generateList.go
├── simple-ssg-cli/ (CLI that allows anyone to bootstrap a project)
├─ example/
├── config/ (Part that makes the project custamizable for users)
└── engine.go

To use it, install the simple-ssg-cli and execute the init command.

$ go install github.com/K-Sato1995/go-simple-ssg/simple-ssg-cli@latest
$ simple-ssg-cli init

Doing this will create a new project with the following structure:

./
├── contents/ (Stores markdown files)
├── templates/ (Stores template html files and style files)
├── generated/ (Stores generated files)
├── go.mod
├── go.sum
└── main.go

Lastly, move to the newly created project and run it to build static contents and stuff.

$ cd your_project && go run main.go

Random Thoughts

Doing this made me appreciate existing SSGs like Hugo and Next.js even more👏👏

Cool existing SSGs written in Go

SSR React in Go

K-Sato — Sun, 21 Jan 2024 07:51:51 +0000

Overview

I tried implementing server-side rendering (SSR) with React in Go. Below is a demonstration and the repo.

Go SSR POC GitHub Repository

While working on this, I discovered another project that basically dose what I wanted to achieve.

Go React SSR GitHub Repository

Objectives

Perform SSR using React's renderToString in a Go environment.
Implement hydration in the browser using React's hydrateRoot.

Tools Used

Firstly, I used rogchap/v8go to execute JavaScript in a Go environment. I listed other options below.

I added polyfills for the Web APIs used in the React code.

Also, I used esbuild (which is built in Go) for transpiling and bundling the React code.

Process

This is the process I followed:

Use esbuild to build the React code into a form executable on both the server and client sides.
Use rogchap/v8go to perform SSR (renderToString) on the server-side code.
Embed the SSR-generated content and the client-side code for hydration into an HTML template using Go’s standard library html/template (props are also injected here).
Make the HTML accessible using Go's standard library net/http.

Result

Here is the code I ended up with. It should do what I intended to do in the Objectives section above.

Go SSR POC GitHub Repository

VS Code Extension for Quick Navigation to Script and Style Tags in a Svelte file

K-Sato — Sat, 06 May 2023 10:41:41 +0000

Overview

I created a simple VSCode extension called svelte-tag-focuser.

You can easily jump to the script tag or style tag even when you are working with a very long svelte component.

Installation

Go to the installation page and install the extension.

Usage

Simply open a Svelte file in Visual Studio Code and activate the extension using one of the following methods:

Focus on script tag: Ctrl+Shift+S (Windows/Linux) or Cmd+Shift+S (Mac)
- or Click CMD+Shift+P and type Focus on Script (Svelte)
Focus on style tag: Ctrl+Shift+T (Windows/Linux) or Cmd+Shift+T (Mac)
- or Click CMD+Shift+P and type Focus on Style (Svelte)

Example

Let's say you have the following Svelte file:

<template>
  <div>
    <h1>Welcome to my Svelte app</h1>
    <p>This is some text</p>
  </div>
</template>

<script>
  // This is your script tag
  console.log('This is your script tag');
</script>

<style>
  /* This is your style tag */
  body {
    color: red;
  }
</style>

If you want to quickly jump to the script tag, you can use the "Focus on Script" command (or the Ctrl+Shift+S key binding) to go directly to the script tag.

That's it for now. Happy coding!

Created a vertical timeline component 😃

K-Sato — Tue, 05 Apr 2022 11:46:10 +0000

I created a svelte component library that provides a vertical timeline component😃😃

Any feed backs are appreciated😃.

Here are the demo site and the repo.

Created a productivity app

K-Sato — Sun, 27 Mar 2022 00:58:46 +0000

What it is

It is a really simple app that lets you play different kind of ambient sounds. You can play any sounds simultaneously.

site: https://focus-sounds.vercel.app/
repo: https://github.com/K-Sato1995/focus-sounds

Why I made it

I used to use Youtube or Apple Music/Spotify to listen to random music when I was coding. But I was having issues below.

Issues with Youtube: There are so many great videos made by great content creators and I usually end up watching those videos instead of coding.
Issues with Apple Music/Spotify: There are so many great songs or music made by great musicians and I usually end up just enjoying the music instead of coding.

Additionally, there actually was a site I used to use for focusing but that site "Upgraded" their features and it was not exactly I wanted anymore.

So I created it myself.

Credits

I'm using sounds and icons from the websites below.

Mixkit.com:
- LINK: https://mixkit.co/free-sound-effects/
- LICENCE: https://mixkit.co/license/
Wether Icons:
- https://github.com/basmilius/weather-icons
- LICENCE: https://github.com/basmilius/weather-icons/blob/dev/LICENSE
Other Icons: https://www.reshot.com/free-svg-icons/
- LICENCE: https://www.reshot.com/license/

Created a svelte tooltip library

K-Sato — Thu, 24 Mar 2022 10:44:58 +0000

Overview

I created a light weight tooltip library. It was my first time making a svelte library. But it was a breeze thanks to svelte-kit.

What I made

As stated above, I created a svelte-actions based tooltip library. I'll leave links to the repo and demo page here.

Repo: https://github.com/K-Sato1995/svelte-tooltip

Demo: https://svelte-tooltip-k-sato1995.vercel.app/

How to make a library with svelte-kit

※ svelte-kit package is currently experimental at the time of writing (2022/03/24)

svelte-kit makes creating a library super easy. The only notable difference between creating a library with svelte-kit and creating a web app with svelte-kit is the location of the public-facing stuff.

The location of the public facing stuff based on what you want to create
- src/routes : for creating a web app with svelte-kit
- src/lib: for creating a library with svelte-kit

And with that out of the way, all you have to do now is to write code and build & publish it by running the commands below.

$ npm run package // build the package from the code under src/lib
$ cd package // move to the package directory
$ npm publish // publish the package

For more information about creating a library with svelte-kit check out the official document below.

SvelteKit docs

Created a blog template with Sveltekit

K-Sato — Wed, 09 Mar 2022 00:46:10 +0000

Overview

As stated in the title, I created a blog template with Sveltekit. If you are looking for a bare minimum blog template, maybe give it a try?

Link to the Example: https://sveltekit-blog-template-swart.vercel.app/
Link to the Repo: https://github.com/K-Sato1995/sveltekit-blog-template

Home	Post Page

My thoughts on Sveltekit

I work as a frontend-engineer and mostly use React at work. And this was my first time using Sveltekit.

And here are the things I personally really liked about it.

Routing: Just like Next, Sveltekit provides filesystem-based routing. It works like a charm 🧙🏻‍♀️
Syntax of Svelte: The syntax of svelte is super easy to understand for anyone who has used HTML and CSS. 👏👏
HMR: Sveltekit internally uses Vite and the development experience was astonishing especially HMR(Hot Module Replacement) was instantaneous. ⚡️⚡️⚡️⚡️

Use lookup tables for cleaning up your JS/TS code

K-Sato — Sat, 01 Aug 2020 02:10:57 +0000

Overview

You might use the if of switch statement like the code below when the output of your function is dependent on the given value.

Using the If statement

const colorMapper = (color) => {
  if (color == "yellow") {
    return "amarillo";
  } else if (color == "blue") {
    return "azul";
  } else if (color == "red") {
    return "rojo";
  } else {
    return "No aplica";
  }
};

colorMapper("yellow"); //=> amarillo
colorMapper("pink"); //=> No aplica

Using the switch statement

const colorMapper = (color) => {
  switch (color) {
    case "yellow":
      return "amarillo";
    case "blue":
      return "azul";
    case "red":
      return "rojo";
    default:
      return "No aplica";
  }
};

colorMapper("yellow"); //=> amarillo
colorMapper("pink"); //=> No aplica

Using lookup tables

You can achieve the same result by creating a lookup table like the code below.

As you can see, the code is cleaner and much easier to read!

const colorsTable = {
  yellow: "amarillo",
  blue: "azul",
  red: "rojo",
};

const colorMapper = (color) => colorsTable[color] || "No aplica";

colorMapper("yellow"); //=> amarillo
colorMapper("pink"); //=> No aplica

If you wanna use the lookup table in TypeScript, you can give types to the lookup table like below.

type ColorEn = "yellow" | "blue" | "red";
type ColorEs = "amarillo" | "azule" | "rojo";

const colorsTable: Record<ColorEn, ColorEs> = {
  yellow: "amarillo",
  blue: "azule",
  red: "rojo",
};

const colorMapper = (color: ColorEn): ColorEs | "No aplica" => colorsTable[color] || "No aplica";

colorMapper("yellow"); //=> amarillo
colorMapper("pink"); //=> No aplica

Resources

Understand how classes work in TypeScript

K-Sato — Thu, 26 Mar 2020 23:06:51 +0000

Basics

Here is an example of a class in TypeScript.

A class mainly consists of the following:

Properties
Constructor
Methods

The syntax should look somewhat familiar if you have used any OOP language before.

class Person {
  // (1) Property(ies)
  name: string;

  // (2) Constructor  
  constructor(name: string) {
    this.name = name;
  }

  // (3) Method(s) 
  intro(): string {
    return `I'm ${this.name}`;
  }
}

const nick = new Person("Nick");
nick.intro(); //=> I'm Nick

Inheritance

You can inherit another class using extends in TypeScript.
As you can see in the example below, a class inherits all the members(like properties and methods) from the base class.
One thing you should pay attention to here is the super keyword in the constructor of the User class.
In TypeScript, when you want to initialize its own members in a subclass(child class), you have to use the super keyword to call the parent constructor and pass the property values.

class Person {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  intro(): string {
    return `I'm ${this.name}`;
  }
}

class User extends Person {
  id: number;

  constructor(id: number, name: string) {
    // The super keyword
    super(name);
    this.id = id;
  }

  showIdName(): void {
    console.log(this.id, this.name);
  }
}

const user1 = new User(1, "John");

user1.intro(); //=> "I'm John"
user1.showIdName(); //=> 1 'John'

Public・Private・Protected modifiers

Public

All the members of a class in TypeScript are public by default.
You can also explicitly declare it like the code below. The public members can be accessed anywhere even outside the class. And the values of public properties can be changed outside the class as well.

class Pet {
  public type: string;

  constructor(type: string) {
    this.type = type;
  }
}

let taro = new Pet("mammal");

taro.type //=> mammal
taro.type = "reptile";
taro.type //=> reptile

Private

The private members are only accessible in its class. It even can't be accessed in a subclass.

class Pet {
  public type: string;
  private name: string;

  constructor(type: string, name: string) {
    this.type = type;
    this.name = name;
  }
}

let taro = new Pet("mammal", "Taro");
taro.name //=> Property 'name' is private and only accessible within class 'Pet'

// Subclass
class SpecialPet extends Pet {
  roar(): void {
    console.log(this.name); //=> Property 'name' is private and only accessible within class 'Pet'
  }
}

Protected

The protected members are very much like the ones marked as private, except that the protected members can be accessed in subclasses.
(Here, I changed name to a protected property.)

class Pet {
  public type: string;
  protected name: string;

  constructor(type: string, name: string) {
    this.type = type;
    this.name = name;
  }
}

// Subclass
class SpecialPet extends Pet {
  roar(): void {
    console.log(`${this.name}!!!!!!!!!`); 
  }
}

let goro = new SpecialPet("mammal", "Goro");
goro.roar(); //=> "Goro!!!!!!!!!"

Readonly modifier

The properties declared as readonly can be accessed outside the class but their values can not be updated(changed).

class Person {
  readonly name: string;

  constructor(name: string) {
    this.name = name;
  }
}

const jenny = new Person("Jenny");
jenny.name;
jenny.name = "Jaz"; // Cannot assign to 'name' because it is a read-only property.

Static Properties

In TypeScript, the static members are only accessed using the class name and dot notation(.), without creating an object of the class.

class School {
  static startingTime: string = "9am";

  static start(): void {
    console.log(`${School.startingTime}!!!!!!!!`);
  }
}

School.startingTime; //=> 9am
School.start(); //=> 9am!!!!!!!!

Abstract classes

There are mainly two things you should remember about abstract classes in TypeScript.

(1) Abstract classes are only used for inheritance. Thus, You can not create an instance of an abstract class.
(2) You can define abstract methods within an abstract class. The abstract methods do not include any actual implementation in the abstract class and they must be implemented in the derived class.

abstract class Animal {
  name: string;

  constructor(name: string) {
    this.name = name;
  }

  scream(): void {
    console.log("AAAAAAAAAA");
  }

  // Abstract method
  // It must be implemented in the derived class.
  abstract shout(): void;
}

class Dog extends Animal {
  shout(): void {
    console.log("OOOOOOO");
  }
}

// const animal1 = new Animal("name"); //=> Cannot create an instance of an abstract class.ts(2511)
const dog1 = new Dog("Yoppy");
dog1.scream(); //=> AAAAAAAAAA
dog1.shout(); //=> OOOOOOO

References

[Rails]Implement session-based authentication from scratch

K-Sato — Mon, 23 Mar 2020 11:50:32 +0000

Here is how you can implement session-based authentication functionality in your rails application without using any gem.

Create author resources

Run the commands below.

$ rails generate model Author
$ rails generate controller Authors name:string email:string password_digest:string
$ rails generate migration add_index_to_authors_email // Add index
$ rake db:migrate

Set validations

Add validations for name and email.

# models/author.rb
class Author < ApplicationRecord
  VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i.freeze

  validates :name, presence: true, length: { maximum: 50 }
  validates :email, presence: true, length: { maximum: 255 }, format: { with: VALID_EMAIL_REGEX }, uniqueness: { case_sensitive: false }
end

Add secure password to Author

You'll have your users put the password and its confirmation in the form and send them as hashed values. (Hash values can not be decrypted even though they got intercepted by a third party during the transmission.)
You check if the sent hashed value matches the hashed password stored in the DB. And if it does, you allow your user to log in to the application.

Add has_secure_password

It's quite easy to set up in rails. Simply put has_secure_password in the Author model. (Also add the minimum length of each password.)

class Author < ApplicationRecord
  #
  # other code
  #
  validates :password, length: { minimum: 6 }
  has_secure_password
end

has_secure_password

Enables you to store the hashed password in your DB as password_digest
Lets you use password and password_confirmation params and validations for them.
Lets you use the authenticate method.

Add bcrypt gem

Add gem 'bcrypt' to your Gemfile and run bundle install.

gem 'bcrypt'

Check if it's working correctly

Run the commands in the rails console to see if you can use the authenticate method.
The authenticate method returns false if the given password was wrong and returns the author object if the given password was correct.

$ Author.create(name:"test", email:"test@email.com", password:"000000")
$ Author.first.authenticate('test')
//=> false
$ Author.first.authenticate('000000')
//=>
#<Author:0x0000560ee2e0a1b8
 id: 1,
 name: "test",
 email: "test@email.com",
 password_digest: "$2a$12$bQQu49N3xNCKO8StooXLBOqwwCAv7NbPqt3aG35AFDHRUgh.C8BgO",
 created_at: Mon, 30 Sep 2019 08:40:11 UTC +00:00,
 updated_at: Mon, 30 Sep 2019 08:40:11 UTC +00:00>

Sign up functionality

Let's start by setting up the routes for users to sign up.

Rails.application.routes.draw do
  resources :authors
  get  '/signup',  to: 'authors#new'
  post '/signup',  to: 'authors#create'

Add the code below to the author controller.

class AuthorsController < ApplicationController
  def show
    @author = Author.find(params[:id])
  end

  def new
    @author = Author.new
  end


  def create
    @author = Author.new(author_params)
    if @author.save
      redirect_to @author
    else
      render 'new'
    end
  end

  private

  def author_params
    params.require(:author).permit(:name, :email, :password, :password_confirmation)
  end
end

Lastly, create a signup page and show page for each user under views/authors/.

# views/authors/show.html.erb
<%= @author.name %>
<%= @author.email %>

# views/authors/new.html.erb
<% provide(:title, 'Sign up') %>
<h1>Sign up</h1>

<div class="row">
  <div class="col-md-6 col-md-offset-3">
    <%= form_for(@author) do |f| %>

      <%= f.label :name %>
      <%= f.text_field :name, class: 'form-control' %>

      <%= f.label :email %>
      <%= f.email_field :email, class: 'form-control' %>

      <%= f.label :password %>
      <%= f.password_field :password, class: 'form-control' %>

      <%= f.label :password_confirmation, "Confirmation" %>
      <%= f.password_field :password_confirmation, class: 'form-control' %>

      <%= f.submit "Create my account", class: "btn btn-primary" %>
    <% end %>
  </div>
</div>

Sign in/out

HTTP is a stateless protocol. So we use sessions to maintain the user state.
The new action is used to put information for a new session and create action is used to actually create a new session. And the destroy action is used to delete a session.

Set up routes

Set up routes for sessions.

Rails.application.routes.draw do
  resources :authors
  # Create new users
  get  '/signup',  to: 'authors#new'
  post '/signup',  to: 'authors#create'
  # Sessions
  get    '/login',   to: 'sessions#new'
  post   '/login',   to: 'sessions#create'
  delete '/logout',  to: 'sessions#destroy'
end

Create a session controller

$ rails generate controller Sessions

Add the code to SessionsController.

class SessionsController < ApplicationController
  def new
  end

  def create
    author = Author.find_by(email: params[:session][:email].downcase)
    if author && author.authenticate(params[:session][:password])
      log_in author
      redirect_to author
    else
      render 'new'
    end
  end

  def destroy
    log_out
    redirect_to root_url
  end
end

And add the code to SessionHelper and include session helper in ApplicationController.
The session used in the code below is the built-in session method in Rails.

module SessionsHelper
  def log_in(author)
    session[:author_id] = author.id
  end

  def current_author
    @author ||= Author.find_by(id: session[:author_id]) if session[:author_id]
  end

  def logged_in?
    !current_author.nil?
  end

  def log_out
    session.delete(:author_id)
    @current_author = nil
  end
end

class ApplicationController < ActionController::Base
  protect_from_forgery with: :exception
  include SessionsHelper
end

Remember me functionality

First of all, add a column called remember_digest to Author.

 $ rails generate migration add_remember_digest_to_users remember_digest:string

Update code in the Author model. Each method has its description in the code.

class Author < ApplicationRecord
  attr_accessor :remember_token
  VALID_EMAIL_REGEX = /\A[\w+\-.]+@[a-z\d\-.]+\.[a-z]+\z/i.freeze

  validates :name, presence: true, length: { maximum: 50 }
  validates :email, presence: true, length: { maximum: 255 }, format: { with: VALID_EMAIL_REGEX }, uniqueness: { case_sensitive: false }
  validates :password, length: { minimum: 6 }

  has_secure_password

  class << self
    # Return the hash value of the given string
    def digest(string)
      cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST : BCrypt::Engine.cost
      BCrypt::Password.create(string, cost: cost)
    end

    # Return a random token
    def generate_token
      SecureRandom.urlsafe_base64
    end
  end

  # Create a new token -> encrypt it -> stores the hash value in remember_digest in DB.
  def remember
    self.remember_token = Author.generate_token
    update_attribute(:remember_digest, Author.digest(remember_token))
  end

  # Check if the given value matches the one stored in DB
  def authenticated?(remember_token)
    BCrypt::Password.new(remember_digest).is_password?(remember_token)
  end

  def forget
    update_attribute(:remember_digest, nil)
  end
end

Update the session helper.

module SessionsHelper
  def log_in(author)
    session[:author_id] = author.id
  end

  def current_author
    if (author_id = session[:author_id])
      @current_author ||= User.find_by(id: author_id)
    elsif (author_id = cookies.signed[:author_id])
      author = User.find_by(id: author_id)
      if author && author.authenticated?(cookies[:remember_token])
        log_in author
        @current_author = author
      end
    end
  end

  def logged_in?
    !current_author.nil?
  end

  # Make the author's session permanent
  def remember(author)
    author.remember
    cookies.permanent.signed[:author_id] = author.id
    cookies.permanent[:remember_token] = author.remember_token
  end

  # Delete the permanent session
  def forget(author)
    author.forget
    cookies.delete(:author_id)
    cookies.delete(:remember_token)
  end

  def log_out
    forget(current_author)
    session.delete(:author_id)
    @current_author = nil
  end
end

Update the session controller.

class SessionsController < ApplicationController
  def new
  end

  def create
    author = Author.find_by(email: params[:session][:email].downcase)
    if author && author.authenticate(params[:session][:password])
      log_in author
      params[:session][:remember_me] == '1' ? remember(author) : forget(author)
      redirect_to author
    else
      render 'new'
    end
  end

  def destroy
    log_out
    redirect_to root_url
  end
end

Lastly, add remember_me checkbox in the view.

<div class="login-form">
  <h2>Log in</h2>
  <%= form_for(:session, url: login_path) do |f| %>
    <%= f.email_field :email, autofocus: true, autocomplete: "email", placeholder: 'Email', class: 'login-input'%><br/>
    <%= f.password_field :password, autocomplete: "current-password", placeholder: 'Password', class: 'login-input' %>
    <div class="check-field">
      <%= f.check_box :remember_me %>
      <%= f.label :remember_me %>
    </div>
    <%= f.submit "Log in", class: 'btn btn-outline-primary login-btn' %>
  <% end %>
</div>

Authorization

Add the following methods to the author controller.

class AuthorsController < ApplicationController
  before_action :authenticate_author

  ##
    Other code
  ##

  private

  def author_params
    params.require(:author).permit(:name, :email, :password, :password_confirmation)
  end

  def authenticate_author
    unless logged_in?
      flash[:danger] = "Please log in."
      redirect_to login_url
    end
  end

  def correct_author
    @author = Author.find(params[:id])
    redirect_to(root_url) unless current_author?(@author)
  end
end

Add the current_author? method to the session helper.

module SessionsHelper
  def current_author?(author)
    author == current_author
  end
end

That's it! Now you should have a simple authentication functionality on your rails app!

References

Ruby on Rails チュートリアル：実例を使って Rails を学ぼう

Make your react apps compatible with IE

K-Sato — Mon, 23 Mar 2020 11:39:51 +0000

Installation

npm install react-app-polyfill

yarn add react-app-polyfill

Import entry points

Import the packages at the top of your index.tsx or index.jsx.

import 'react-app-polyfill/ie9';
import 'react-app-polyfill/ie11';
import 'react-app-polyfill/stable';

That's it! Now your react app should run on IE without any errors.

Resources

react-app-polyfill

Basic curl options

K-Sato — Sun, 12 Jan 2020 01:52:10 +0000

Overview

Here are some super basic curl command options all web-application-developers should know.
If there is/are any other command option/options, you think, should be on the list, plz leave a comment below with the option/options.

Add headers

You can use -H to add headers to your request.

$ curl -H "Content-Type: application/json" http://localhost:8888

Make a POST request with Parameters

You can make a post request with parameters with the -d (-data) flag.
You can specify the method you want to use with -X. In this case, you are specifying to use the POST method.

$ curl -d '{"name":"value1", "content":"value2"}'  -X POST http://localhost:3000

Get verbose response

You can get verbose response with the -v option. The -v stands for -verbose.

$ curl -v http://localhost:8888

Fetch only the HTTP headers

You can use -I/--head flag to only fetch the headers.

$ curl -I http://localhost:8888

Add cookies

You can pass the data to the HTTP server as a cookie with the -b/--cookie command.
NOTE that the file specified with -b/--cookie is only used as input. No cookies will be stored in the file. To store cookies, use the -c/--cookie-jar option

$ curl -c cookie.txt -b cookie.txt -b "name=value" http://example.com

Send Data like sending them via forms

This lets curl emulate a filled-in form in which a user has pressed the submit button. This causes curl to POST data using the content-type multipart/form-data according to RFC1867.

$ curl -F title="Test" -F author="Test" -F attachment-file=@test.txt http://localhost:8880

Resources

Here are some resources to know more about the curl command.