on 27-Nov-2023 (Mon)

React components are JavaScript functions that return markup:

 function MyButton ( ) { 
 return ( 
 < button > I'm a button </ button > 
 ) ; 
 } 

Now that you’ve declared MyButton, you can nest it into another component:

 export default function MyApp ( ) { 
 return ( 
 < div > 
 < h1 > Welcome to my app </ h1 > 
 < MyButton /> 
 </ div > 
 ) ; 
 } 

The markup syntax you’ve seen above is called JSX. It is optional, but most React projects use JSX for its convenience. All of the tools we recommend for local development support JSX out of the box.

JSX is stricter than HTML. You have to close tags like <br />. Your component also can’t return multiple JSX tags. You have to wrap them into a shared parent, like a <div>...</div> or an empty <>...</> wrapper

In React, you specify a CSS class with className. It works the same way as the HTML class attribute:

 < img className = "avatar" /> 

JSX lets you put markup into JavaScript. Curly braces let you “escape back” into JavaScript so that you can embed some variable from your code and display it to the user. For example, this will display user.name:

 return ( 
 < h1 > 
 { user . name } 
 </ h1 > 
 ) ; 

You can also “escape into JavaScript” from JSX attributes, but you have to use curly braces instead of quotes. For example, className="avatar" passes the "avatar" string as the CSS class, but src={user.imageUrl} reads the JavaScript user.imageUrl variable value, and then passes that value as the src attribute:

 return ( 
 < img 
 className = "avatar" 
 src = { user . imageUrl } 
 /> 
 ) ; 

const user = { name : 'Hedy Lamarr' , imageUrl : 'https://i.imgur.com/yXOvdOSs.jpg' , imageSize : 90 , } ;
export default function Profile ( ) { return ( < > < h1 > { user . name } </ h1 > < img className = "avatar" src = { user . imageUrl } alt = { 'Photo of ' + user . name } style = { { width : user . imageSize , height : user . imageSize } } /> </ > ) ; }
Show more

In the above example, style={{}} is not a special syntax, but a regular {} object inside the style={ } JSX curly braces. You can use the style attribute when your styles depend on JavaScript variables.

In React, there is no special syntax for writing conditions. Instead, you’ll use the same techniques as you use when writing regular JavaScript code. For example, you can use an if statement to conditionally include JSX:

 let content ; 
 if ( isLoggedIn ) { 
 content = < AdminPanel /> ; 
 } else { 
 content = < LoginForm /> ; 
 } 
 return ( 
 < div > 
 { content } 
 </ div > 
 ) ; 

If you prefer more compact code, you can use the conditional ? operator. Unlike if, it works inside JSX:

 < div > 
 { isLoggedIn ? ( 
 < AdminPanel /> 
 ) : ( 
 < LoginForm /> 
 ) } 
 </ div > 

When you don’t need the else branch, you can also use a shorter logical && syntax:

 < div > 
 { isLoggedIn && < AdminPanel /> } 
 </ div > 

All of these approaches also work for conditionally specifying attributes. If you’re unfamiliar with some of this JavaScript syntax, you can start by always using if...else.

 const listItems = products . map ( product => 
 < li key = { product . id } > 
 { product . title } 
 </ li > 
 ) ; 
 
 return ( 
 < ul > { listItems } </ ul > 
 ) ; 

Notice how <li> has a key attribute. For each item in a list, you should pass a string or a number that uniquely identifies that item among its siblings. Usually, a key should be coming from your data, such as a database ID. React uses your keys to know what happened if you later insert, delete, or reorder the items.

You can respond to events by declaring event handler functions inside your components:

 function MyButton ( ) { 
 function handleClick ( ) { 
 alert ( 'You clicked me!' ) ; 
 } 
 
 return ( 
 < button onClick = { handleClick } > 
 Click me
 </ button > 
 ) ; 
 } 

Notice how onClick={handleClick} has no parentheses at the end! Do not call the event handler function: you only need to pass it down. React will call your event handler when the user clicks the button.

Often, you’ll want your component to “remember” some information and display it. For example, maybe you want to count the number of times a button is clicked. To do this, add state to your component.

First, import useState from React:

 import { useState } from 'react' ; 

Now you can declare a state variable inside your component:

 function MyButton ( ) { 
 const [ count , setCount ] = useState ( 0 ) ; 
 // ... 

You’ll get two things from useState: the current state (count), and the function that lets you update it (setCount). You can give them any names, but the convention is to write [something, setSomething].

The first time the button is displayed, count will be 0 because you passed 0 to useState(). When you want to change state, call setCount() and pass the new value to it. Clicking this button will increment the counter:

 function MyButton ( ) { 
 const [ count , setCount ] = useState ( 0 ) ; 
 
 function handleClick ( ) { 
 setCount ( count + 1 ) ; 
 } 
 
 return ( 
 < button onClick = { handleClick } > 
 Clicked { count } times
 </ button > 
 ) ; 
 } 

React will call your component function again. This time, count will be 1. Then it will be 2. And so on.

If you render the same c

When your code imports packages contained in other modules, you manage those dependencies through your code's own module. That module is defined by a go.mod file that tracks the modules that provide those packages. That go.mod file stays with your code, including in your source code repository.

To enable dependency tracking for your code by creating a go.mod file, run the go mod init command, giving it the name of the module your code will be in. The name is the module's module path.

In actual development, the module path will typically be the repository location where your source code will be kept. For example, the module path might be github.com/mymodule. If you plan to publish your module for others to use, the module path must be a location from which Go tools can download your module. For more about naming a module with a module path, see Managing dependencies.

For the purposes of this tutorial, just use example/hello.

$ go mod init example/hello
go: creating new go.mod: module example/hello

The go run command is one of many go commands you'll use to get things done with Go. Use the following command to get a list of the others:

$ go help

Programmatic React features:

• Hooks - Use different React features from your components.
• Components - Documents built-in components that you can use in your JSX.
• APIs - APIs that are useful for defining components.
• Directives - Provide instructions to bundlers compatible with React Server Components.

React-dom contains features that are only supported for web applications (which run in the browser DOM environment). This section is broken into the following:

• Hooks - Hooks for web applications which run in the browser DOM environment.
• Components - React supports all of the browser built-in HTML and SVG components.
• APIs - The react-dom package contains methods supported only in web applications.
• Client APIs - The react-dom/client APIs let you render React components on the client (in the browser).
• Server APIs - The react-dom/server APIs let you render React components to HTML on the server.

• Legacy APIs - Exported from the react package, but not recommended for use in newly written code.

migrate

Database migrations written in Go. Use as CLI or import as library.

(Whole file)

graphile-migrate

Opinionated SQL-powered productive roll-forward migration tool for PostgreSQL.

(Whole page)

goose

Goose is a database migration tool. Manage your database schema by creating incremental SQL changes or Go functions.

(Whole page)

Tern - The SQL Fan's Migrator

Tern is a standalone migration tool for PostgreSQL.

(Whole page)

• Migrate reads migrations from sources and applies them in correct order to a database.
• Drivers are "dumb", migrate glues everything together and makes sure the logic is bulletproof. (Keeps the drivers lightweight, too.)
• Database drivers don't assume things or try to correct user input. When in doubt, fail.

Database drivers run migrations. Add a new database?

• PostgreSQL
• PGX v4
• PGX v5
• Redshift
• Ql
• Cassandra
• SQLite
• SQLite3 (todo #165)
• SQLCipher
• MySQL/ MariaDB
• Neo4j
• MongoDB
• CrateDB (todo #170)
• Shell (todo #171)
• Google Cloud Spanner
• CockroachDB
• YugabyteDB
• ClickHouse
• Firebird
• MS SQL Server

Database URLs

Database connection strings are specified via URLs. The URL format is driver dependent but generally has the form: dbdriver://username:password@host:port/dbname?param1=true&param2=false

Any reserved URL characters in the DB connection URL need to be escaped. Note, the % character also needs to be escaped

Explicitly, the following characters need to be escaped: !, #, $, %, &, ', (, ), *, +, ,, /, :, ;, =, ?, @, [, ]

It's easiest to always run the URL parts of your DB connection URL (e.g. username, password, etc) through an URL encoder. See the example Python snippets below:

$ python3 -c ' import urllib.parse; print(urllib.parse.quote(input("String to encode: "), "")) ' String to encode: FAKEpassword!#$%&' () * +,/:;= ? @[]
FAKEpassword%21%23%24%25%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D
$ python2 -c ' import urllib; print urllib.quote(raw_input("String to encode: "), "") ' String to encode: FAKEpassword!#$%&' () * +,/:;= ? @[]
FAKEpassword%21%23%24%25%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D
$

Source drivers read migrations from local or remote sources. Add a new source?

• Filesystem - read from filesystem
• io/fs - read from a Go io/fs
• Go-Bindata - read from embedded binary data (jteeuwen/go-bindata)
• pkger - read from embedded binary data (markbates/pkger)
• GitHub - read from remote GitHub repositories
• GitHub Enterprise - read from remote GitHub Enterprise repositories
• Bitbucket - read from remote Bitbucket repositories
• Gitlab - read from remote Gitlab repositories
• AWS S3 - read from Amazon Web Services S3
• Google Cloud Storage - read from Google Cloud Platform Storage

• Simple wrapper around this library.
• Handles ctrl+c (SIGINT) gracefully.
• No config search paths, no config files, no magic ENV var injections.

CLI Documentation

Basic usage

$ migrate -source file://path/to/migrations -database postgres://localhost:5432/database up 2

Go to getting started

• CockroachDB
• PostgreSQL

Each migration has an up and down migration. Why?

1481574547_create_users_table.up.sql
1481574547_create_users_table.down.sql

Best practices: How to write migrations.

Coming from another db migration tool?

Check out migradaptor. Note: migradaptor is not affliated or supported by this project

Yes, please! Makefile is your friend, read the development guide.

Also have a look at the FAQ.

• Multi-platform
• Stand-alone binary
• SSH tunnel support built-in
• Data variable interpolation into migrations

The migrations themselves have an extremely simple file format. They are simply the up and down SQL statements divided by a magic comment.

---- create above / drop below ----

Example:

 create table t1 ( id serial primary key ); -- -- create above / drop below ---- drop table t1;

If a migration is irreversible such as a drop table, simply delete the magic comment.

 drop table widgets;

Database Schema Migration

• atlas - A Database Toolkit. A CLI designed to help companies better work with their data.
• avro - Discover SQL schemas and convert them to AVRO schemas. Query SQL records into AVRO bytes.
• bytebase - Safe database schema change and version control for DevOps teams.
• darwin - Database schema evolution library for Go.
• dbmate - A lightweight, framework-agnostic database migration tool.
• go-fixtures - Django style fixtures for Golang's excellent built-in database/sql library.
• go-pg-migrate - CLI-friendly package for go-pg migrations management.
• go-pg-migrations - A Go package to help write migrations with go-pg/pg.
• goavro - A Go package that encodes and decodes Avro data.
• godfish - Database migration manager, works with native query language. Support for cassandra, mysql, postgres, sqlite3.
• goose - Database migration tool. You can manage your database's evolution by creating incremental SQL or Go scripts.
• gorm-seeder - Simple database seeder for Gorm ORM.
• gormigrate - Database schema migration helper for Gorm ORM.
• libschema - Define your migrations separately in each library. Migrations for open source libraries. MySQL & PostgreSQL.
• migrate - Database migrations. CLI and Golang library.
• migrator - Dead simple Go database migration library.
• migrator - MySQL database migrator designed to run migrations to your features and manage database schema update with intuitive go code.
• schema - Library to embed schema migrations for database/sql-compatible databases inside your Go binaries.
• skeema - Pure-SQL schema management system for MySQL, with support for sharding and external online schema change tools.
• soda - Database migration, creation, ORM, etc... for MySQL, PostgreSQL, and SQLite.
• sql-migrate - Database migration tool. Allows embedding migrations into the application using go-bindata.
• sqlize - Database migration generator. Allows generate sql migration from model and existing sql by differ them.

Because Graphile Migrate tracks which migrations it has ran and runs remaining migrations, you must not put your existing database schema as the first migration otherwise you production database might be wiped (or it just won't work) when Graphile Migrate attempts to apply it. Instead you must ensure all databases (development, staging, production, etc.) are at the same state before running any migrations, and then the Graphile Migrate migrations will be applied on top of this initial state.

Storing the initial state

Though you could hand-roll the initial state if you prefer, we generally advise that you take a schema-only dump of your existing (production) database schema and store it to migrations/initial_schema.sql with a command such as:

pg_dump --schema-only --no-owner --file=migrations/initial_schema.sql "postgres://..."