Let's Build a Go version of Laravel

Let's get our project structure set up and initialized.

Let's use a Makefile to keep things up to date and easy to manage.

Let's start making our Celeritas package useful for web applications

Let's call our celeritas package from our application and create some folders

Let's create a .env file and read it's values into the application's environment

Let's add some loggers, and try accessing information from our celeritas package from myapp

We are going to need a lot of configuration information for the celeritas package, so let's set up a type and share it with the entire module.

Let's implement a web server in our celeritas package, and start it from the myapp project

Let's build a render package that handles Go and Jet templates

Let's try rendering a standard Go template from myapp, just to make sure our code works.

Sometimes I don't get enough caffeine, and I write messy code. Let's fix that.

Let's add support for rendering Jet templates to the celeritas package

Let's make sure our code to render a Jet template works as expected

Let's change our default renderer to Jet, and change our home page template

Testing is very important. Let's write some tests for the render package.

Let's finish testing the render package

Our test for the Page function is rather long. Let's simplify it by using table tests.

Let's update our home page to make testing functionality easier.

Let's set up an easy to configure session package for Celeritas.

Our session needs to be loaded and saved on every request. Let's create and use some middleware that does just that.

Let's verify that we can write to and read from the session, and pass data to our Jet template.

It's important to keep our tests up to date, so let's write a test for our session package.

Let's check our test coverage.

Let's install Docker and make our lives much easier.

Let's use docker-compose to bring up our databases (and Redis).

Let's write some code to open a connection to a Postgres database using the jack/pgx driver.

Let's write some code to build a data source name (DSN), and connect Celeritas to Postgres

Let's try out a simple test route in myapp that reads information from the database and writes it to the browser window.

Most people who use frameworks expect to have an easy to use means of interacting with the database. Let's get started working on that functionality.

Let's create a user model that allows us to work with users easily by attaching functions to the model that interact with the database.

Let's write some additional functions for the User model, allowing us to insert, update, and delete users easily.

Let's write the last functions for the User model, to handle common tasks associated with authentication and user management.

Let's try creating a test route to insert a user.

Let's try out some of our User functions using test routes.

Let's try out our user.go functions by logging a user in.

Let's complete the login process.

Let's write some simple unit tests for models.go.

Let's get started with the code to set up our integration tests.

Let's finish up TestMain, verify that our docker image is up, and write some tests.

Let's keep writing integration tests for our User and Token data models.

Let's finish up our integration tests.

Just a bit of housekeeping.

Let's take the first steps to build our command line application.

Let's add support for running database migrations to the celeritas package.

Let's get started implementing a "make migration" command in the CLI.

Let's write the code to execute up and down migrations

Let's get started making setting up an authentication system easy for users of the Celeritas package.

Let's try out our "make auth" command and see if it works.

Let's make sure we copy over the data models for user and token when we run make auth from our command line utility.

Let's create some authentication middleware that we'll install using the command line application.

Let's update our command line utility to install the authentication middleware.

Let's make sure that our middleware is installed correctly.

Let's improve our command line application to allow for creating stub handlers.

Let's make it easy for our users to generate data models from the CLI.

Let's add support for storing sessions in the database to the CLI.

Let's add support for storing sessional data in Postgres.

Let's add support for "make auth" with MariaDB/MySQL.

Let's update our /update-user route to use our validation package.

Let's make it easy to add validation right to our models.

Let's try out the validation rules we attached to the user model.