1 of 95

Azu

Overview

Azu is a high-performance web framework for Crystal emphasizing type safety, modularity, and real-time capabilities.

Quick Example

Architecture

Endpoints are type-safe handlers with:

Request Contract: Validates and types incoming data
Response Object: Handles content rendering
Middleware: Cross-cutting concerns (auth, logging, etc.)

Core Features

Feature

Description

Documentation

New to Azu?

Need to do something?

Looking for API?

Want to understand?

Tutorials

Step-by-step lessons to learn Azu:

- Install and create your first app
- Complete CRUD API tutorial
- Real-time features

How-To Guides

Task-oriented guides for specific goals:

- Create endpoints, handle parameters, return formats
- Validate requests and models
- WebSocket channels and live components

Reference

Technical specifications and API documentation:

- Endpoint, Request, Response, Channel, Component
- Built-in middleware handlers
- All configuration options

Explanation

Conceptual understanding of Azu:

- How Azu works
- Request flow
- Compile-time guarantees

Resources

- Common questions and troubleshooting
- Development setup and guidelines

Tutorials

Getting Started

Welcome to Azu! This tutorial will guide you through installing Crystal and Azu, then building your first working application.

What You'll Learn

By the end of this tutorial, you will have:

Crystal and Azu installed on your system
A working Azu application running locally
Understanding of the basic project structure

Prerequisites

Before starting, ensure you have:

A computer running macOS, Linux, or Windows
Internet connection for downloading dependencies
A terminal/command line application

Step 1: Install Crystal

Azu requires Crystal 0.35.0 or higher. Install Crystal for your operating system:

macOS

Linux (Ubuntu/Debian)

Linux (Fedora/CentOS/RHEL)

Windows

Step 2: Create Your Project

Create a new Crystal project and add Azu as a dependency:

Edit your shard.yml to add Azu:

Install dependencies:

Step 3: Create Your First Application

Replace the contents of src/my_first_azu_app.cr with:

Step 4: Run Your Application

Start the server:

You should see output like:

Step 5: Test Your Endpoints

Open a new terminal and test your endpoints:

You can also open http://localhost:4000/ in your browser.

Understanding the Code

Let's break down what you just created:

Application Module

This defines your application and configures the server settings.

Endpoints

Endpoints handle HTTP requests:

include Azu::Endpoint(RequestType, ResponseType) defines the contract
get "/" declares the HTTP method and route
def call contains your handler logic

Route Parameters

The :name in the route captures that segment and makes it available via params.

Project Structure

Your project should now look like this:

Troubleshooting

"command not found: crystal"

Add Crystal to your PATH:

"Error resolving dependencies"

Clear the cache and reinstall:

Port already in use

Change the port in your configuration or kill the existing process:

Next Steps

Congratulations! You've created your first Azu application. Continue learning with:

- Create a complete CRUD API
- Add real-time features
- Connect to PostgreSQL or MySQL

Your Azu journey begins! You now have a working development environment and understand the basics of creating endpoints.

Building a User API

This tutorial walks you through building a complete RESTful API for user management with type-safe endpoints, validation, and proper error handling.

What You'll Build

By the end of this tutorial, you'll have:

CRUD endpoints for user management
Request validation with error messages
Type-safe request and response contracts
Proper error handling and status codes

Prerequisites

Completed the tutorial
Azu installed and working

Step 1: Project Setup

Create a new project:

Update shard.yml:

Install dependencies:

Create the project structure:

Step 2: Create the User Model

Create src/models/user.cr:

Note: This tutorial uses in-memory storage for simplicity. See for production database integration.

Step 3: Create Request Contracts

Request contracts validate incoming data automatically.

Create src/requests/create_user_request.cr:

Create src/requests/update_user_request.cr:

Step 4: Create Response Objects

Response objects define your API's output format.

Create src/responses/user_response.cr:

Create src/responses/users_list_response.cr:

Step 5: Create Endpoints

Now create the CRUD endpoints.

Create src/endpoints/create_user_endpoint.cr:

Create src/endpoints/list_users_endpoint.cr:

Create src/endpoints/show_user_endpoint.cr:

Create src/endpoints/update_user_endpoint.cr:

Create src/endpoints/delete_user_endpoint.cr:

Step 6: Create the Main Application

Create src/user_api.cr:

Step 7: Run and Test

Start the server:

Create a User

Response:

List Users

Get a User

Update a User

Delete a User

Test Validation

Response:

Key Concepts Learned

Type-Safe Contracts

Every endpoint declares exactly what it accepts and returns:

Automatic Validation

Request contracts validate data before your handler runs:

Structured Error Responses

Validation errors return consistent, structured JSON responses with proper HTTP status codes.

Route Parameters

Access URL segments via the params hash:

Project Structure

Next Steps

You've built a complete REST API. Continue learning with:

- Add real-time notifications
- Replace in-memory storage with PostgreSQL
- Write tests for your endpoints

Your API is ready! You now understand how to build type-safe, validated REST APIs with Azu.

Adding WebSockets

This tutorial teaches you how to add real-time features to your Azu application using WebSocket channels.

What You'll Build

By the end of this tutorial, you'll have:

A WebSocket channel for real-time notifications
Broadcasting messages to connected clients
Client-side WebSocket connection handling
Understanding of the channel lifecycle

Prerequisites

Completed tutorial
Basic understanding of WebSockets

Step 1: Understanding WebSocket Channels

WebSocket channels in Azu provide:

Persistent connections - Clients stay connected for real-time updates
Bidirectional communication - Both server and client can send messages
Broadcasting - Send messages to all connected clients

Step 2: Create a Notification Channel

Create src/channels/notification_channel.cr:

Step 3: Add Broadcasting to Your API

Update src/endpoints/create_user_endpoint.cr to broadcast when users are created:

Similarly update delete and update endpoints to broadcast their events.

Step 4: Update the Main Application

Update src/user_api.cr to include the channel:

Step 5: Create a Client Page

Create public/index.html:

Step 6: Add Static File Handler

Update your application to serve static files:

Step 7: Test Real-time Updates

Start the server:
Open http://localhost:4000/ in your browser
In another terminal, create a user:

Creating a Chat Room

For room-based broadcasting, use a message-based room join pattern:

Key Concepts Learned

Channel Lifecycle

Broadcasting Patterns

Message Protocol

Use a type field to route messages:

Next Steps

You've added real-time features to your API. Continue learning with:

- Persist data to PostgreSQL
- Create reactive UI components
- Test your WebSocket channels

Real-time features unlocked! Your application now supports live updates via WebSockets.

Working with Databases

This tutorial teaches you how to connect Azu to a database using CQL, Crystal's type-safe ORM.

What You'll Build

By the end of this tutorial, you'll have:

CQL connected to PostgreSQL (or SQLite for development)
Type-safe database models
CRUD operations with proper validation
Integration with Azu endpoints

Prerequisites

Completed tutorial
PostgreSQL installed (or SQLite for development)

Step 1: Add CQL Dependencies

Update your shard.yml:

Install dependencies:

Step 2: Define the Schema

Create src/config/database.cr:

For SQLite development:

Step 3: Create the Database

For PostgreSQL:

For SQLite:

Step 4: Create the Model

Replace src/models/user.cr with a CQL-backed model:

Step 5: Update Endpoints

Update src/endpoints/create_user_endpoint.cr:

Update src/endpoints/list_users_endpoint.cr:

Update src/endpoints/show_user_endpoint.cr:

Update src/endpoints/update_user_endpoint.cr:

Update src/endpoints/delete_user_endpoint.cr:

Step 6: Update Main Application

Update src/user_api.cr:

Step 7: Adding Relationships

Add a posts table to your schema:

Create src/models/post.cr:

Update the User model with the relationship:

Step 8: Query Examples

Environment Configuration

Create a .env file for development:

For production:

Key Concepts Learned

Schema Definition

Model Definition

CRUD Operations

Next Steps

Your API now persists data to a database. Continue learning with:

- Create real-time UI
- Test database operations
- Production database setup

Database integration complete! Your application now stores data persistently with type-safe queries.

Building Live Components

This tutorial teaches you how to create real-time, interactive UI components using Azu's live component system.

What You'll Build

By the end of this tutorial, you'll have:

A reactive counter component
A live chat component
Understanding of component lifecycle
Real-time DOM updates without page refreshes

Prerequisites

Completed tutorial
Understanding of WebSocket basics

Step 1: Understanding Live Components

Live components in Azu provide:

Real-time DOM updates - UI changes without page refreshes
Server-side state - State managed on the server
Event-driven interactions - Respond to user actions immediately

Step 2: Create a Counter Component

Create src/components/counter_component.cr:

Step 3: Create a Counter Endpoint

Create src/endpoints/counter_endpoint.cr:

Step 4: Create a Chat Component

Create src/components/chat_component.cr:

Step 5: Component Lifecycle

Components have lifecycle methods you can override:

Step 6: State Management

Manage complex state in components:

Step 7: Form Components

Handle forms with validation:

Step 8: Composing Components

Build complex UIs by composing components:

Key Concepts Learned

Component Structure

DOM Updates

Event Handling

Best Practices

Keep components focused - One responsibility per component
Use composition - Build complex UIs from simple components
Handle cleanup - Implement on_unmount for resource cleanup

Next Steps

You've learned to build interactive components. Continue with:

- Test your components
- Deploy your application

Interactive components ready! Your application now has real-time, reactive UI elements.

Testing Your App

This tutorial teaches you how to write comprehensive tests for your Azu application, including endpoints, models, and WebSocket channels.

What You'll Learn

By the end of this tutorial, you'll be able to:

Set up a testing environment
Write unit tests for endpoints
Test request validation
Test database models
Test WebSocket channels

Prerequisites

Completed previous tutorials
Basic understanding of testing concepts

Step 1: Test Setup

Create spec/spec_helper.cr:

Step 2: Testing Endpoints

Create spec/endpoints/create_user_endpoint_spec.cr:

Create spec/endpoints/show_user_endpoint_spec.cr:

Step 3: Testing Request Validation

Create spec/requests/create_user_request_spec.cr:

Step 4: Testing Models

Create spec/models/user_spec.cr:

Step 5: Testing WebSocket Channels

Create spec/channels/notification_channel_spec.cr:

Step 6: Integration Tests

Create spec/integration/api_spec.cr:

Step 7: Running Tests

Run all tests:

Run specific test file:

Run with verbose output:

Run focused tests:

Test Organization

Best Practices

Test one thing per test - Each test should verify one specific behavior
Use descriptive names - Test names should describe the expected behavior
Clean up after tests - Reset database state between tests

Key Concepts Learned

Test Structure

Common Assertions

Next Steps

You've learned to test your Azu application. Continue with:

- Deploy your tested app

Your tests are ready! You now have comprehensive test coverage for your application.

Deploying to Production

This tutorial teaches you how to deploy your Azu application to a production environment.

What You'll Learn

By the end of this tutorial, you'll know how to:

Configure your app for production
Build an optimized release binary
Set up a production server
Deploy with Docker
Configure SSL and security

Prerequisites

A working Azu application
Access to a Linux server or cloud platform
Basic knowledge of command line and servers

Step 1: Production Configuration

Create production settings in your application:

Step 2: Build for Production

Create a release build:

The --release flag enables optimizations and --no-debug removes debug symbols for a smaller binary.

Step 3: Environment Variables

Create a .env.production file (don't commit this):

Step 4: Docker Deployment

Create a Dockerfile:

Create docker-compose.yml:

Build and run:

Step 5: Systemd Service

For traditional server deployment, create /etc/systemd/system/user-api.service:

Enable and start the service:

Step 6: Nginx Reverse Proxy

Configure Nginx as a reverse proxy with SSL:

Enable the site:

Step 7: SSL with Let's Encrypt

Install and configure Certbot:

Step 8: Health Check Endpoint

Add a health check endpoint:

Step 9: Deployment Script

Create scripts/deploy.sh:

Step 10: CI/CD with GitHub Actions

Create .github/workflows/deploy.yml:

Production Checklist

Before going live:

Environment variables configured
Database migrations run
SSL certificate installed
Health check endpoint working

Monitoring

Add a simple monitoring endpoint:

Security Headers

Add security middleware:

Key Takeaways

Build optimized binaries with --release
Use environment variables for configuration
Run behind a reverse proxy (Nginx) for SSL

Next Steps

Congratulations! You've completed the Azu tutorial series. Explore further:

- Task-specific solutions
- Complete API documentation
- Deep dive into Azu internals

Your application is production-ready! You now have a fully deployed, secure Azu application.

Endpoints

Create an Endpoint

This guide shows you how to create type-safe HTTP endpoints in Azu.

Basic Endpoint

Create an endpoint by including Azu::Endpoint with request and response types:

Endpoint with JSON Response

HTTP Method Macros

Use macros to declare the HTTP method:

Accessing Request Data

Route Parameters

Query Parameters

Request Headers

Setting Response Status

Registering Endpoints

Add endpoints to your application:

Handle Parameters

This guide shows you how to extract and work with request parameters.

Route Parameters

Define route parameters with a colon prefix:

Multiple Route Parameters

Query Parameters

Access query string parameters:

Request Body (JSON)

Use request contracts to parse JSON bodies:

Form Data

Handle form submissions:

File Uploads

Handle multipart file uploads:

Headers

Access request headers:

Type Conversion

Convert string parameters to types:

Default Values

Provide defaults for optional parameters:

Return Different Formats

This guide shows you how to return JSON, HTML, text, and other response formats.

JSON Response

Return JSON data:

Custom JSON Response

Text Response

Return plain text:

HTML Response

Return HTML content:

Using Templates

Empty Response

Return no content (204):

Content Negotiation

Return different formats based on Accept header:

Setting Headers

Add custom response headers:

Redirect Response

Redirect to another URL:

File Download

Return a file for download:

Validation

Validate Requests

This guide shows you how to add validation to your request contracts.

Basic Validation

Add the validate macro to your request struct:

Validation Rules

Presence

Ensure a field is not empty:

Length

Validate string length:

Format

Validate against a regular expression:

Numericality

Validate numeric values:

Inclusion

Validate value is in a set:

Exclusion

Validate value is not in a set:

Combining Validations

Apply multiple rules to one field:

Custom Validation

Add custom validation logic:

Conditional Validation

Validate based on conditions:

Using Validated Requests in Endpoints

Validate Models

This guide shows you how to add validation to your CQL database models.

Basic Model Validation

Add validations to your CQL model:

Validation Rules

Presence

Uniqueness

Ensure a value is unique in the database:

Length

Format

Numericality

Inclusion

Custom Model Validation

Validation Callbacks

Run code before or after validation:

Checking Validity

Skipping Validations

When necessary, skip validations:

Validation Contexts

Use contexts for different validation scenarios:

Handle Validation Errors

This guide shows you how to handle and respond to validation errors in your Azu application.

Automatic Error Handling

Azu automatically validates requests and raises ValidationError for invalid data:

Default Error Response

When validation fails, Azu returns:

With HTTP status 422 Unprocessable Entity.

Custom Error Responses

Create a custom error response format:

Manual Validation Handling

Handle validation manually in your endpoint:

Model Validation Errors

Handle model validation errors:

Custom Error Handler

Create a global error handler for validation errors:

Collecting All Errors

Ensure all validation errors are collected:

Displaying Errors to Users

For HTML responses, pass errors to templates:

In your template:

Internationalization

Customize error messages:

Real-Time

Build Live Component

This guide shows you how to create real-time UI components that update automatically.

Basic Live Component

Create a component by including Azu::Component:

Register Component with Spark

Add your component to the Spark system:

Client-Side Setup

Include the Spark JavaScript client:

Mount a component in your HTML:

Component with Props

Pass initial data to components:

Mount with props:

Handling Form Input

Create interactive forms:

Component Lifecycle

Handle lifecycle events:

Real-time Updates

Push updates from server events:

Optimizing Updates

Use partial updates for better performance:

Component Communication

Components can communicate via events:

Error Handling

Handle component errors gracefully:

Database

Caching

File Handling

Middleware

Templates

Testing

Deployment

Error Handling

Performance

API Reference

Handlers

Configuration

Errors

Database

Templates

Migration

Architecture

Concepts

Design Decisions

Resources

require "../spec_helper" describe NotificationChannel do describe "#on_connect" do it "adds socket to connections" do channel = NotificationChannel.new socket = MockWebSocket.new initial_count = NotificationChannel::CONNECTIONS.size channel.socket = socket channel.on_connect NotificationChannel::CONNECTIONS.size.should eq(initial_count + 1) end it "sends welcome message" do channel = NotificationChannel.new socket = MockWebSocket.new channel.socket = socket channel.on_connect socket.sent_messages.size.should eq(1) message = JSON.parse(socket.sent_messages.first) message["type"].should eq("connected") end end describe "#on_message" do it "responds to ping with pong" do channel = NotificationChannel.new socket = MockWebSocket.new channel.socket = socket channel.on_connect channel.on_message(%({"type": "ping"})) messages = socket.sent_messages pong = messages.find { |m| JSON.parse(m)["type"] == "pong" } pong.should_not be_nil end it "handles invalid JSON" do channel = NotificationChannel.new socket = MockWebSocket.new channel.socket = socket channel.on_connect channel.on_message("invalid json") messages = socket.sent_messages error = messages.find { |m| JSON.parse(m)["type"] == "error" } error.should_not be_nil end end describe "#on_close" do it "removes socket from connections" do channel = NotificationChannel.new socket = MockWebSocket.new channel.socket = socket channel.on_connect count_before = NotificationChannel::CONNECTIONS.size channel.on_close(nil, nil) NotificationChannel::CONNECTIONS.size.should eq(count_before - 1) end end end # Mock WebSocket for testing class MockWebSocket getter sent_messages = [] of String def send(message : String) @sent_messages << message end def object_id 0_u64 end end

<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Real-time Notifications</title> <style> body { font-family: Arial, sans-serif; margin: 20px; } #notifications { border: 1px solid #ddd; padding: 10px; margin: 20px 0; max-height: 300px; overflow-y: auto; } .notification { padding: 5px; border-bottom: 1px solid #eee; } .connected { color: green; } .disconnected { color: red; } </style> </head> <body> <h1>Real-time Notifications</h1> <div id="status" class="disconnected">Disconnected</div> <div id="notifications"> <h3>Events</h3> </div> <script> const statusEl = document.getElementById('status'); const notificationsEl = document.getElementById('notifications'); // Connect to WebSocket const ws = new WebSocket('ws://localhost:4000/notifications'); ws.onopen = function() { statusEl.textContent = 'Connected'; statusEl.className = 'connected'; // Subscribe to notifications ws.send(JSON.stringify({ type: 'subscribe' })); }; ws.onmessage = function(event) { const data = JSON.parse(event.data); addNotification(data); }; ws.onclose = function() { statusEl.textContent = 'Disconnected'; statusEl.className = 'disconnected'; }; function addNotification(data) { const div = document.createElement('div'); div.className = 'notification'; const time = new Date().toLocaleTimeString(); switch(data.type) { case 'user_created': div.textContent = `${time}: User created - ${data.user.name}`; break; case 'user_updated': div.textContent = `${time}: User updated - ${data.user.name}`; break; case 'user_deleted': div.textContent = `${time}: User deleted - ID ${data.user_id}`; break; case 'connected': case 'subscribed': div.textContent = `${time}: ${data.message}`; break; default: div.textContent = `${time}: ${JSON.stringify(data)}`; } notificationsEl.appendChild(div); } </script> </body> </html>

class ChatComponent < Azu::Component def initialize(@room_id : String) @messages = [] of NamedTuple(user: String, text: String, time: Time) @users = Set(String).new end def content div class: "chat-room", id: "chat-#{object_id}" do div class: "chat-header" do h3 "Room: #{@room_id}" span id: "user-count" do text "#{@users.size} users" end end div id: "messages", class: "messages" do @messages.each do |msg| render_message(msg) end end form onsubmit: "sendMessage(event)", class: "message-form" do input type: "text", id: "message-input", placeholder: "Type a message..." button type: "submit" do text "Send" end end end end def on_event("send_message", data) message = data["text"]?.try(&.as_s) user = data["user"]?.try(&.as_s) || "Anonymous" return unless message && !message.strip.empty? msg = {user: user, text: message, time: Time.utc} @messages << msg # Append new message to DOM append_element "messages", render_message_html(msg) end def on_event("user_joined", data) user = data["user"]?.try(&.as_s) return unless user @users << user update_element "user-count", "#{@users.size} users" # Add system message append_element "messages", <<-HTML <div class="system-message">#{user} joined the room</div> HTML end def on_event("user_left", data) user = data["user"]?.try(&.as_s) return unless user @users.delete(user) update_element "user-count", "#{@users.size} users" append_element "messages", <<-HTML <div class="system-message">#{user} left the room</div> HTML end private def render_message(msg) div class: "message" do span class: "user" do text msg[:user] end span class: "text" do text msg[:text] end time class: "timestamp" do text msg[:time].to_s("%H:%M") end end end private def render_message_html(msg) <<-HTML <div class="message"> <span class="user">#{msg[:user]}</span> <span class="text">#{msg[:text]}</span> <time class="timestamp">#{msg[:time].to_s("%H:%M")}</time> </div> HTML end end

┌──────────────────────────────────────────────────────┐ │ Azu │ ├──────────────────────────────────────────────────────┤ │ │ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Endpoints │ │ Channels │ │ Components │ │ │ │ │ │ │ │ │ │ │ │ HTTP │ │ WebSocket │ │ Live UI │ │ │ └──────┬──────┘ └──────┬──────┘ └──────┬──────┘ │ │ │ │ │ │ │ └────────────────┼────────────────┘ │ │ │ │ │ ┌───────────────────────┴───────────────────────┐ │ │ │ Router │ │ │ │ (Radix Tree) │ │ │ └───────────────────────┬───────────────────────┘ │ │ │ │ │ ┌───────────────────────┴───────────────────────┐ │ │ │ Handler Pipeline │ │ │ │ Rescuer → Logger → CORS → Auth → Static │ │ │ └───────────────────────────────────────────────┘ │ │ │ ├──────────────────────────────────────────────────────┤ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │ │ Cache │ │ Templates │ │ Config │ │ │ │ Memory/ │ │ Crinja │ │ Environment │ │ │ │ Redis │ │ │ │ │ │ │ └─────────────┘ └─────────────┘ └─────────────┘ │ └──────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐ │ Browser │ │ ┌─────────────────────────────────────────────┐ │ │ │ Rendered HTML │ │ │ │ <button azu-click="increment">+</button> │ │ │ └─────────────────────────────────────────────┘ │ │ │ ↑ │ │ │ Click Event │ HTML Patch │ │ ↓ │ │ │ ┌─────────────────────────────────────────────┐ │ │ │ Spark JavaScript │ │ │ └─────────────────────────────────────────────┘ │ │ │ ↑ │ │ │ WebSocket │ WebSocket │ └─────────│────────────────────│──────────────────────┘ ↓ │ ┌─────────────────────────────────────────────────────┐ │ Server │ │ ┌─────────────────────────────────────────────┐ │ │ │ CounterComponent │ │ │ │ @count = 5 │ │ │ │ │ │ │ │ on_event "increment" → @count += 1 │ │ │ │ → push_state │ │ │ └─────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────┘

Azu

Overview

hashtagQuick Example

hashtagArchitecture

hashtagCore Features

hashtagDocumentation

hashtagTutorials

hashtagHow-To Guides

hashtagReference

hashtagExplanation

hashtagResources

Tutorials

Getting Started

hashtagWhat You'll Learn

hashtagPrerequisites

hashtagStep 1: Install Crystal

hashtagmacOS

hashtagLinux (Ubuntu/Debian)

hashtagLinux (Fedora/CentOS/RHEL)

hashtagWindows

hashtagStep 2: Create Your Project

hashtagStep 3: Create Your First Application

hashtagStep 4: Run Your Application

hashtagStep 5: Test Your Endpoints

hashtagUnderstanding the Code

hashtagApplication Module

hashtagEndpoints

hashtagRoute Parameters

hashtagProject Structure

hashtagTroubleshooting

hashtag"command not found: crystal"

hashtag"Error resolving dependencies"

hashtagPort already in use

hashtagNext Steps

Building a User API

hashtagWhat You'll Build

hashtagPrerequisites

hashtagStep 1: Project Setup

hashtagStep 2: Create the User Model

hashtagStep 3: Create Request Contracts

hashtagStep 4: Create Response Objects

hashtagStep 5: Create Endpoints

hashtagStep 6: Create the Main Application

hashtagStep 7: Run and Test

hashtagCreate a User

hashtagList Users

hashtagGet a User

hashtagUpdate a User

hashtagDelete a User

hashtagTest Validation

hashtagKey Concepts Learned

hashtagType-Safe Contracts

hashtagAutomatic Validation

hashtagStructured Error Responses

hashtagRoute Parameters

hashtagProject Structure

hashtagNext Steps

Adding WebSockets

hashtagWhat You'll Build

hashtagPrerequisites

hashtagStep 1: Understanding WebSocket Channels

hashtagStep 2: Create a Notification Channel

hashtagStep 3: Add Broadcasting to Your API

hashtagStep 4: Update the Main Application

hashtagStep 5: Create a Client Page

hashtagStep 6: Add Static File Handler

hashtagStep 7: Test Real-time Updates

hashtagCreating a Chat Room

hashtagKey Concepts Learned

hashtagChannel Lifecycle

hashtagBroadcasting Patterns

hashtagMessage Protocol

hashtagNext Steps

Working with Databases

hashtagWhat You'll Build

hashtagPrerequisites

hashtagStep 1: Add CQL Dependencies

hashtagStep 2: Define the Schema

hashtagStep 3: Create the Database

hashtagStep 4: Create the Model

Quick Example

Architecture

Core Features

Documentation

Tutorials

How-To Guides

Reference

Explanation

Resources

What You'll Learn

Prerequisites

Step 1: Install Crystal

macOS

Linux (Ubuntu/Debian)

Linux (Fedora/CentOS/RHEL)

Windows

Step 2: Create Your Project

Step 3: Create Your First Application

Step 4: Run Your Application

Step 5: Test Your Endpoints

Understanding the Code

Application Module

Endpoints

Route Parameters

Project Structure

Troubleshooting

"command not found: crystal"

"Error resolving dependencies"

Port already in use

Next Steps

What You'll Build

Prerequisites

Step 1: Project Setup

Step 2: Create the User Model

Step 3: Create Request Contracts

Step 4: Create Response Objects

Step 5: Create Endpoints

Step 6: Create the Main Application

Step 7: Run and Test

Create a User

List Users

Get a User

Update a User

Delete a User

Test Validation

Key Concepts Learned

Type-Safe Contracts

Automatic Validation

Structured Error Responses

Route Parameters

Project Structure

Next Steps

What You'll Build

Prerequisites

Step 1: Understanding WebSocket Channels

Step 2: Create a Notification Channel

Step 3: Add Broadcasting to Your API

Step 4: Update the Main Application

Step 5: Create a Client Page

Step 6: Add Static File Handler

Step 7: Test Real-time Updates

Creating a Chat Room

Key Concepts Learned

Channel Lifecycle

Broadcasting Patterns

Message Protocol

Next Steps

What You'll Build

Prerequisites

Step 1: Add CQL Dependencies

Step 2: Define the Schema

Step 3: Create the Database

Step 4: Create the Model

Step 5: Update Endpoints

Step 6: Update Main Application

Step 7: Adding Relationships

Step 8: Query Examples

Environment Configuration

Key Concepts Learned

Schema Definition