Learn Faunadb, Flexbox and Jasmine

It's tempting to pick up a framework which has preselected flexbox or grid as the layout tool of choice, but it's important to learn when and why to use each method. This leads to slimmer stylesheets which results in better site performance, and less likelihood for "hacks" to make one method do what the other does inherently better.

Throughout this collection, we will be progressively styling a responsive landing page template while building your knowledge on when to select grid or flexbox for any layout scenario. Spoiler alert: sometimes the best solution is using both!

The specification describes a CSS box model optimized for user interface design. In the flex layout model, the children of a flex container can be laid out in any direction, and can “flex” their sizes, either growing to fill unused space or shrinking to avoid overflowing the parent.

flexbox

Create a Landing Page with CSS Grid and Flexbox

This application serves as an introduction to building products with a JAMStack and Serverless approach. We cover everything from the beginning:

* starting with the Gatsby client
* handling authentication with Netlify Identity
* Shipping a GraphQL server on Netlify Functions
* Building in access control with a serverless capable database

It uses tools that remove as many of the barriers as possible while also allowing upgrading in the future. Netlify Functions can grow into AWS Lambda, Netlify Identity can grow into Auth0 or Cognito, and FaunaDB can grow into DynamoDB.

Gatsby is a blazing fast static site generator built with React. Gatsby gives you all of the modern JavaScript tools you want; set up and ready to go out of the box.

gatsby

Building a Serverless JAMStack Todo app with Netlify, Gatsby, GraphQL, and FaunaDB

This collection is a sequel to the [Building a Serverless JAMStack Todo app with Netlify, Gatsby, GraphQL, and FaunaDB](https://egghead.io/playlists/building-a-serverless-jamstack-todo-app-with-netlify-gatsby-graphql-and-faunadb-53bb) collection. In this collection we take the TODO application we built and convert it to run using Netlify Identity, AWS Lambda (using the serverless framework) and DynamoDB. We cover

* Fauna vs DynamoDB and when to use each
* Setting up AWS accounts
* Creating DynamoDB tables and data modeling differences between Fauna and Dynamo
* Converting our Netlify Functions deployment to a Serverless Framework deployment
* Implementing Custom authorizer functions on AWS

It uses tools that remove as many of the barriers as possible. Netlify Functions grows into Serverless Framework adn AWS Lambda, Netlify Identity is kept around, and FaunaDB can grows into DynamoDB.



FaunaDB is a global serverless database that gives you ubiquitous, low latency access to app data, without sacrificing data correctness. It eliminates layers of app code for manually handling data anomalies, security, and scale, creating a friendlier dev experience for you and better app experience for your users.

faunadb

Converting a Serverless App to run on AWS Lambda and DynamoDB with Serverless Framework

FaunaDB is a global serverless database that gives you ubiquitous, low latency access to app data, without sacrificing data correctness. It eliminates layers of app code for manually handling data anomalies, security, and scale, creating a friendlier dev experience for you and better app experience for your users.

Fauna is inspired by [Calvin](https://blog.acolyer.org/2019/03/29/calvin-fast-distributed-transactions-for-partitioned-database-systems/), has [built-in GraphQL integration](https://docs.fauna.com/fauna/current/api/graphql/), and a query language based on lambda calculus. Be sure to check out the [Jepsen analysis](https://jepsen.io/analyses/faunadb-2.5.4) and the associated [chart of consistency models](https://jepsen.io/consistency)

The Complete Guide to FaunaDB

Flexbox is a powerful way to layout HTML so that elements can grow to fit the size of their container.  It can also control how the elements are positioned within a flexed container.  

Once you start thinking in `rows` and `columns`, you can control almost any flexed layout with just a few simple flexbox layout primitives.

Get Started with Flexbox CSS Layouts

This playlist covers various aspects of CSS including different rules, selectors, and patterns

CSS Tips and Tricks

Flexbox is a wonderful tool built into the CSS specification. Using flexbox doesn't require any special framework or library, just a browser with CSS3 support. It is so awesome, and makes the arranging elements on a page almost fun!

Flexbox Fundamentals

After setting `display: flex` on a parent element, you can use `flex-direction` to switch the container to be either a `row` or a `column`.

We also switch the body between `row` and `column`.

Flex into a Row or a Column with flex-direction

We can space items inside of a flexed component in the "on-axis" direction, with `justify-content`.

Justify content can take the following values: `flex-start`, `flex-end`, `center`, `space-between`, `space-around`, or `space-evenly`

Change the Spacing of Flexed Components with justify-content

We changed the axis layout with 'justify-content', and the "off axis" layout is controlled by 'align-items'.  The most common values are `flex-start`, `flex-end`, or `center`.

Change the off-axis Alignment of a Flexed Container with `align-items`

To set the wrap settings of elements inside of a container, we can set the `flex-wrap` css attribute.  The most common values are: `nowrap`, `wrap`, or `wrap-reverse`

Wrap Elements Inside of a Flexed Container with `flex-wrap`

To stretch individual elements to fit the given space, we can set the `flex-grow` or `flex` attributes to any integer.  Other surrounding elements will grow proportionally to their `flex-grow` or `flex` attributes.

Proportionally Grow a Flexed Element by Setting `flex-grow` or `flex` Styles

FaunaDB is a Calvin inspired hosted database marketed towards JAMStack and serverless users. It is geo-replicated across multiple providers (AWS, GCP, and soon Azure), uses a lambda calculus based query language (FQL) or the built-in GraphQL support, and is quick to get started with. Don't worry about the vocabulary here (Consistency, lambda calculus, etc), FaunaDB can be quickly put to work without reading any papers and without knowing what lambda calculus is.

* [Calvin Paper](http://cs.yale.edu/homes/thomson/publications/calvin-sigmod12.pdf) (warning: pdf link)
  - [Morning Paper Overview of Calvin Paper](https://blog.acolyer.org/2019/03/29/calvin-fast-distributed-transactions-for-partitioned-database-systems/) if you don't want to read the whole paper
* [jepsen report](https://jepsen.io/analyses/faunadb-2.5.4)

An Introduction to FaunaDB

FQL is the main query language for interacting with FaunaDB. It supports all JSON types, plus some additional types like Ref, Date, and Set. FQL is based in expressions and as such everything returns a value. This makes it easy to compose logic into larger queries.

Code shown in the shell:

```
Match(Index("all_customers"))
```

Overview of the FaunaDB Query Language

When working with FQL it's often the case that you'll encounter `Ref`s. `Ref`s don't have any fields on them though! So how do we access the fields? `Get`.

```
Collections()
```

```
Collection("customers")
```

```
Ref(Collection("customers"), "244075679454331401")
```

```
Get(Ref(Collection("customers"), "244075679454331401"))
```

```
Get(Collection("customers"))
```



Refs and Get in FaunaDB

FQL Page objects have additional fields like `before`, and `data`, that may make it seem like you need to `Select` to get at the underlying array of results. However, FQL supports passing Page objects directly to functions that operate on arrays and the function will transparently operate on the contained `data` field.

```
Paginate(Match(Index("all_customers")))
```

```
Drop(1, Paginate(Match(Index("all_customers"))))
```

```
Take(1, Paginate(Match(Index("all_customers"))))
```

FQL Page objects can be arguments to array functions

`Ref`s are opaque. To access the fields on a document associated with a Ref, we first need to run `Get` on our results and then we can access fields using `Select`

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda("X", Get(Var("X")))
)
```

```
Map(
  Paginate(Match(Index("all_customers"))),
  Lambda("X", Select(["data", "firstName"], Get(Var("X"))))
)
```

Accessing fields through Refs with Select

We walk through creating a new Database in the FaunaDB console complete with some demo data. We do some exploration of the data, introducing concepts like Collections and Indexes, before showing an example FQL query that runs against the database. This sets us up to talk about FQL in future videos

Creating your first FaunaDB database

Overview of the FaunaDB Query Language (FQL)

When working with FQL it's often the case that you'll encounter Refs. Refs don't have any fields on them though! So how do we access the fields? Get.

```
Collections()
```

```
Collection("customers")
```

```
Ref(Collection("customers"), "244075679454331401")
```

```
Get(Ref(Collection("customers"), "244075679454331401"))
```

```
Get(Collection("customers"))
```

Topics

Instructors

Content Type

Create a Landing Page with CSS Grid and Flexbox

Building a Serverless JAMStack Todo app with Netlify, Gatsby, GraphQL, and FaunaDB

Converting a Serverless App to run on AWS Lambda and DynamoDB with Serverless Framework

The Complete Guide to FaunaDB

Get Started with Flexbox CSS Layouts

CSS Tips and Tricks

Flexbox Fundamentals

Flex into a Row or a Column with flex-direction

Change the Spacing of Flexed Components with justify-content

Change the off-axis Alignment of a Flexed Container with `align-items`

Wrap Elements Inside of a Flexed Container with `flex-wrap`

Proportionally Grow a Flexed Element by Setting `flex-grow` or `flex` Styles

An Introduction to FaunaDB

Overview of the FaunaDB Query Language

Refs and Get in FaunaDB

FQL Page objects can be arguments to array functions

Accessing fields through Refs with Select

An Introduction to FaunaDB

Creating your first FaunaDB database

Overview of the FaunaDB Query Language (FQL)

Getting fields out of Refs with Get