SaaS Pegasus

https://docs.saaspegasus.com
Admin
SaaS Pegasus is a comprehensive boilerplate and framework for building SaaS applications, offering...
Tokens:219,889
Snippets:1,574
Trust Score:9.2
Update:1 year ago
Show doc for...
Tokens:
Raw
### Run Pegasus Project Initialization and Development Servers

Source: https://docs.saaspegasus.com/llms-small

These `make` commands simplify the setup and running of a Pegasus project. `make init` typically sets up databases and installs dependencies, while `make dev` starts the development server. The latter might not be needed if Docker is running in 'full mode'.

```bash
make init
make dev
```

--------------------------------

### Build and Run Frontend (Node.js)

Source: https://docs.saaspegasus.com/getting-started

Commands to install front-end dependencies and start the development server using npm. Assumes a Node.js environment is set up.

```bash
npm install
npm run dev
```

--------------------------------

### Python Database Migration Example

Source: https://docs.saaspegasus.com/llms-small

Demonstrates the commands required to manage database migrations in Django, specifically for new and existing users of the Pegasus project. It highlights the necessity of running `makemigrations` before the initial `migrate` command for new setups.

```bash
# For new users:
./manage.py makemigrations
./manage.py migrate

# For existing users (option 1: keep current migrations):
# No specific commands needed if keeping current migrations.

# For existing users (option 2: re-initialize migrations):
./manage.py makemigrations
./manage.py migrate --fake
```

--------------------------------

### Basic Backend API Access Example (JSX)

Source: https://docs.saaspegasus.com/llms-small

A simplified example showing how to interact with the backend API from the React front end using the `PegasusApi` client. This demonstrates a basic setup for fetching or manipulating data, assuming the API client is installed as a local npm package and authentication is handled via sessions.

```jsx
import {PegasusApi} from "api-client";
import EmployeeApplication from "../../../../assets/javascript/pegasus/examples/react/App.jsx";
import {getApiConfiguration} from "../"
```

--------------------------------

### Example Celerybeat Configuration

Source: https://docs.saaspegasus.com/llms-small

This entry points to an example configuration for Celerybeat, a scheduler for Celery. This is relevant for Kamal deployments that now support scheduled tasks out-of-the-box, providing a template for setting up periodic tasks.

```text
Added an example celerybeat configuration to the built-in examples.
```

--------------------------------

### Install Python Package Requirements

Source: https://docs.saaspegasus.com/getting-started

Install project dependencies using either 'uv sync' or 'pip install -r dev-requirements.txt'. If encountering issues with 'psycopg2', refer to the provided links for potential dependency solutions.

```bash
# with uv
uv sync
# or if using pip tools
pip install -r dev-requirements.txt
```

--------------------------------

### Install Individual npm Packages with make

Source: https://docs.saaspegasus.com/llms-small

This snippet demonstrates how to use the 'make' command to install individual npm packages. It includes an optional argument for specifying packages and is useful for managing project dependencies.

```bash
make npm-install -- <package-name>
```

--------------------------------

### Troubleshooting Kamal Setup Errors

Source: https://docs.saaspegasus.com/llms-small

Commands to individually rebuild or restart services when `kamal setup` fails. These commands help isolate and fix issues with PostgreSQL, Redis, or the proxy. They are useful for resuming deployment after a failed setup.

```bash
# rebuild the PostgreSQL container
kamal accessory reboot postgres

# rebuild the Redis container
kamal accessory reboot redis

# rebuild the proxy container
kamal proxy reboot

# build the proxy container (if it didn't succeed the first time)
kamal proxy boot

# deploy the app
kamal deploy
```

--------------------------------

### Install Frontend Dependencies and Start Dev Server

Source: https://docs.saaspegasus.com/llms-full

Instructions to navigate to the frontend directory, install npm packages, copy the environment file, and start the development server. Requires the Django backend to be running.

```bash
cd frontend
npm install
cp .env.example .env
npm run dev
```

--------------------------------

### Docker Environment File Configuration

Source: https://docs.saaspegasus.com/llms-small

Configuration for Docker environment variables. This change involves moving example environment files (`.env.dev.example`, `.env.production.example`) to their active counterparts (`.env.dev`, `.env.production`). This simplifies the setup process for Docker builds by eliminating the need for manual copying.

```bash
# Move .env.dev.example to .env.dev and .env.production.example to .env.production so they don’t have to be copied to get running (Docker builds only)
```

--------------------------------

### Update Node.js Docker Installation

Source: https://docs.saaspegasus.com/llms-small

This snippet updates the Node.js and npm installation steps in Dockerfiles to align with recent changes from NodeSource. It ensures compatibility and proper setup for Node.js environments within Docker containers. The code uses `curl` to download GPG keys and `apt-get` to install Node.js.

```plaintext
# install node/npm RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | \
 gpg --dearmor -o /usr/share/keyrings/nodesource.gpg RUN echo \
 "deb [signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_18.x nodistro main" | \
 tee /etc/apt/sources.list.d/nodesource.list && \
 apt-get update && \
 apt-get install nodejs -yqq 
```

--------------------------------

### Makefile Commands for SaaS Pegasus

Source: https://docs.saaspegasus.com/llms-small

Demonstrates common commands available through the project's Makefile for tasks like starting containers, database operations, and building the frontend. Running `make` alone lists all available helper functions.

```bash
make
```

--------------------------------

### API Client Initialization and Usage

Source: https://docs.saaspegasus.com/llms-small

Examples of how to initialize and use the auto-generated TypeScript API client.

```APIDOC
## API Client Usage

### Description
Examples demonstrating how to initialize the Pegasus API client and make API calls from your frontend JavaScript code.

### Initialize the API client

```javascript
import { Cookies } from "./app";
import { Configuration, PegasusApi } from "./api-client";

const apiConfig = new Configuration({
  basePath: 'https://yourserver.com/', // or pass this in via {{server_url}} template variable
  headers: {
    'X-CSRFToken': Cookies.get('csrftoken'),
  }
});

const client = new PegasusApi(apiConfig);
```

### Call an API

```javascript
client.employeesList().then((result) => {
  // do something with the API result here
  console.log('your employees are ', result.results);
});
```

### Client Method Naming

Client method names are derived from the `operationId` in the `schema.yaml` file and are converted to camelCase. These can be customized using DRF Spectacular's `extend_schema` helper functions.
```

--------------------------------

### Install and Run Pre-commit Hooks

Source: https://docs.saaspegasus.com/llms-small

This snippet shows how to install pre-commit hooks for a project. Pre-commit is a tool used to manage pre-commit hooks, ensuring code formatting and quality checks before committing.

```bash
pre-commit install --install-hooks
```

--------------------------------

### Stripe CLI Webhook Setup (Development)

Source: https://docs.saaspegasus.com/llms-small

Commands to set up and listen for Stripe webhooks in a development environment using the Stripe CLI. This is essential for testing webhook functionality locally.

```bash
stripe listen --print-secret
```

```bash
docker run --network host --rm -it stripe/stripe-cli listen \
--print-secret \
--api-key sk_test_<your_key>
```

--------------------------------

### Install Ruff Linter and Formatter

Source: https://docs.saaspegasus.com/llms-small

This command installs the 'ruff' tool, a fast Python linter and formatter, using pip. It's a prerequisite for enabling auto-formatting in Pegasus projects.

```bash
pip install ruff
```

--------------------------------

### Run Development Server (Python)

Source: https://docs.saaspegasus.com/getting-started

Commands to start the Django development server. Supports execution with both `uv` and a standard Python virtual environment.

```bash
# with uv
uv run manage.py runserver
# or with normal venv
python ./manage.py runserver
```

--------------------------------

### Update htmx Websocket Extension Installation

Source: https://docs.saaspegasus.com/llms-small

This change involves updating how the htmx websocket extension is installed, moving from a CDN (unpkg.com) to a local installation. This ensures the extension is managed as part of the project's dependencies.

```bash
The htmx websocket extension is now installed locally instead of loaded from unpkg.com.
```

--------------------------------

### Standalone React (Vite) Front End Setup

Source: https://docs.saaspegasus.com/llms-small

This outlines the basic structure and key components of an experimental standalone React front-end application built with Vite. It includes authentication flows and helper components for managing application state.

```javascript
import React from 'react';
import ReactDOM from 'react-dom/client';
import { BrowserRouter as Router, Route, Routes } from 'react-router-dom';
import LoginPage from './pages/LoginPage';
import SignupPage from './pages/SignupPage';
import ProtectedRoute from './components/ProtectedRoute';
import HomePage from './pages/HomePage';

ReactDOM.createRoot(document.getElementById('root')).render(
  <React.StrictMode>
    <Router>
      <Routes>
        <Route path="/login" element={<LoginPage />} />
        <Route path="/signup" element={<SignupPage />} />
        <Route path="/" element={<ProtectedRoute><HomePage /></ProtectedRoute>} />
        {/* Other routes */}
      </Routes>
    </Router>
  </React.StrictMode>
);
```

--------------------------------

### Legacy Webhook Setup (Before Pegasus 2025.4.1)

Source: https://docs.saaspegasus.com/llms-small

Instructions for setting up Stripe webhooks for versions prior to Pegasus 2025.4.1. This involves configuring the webhook directly in the Stripe dashboard, specifying the endpoint URL, selecting events, and setting the `DJSTRIPE_WEBHOOK_SECRET` in `settings.py`.

```bash
# In Stripe Dashboard:
# Toggle off test mode.
# Click 'Add endpoint'.
# Endpoint URL: https://yourserver.com/stripe/webhook/ (trailing slash required)
# Select Events: checkout.session.completed, customer.subscription.updated, customer.subscription.deleted

# In settings.py or environment variable:
# DJSTRIPE_WEBHOOK_SECRET = <your_signing_secret>
```

--------------------------------

### Webpack Entry Configuration

Source: https://docs.saaspegasus.com/llms-small

Example of how Webpack entry points are configured in `webpack.config.js`. This defines the main JavaScript and CSS files for the project's bundles.

```javascript
entry: {
  'site-base': './assets/site-base.js',
  // base styles shared between frameworks
  'site-tailwind': './assets/site-tailwind.js',
  // required for tailwindcss styles
  site: './assets/javascript/site.js',
  // global site javascript
  app: './assets/javascript/app.js',
  // logged-in javascript
  dashboard: './assets/javascript/shadcn-dashboard/index.jsx',
  teams: './assets/javascript/teams/teams.jsx',
  'edit-team': './assets/javascript/teams/edit-team.jsx',
  'chat': './assets/javascript/chat/chat.jsx',
}
```

--------------------------------

### Environment Variable File Example

Source: https://docs.saaspegasus.com/llms-small

Provides an example of how environment variables are defined within a `.env` file, using a simple key-value pair format. This file is typically used for managing settings that vary across different deployment environments, such as development or production.

```dotenv
SOME_VALUE=''
```

--------------------------------

### Build and Deployment Commands for React Frontend

Source: https://docs.saaspegasus.com/llms-small

These are the essential commands for building the React frontend for deployment and configuring environment variables for static site hosting.

```bash
# Build the frontend for production
npm run build

# Example environment variables for build time (e.g., in .env file or CI/CD)
VITE_APP_BASE_URL=https://<your Django backend URL>
VITE_ALLAUTH_BASE_URL=https://<your Django backend URL>/_allauth/browser/v1
```

--------------------------------

### Configure SSL for macOS

Source: https://docs.saaspegasus.com/getting-started

On macOS, if you face SSL-related installation issues, you might need to reinstall OpenSSL using Homebrew and then update your environment's library path to include the OpenSSL library.

```bash
brew reinstall openssl
export LIBRARY_PATH=$LIBRARY_PATH:/usr/local/opt/openssl/lib/
```

--------------------------------

### Create Fly.io App and Services via CLI

Source: https://docs.saaspegasus.com/llms-small

This command initiates the creation of a new Fly.io application and its associated services. It requires the flyctl CLI to be installed and authenticated. The command prompts for confirmation and allows customization of app settings, including database and Redis instances.

```bash
$ fly launch --dockerfile Dockerfile.web \
    --dockerignore-from-gitignore \
    --no-deploy \
    --name {app-name} \
    --region ord
```

```bash
$ fly postgres create --name {app-name}-db --region ord
# ? Select Organization: My Org
# ? Select configuration: Development - Single node, 1x shared CPU, 256MB RAM, 1GB disk
```

```bash
$ fly postgres attach {app-name}-db -a {app-name}
Postgres cluster {app-name}-db is now attached to {app-name}
The following secret was added to <app name>: DATABASE_URL=postgres://.....
```

```bash
$ fly redis create --name {app-name}-redis --region ord
? Select Organization: My Org (my_org)
? Would you like to enable eviction? Yes
? Select an Upstash Redis plan Free: 100 MB Max Data Size
Your Upstash Redis database {app-name}-redis is ready.
Apps in the personal org can connect to at redis://.....
```

```bash
$ fly secrets set REDIS_URL={url}
```

--------------------------------

### Initial Kamal Deployment Command

Source: https://docs.saaspegasus.com/deployment/kamal

This command initiates the first deployment of your application using Kamal. It handles server setup, Docker installation, image building and pushing, and application containerization. Root access via SSH is required for server setup.

```bash
kamal setup
```

--------------------------------

### Synchronize Project Dependencies with uv

Source: https://docs.saaspegasus.com/python/setup

Synchronizes project dependencies using the uv package manager. This command installs the correct Python version if needed, creates a virtual environment in a '.venv' folder, and installs all project dependencies.

```bash
uv sync
```

--------------------------------

### Install uv Package Manager (Windows)

Source: https://docs.saaspegasus.com/python/setup

Installs the uv package manager on Windows systems using PowerShell. It bypasses execution policy restrictions to download and run the installation script. Requires uv version 0.5 or higher.

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

--------------------------------

### API Documentation Endpoints

Source: https://docs.saaspegasus.com/llms-small

Pegasus apps ship with built-in API documentation, accessible via Swagger UI and Redoc.

```APIDOC
## API Documentation Access

### Description
Access the automatically generated API documentation for your Pegasus application.

### Endpoints
- `/api/schema/swagger-ui/`: Provides API documentation in Swagger UI format.
- `/api/schema/redoc/`: Provides API documentation in Redoc format.

### Example Usage
Navigate to `http://localhost:8000/api/schema/swagger-ui/` in your browser during development to view the interactive API documentation.
```

--------------------------------

### Django Template Context Processor Configuration

Source: https://docs.saaspegasus.com/llms-small

Shows how to configure a custom template context processor in Django. The example implies a move away from older settings like `PEGASUS_USING_TEAMS` and `pegasus_settings`, suggesting configuration is handled at installation time.

```python
# In your settings.py file

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
                # Example of a custom context processor (if still used)
                # 'myapp.context_processors.my_custom_processor',
            ],
        },
    },
]

# Note: The text indicates 'PEGASUS_USING_TEAMS' and 'pegasus_settings'
# context processors were removed. This example shows the standard structure.
# Configuration is now handled at installation time, not via settings variables.
```

--------------------------------

### Initialize Git Repository and Commit

Source: https://docs.saaspegasus.com/getting-started

Manually initialize a Git repository for your project if you downloaded the source code as a zip file. This involves creating a new repository, staging all files, and making an initial commit.

```bash
git init
git add .

git commit -am "initial project creation"
```

--------------------------------

### Create PostgreSQL Database

Source: https://docs.saaspegasus.com/llms-small

Command to create a new PostgreSQL database for the application. Replace placeholders with your specific user and database names.

```bash
kamal accessory exec postgres "createdb -h localhost -p 5432 -U <your_app_user> <your_app_db_name>" --reuse
```

--------------------------------

### Clone Project from GitHub

Source: https://docs.saaspegasus.com/getting-started

Use 'git clone' to download your project's source code if you have integrated with GitHub. This command requires the Git URL provided by GitHub and specific project details.

```bash
git clone https://github.com/user/project-id.git
```

--------------------------------

### Verify Docker Installation

Source: https://docs.saaspegasus.com/llms-small

Command to check if Docker is installed and accessible on the system. Expected output shows the Docker version.

```plaintext
Docker version 24.0.5, build 24.0.5-0ubuntu1~20.04.1
```

--------------------------------

### Run Development Server

Source: https://docs.saaspegasus.com/getting-started

Execute the 'make init' and 'make dev' commands to set up and run your project in a development environment. 'make dev' is optional if Docker is in 'full mode'. Access your application at http://localhost:8000.

```bash
make init
make dev  # This is not required if running Docker in "full mode"
```

--------------------------------

### Navigate to Project Directory

Source: https://docs.saaspegasus.com/getting-started

Change the current directory to your project's root folder. This command assumes your project directory is named using a placeholder for the project name.

```bash
cd {{ project_name }}
```

--------------------------------

### Initialize Git Repository and Commit Project Files

Source: https://docs.saaspegasus.com/llms-small

These commands are used when downloading the project as a zip file. They initialize a new Git repository, stage all project files, and create an initial commit. It's also recommended to create a 'pegasus' branch for future upgrades.

```bash
git init
git add .
git commit -am "initial project creation"
git branch pegasus
```

--------------------------------

### Run Database Migrations (Python)

Source: https://docs.saaspegasus.com/getting-started

Commands to apply database migrations using Django's `migrate` command. Supports execution with both `uv` and a standard Python virtual environment.

```bash
# with uv
uv run manage.py migrate
# or with normal venv
python ./manage.py migrate
```

--------------------------------

### Run Celery Worker with Gevent Pool

Source: https://docs.saaspegasus.com/llms-small

Installs gevent and starts a Celery worker using the 'gevent' concurrency pool, suitable for I/O bound tasks and Windows compatibility.

```bash
pip install gevent
celery -A {{ project_name }} worker -l info -P gevent 
```

--------------------------------

### Conditional Inclusion of Stripe Card Element

Source: https://docs.saaspegasus.com/llms-small

This Django template snippet shows how to conditionally include a Stripe payment component. It's moved to an examples directory and only included if the project is built with examples.

```html
{% if include_stripe_examples %}
    {% include "pegasus/examples/payments/components/card_element.html" %}
{% endif %}

```

--------------------------------

### Create PostgreSQL Database

Source: https://docs.saaspegasus.com/getting-started

Commands to create a new PostgreSQL database for your project. It requires specifying the username, host, port, and project name. An alternative using identity authentication is also provided.

```bash
createdb -U postgres -h localhost -p 5432 {{ project_name }}
sudo -u postgres createdb {{ project_name }}
```

--------------------------------

### Troubleshooting and Restarting Services with Kamal

Source: https://docs.saaspegasus.com/llms-full

Provides commands for troubleshooting setup issues by individually rebooting or starting specific services managed by Kamal. This includes PostgreSQL, Redis, and the proxy, as well as deploying the application and checking logs.

```bash
# rebuild the PostgreSQL container
kamal accessory reboot postgres

```

```bash
# rebuild the Redis container
kamal accessory reboot redis

```

```bash
# rebuild the proxy container
kamal proxy reboot

```

```bash
# build the proxy container (if it didn't succeed the first time)
kamal proxy boot

```

```bash
# deploy the app
kamal deploy

```

```bash
kamal app logs

```

--------------------------------

### Update Dockerfile.dev for Node 22 Installation

Source: https://docs.saaspegasus.com/llms-small

This snippet provides a patch to update the `Dockerfile.dev` to install Node version 22. It includes steps to update package lists, add the NodeSource repository, and install Node.js. This is useful for ensuring development environments are up-to-date with the latest Node.js versions.

```diff
RUN --mount=target=/var/lib/apt/lists,type=cache,sharing=locked \
--mount=target=/var/cache/apt,type=cache,sharing=locked \
rm -f /etc/apt/apt.conf.d/docker-clean && \
echo "deb https://deb.nodesource.com/node_22.x bookworm main" > /etc/apt/sources.list.d/nodesource.list && \
wget -qO- https://deb.nodesource.com/gpgkey/nodesource.gpg.key | apt-key add - && \
curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
apt-get update && \
apt-get install -yqq nodejs \

```

--------------------------------

### Create Database Migrations (Python)

Source: https://docs.saaspegasus.com/getting-started

Commands to generate database migration files using Django's `makemigrations` command. Supports execution with both `uv` and a standard Python virtual environment.

```bash
# with uv
uv run manage.py makemigrations
# or with normal venv
python ./manage.py makemigrations
```

--------------------------------

### Configure Django Debug Toolbar

Source: https://docs.saaspegasus.com/llms-small

This snippet shows how to add the django-debug-toolbar to your project settings for development. It requires installation and configuration as per the django-debug-toolbar documentation.

```python
INSTALLED_APPS = [
    # ...
    'debug_toolbar',
    # ...
]

MIDDLEWARE = [
    # ...
    'debug_toolbar.middleware.DebugToolbarMiddleware',
    # ...
]

INTERNAL_IPS = [
    '127.0.0.1',
]

```

--------------------------------

### Use Bootstrap Modal in Django Template (Jinja)

Source: https://docs.saaspegasus.com/llms-small

An example of how to use the Bootstrap Modal component within a Django template after making Bootstrap JavaScript globally available. This specific example shows how to display a modal with ID 'onLoadModal' when the page loads.

```jinja
{% block page_js %}
<script>
document.addEventListener('DOMContentLoaded', function() {
  const onLoadModal = new bootstrap.Modal(document.getElementById('onLoadModal'));
  onLoadModal.show();
});
</script>
{% endblock %}
```

--------------------------------

### Create Git Branch for Upgrades

Source: https://docs.saaspegasus.com/getting-started

It is recommended to create a new 'pegasus' branch immediately after initializing your Git repository. This branch is intended for managing future project upgrades.

```bash
git branch pegasus
```

--------------------------------

### Example Custom Webhook Handling in dj-stripe

Source: https://docs.saaspegasus.com/llms-small

This Python code snippet demonstrates how to implement custom logic when processing webhooks, specifically mailing project admins upon subscription cancellation. This is an example found in `apps/subscriptions/webhooks.py` for extending default dj-stripe behavior.

```python
from dj_stripe.views import StripeWebhookView
from django.core.mail import mail_admins

class CustomWebhookView(StripeWebhookView):
    def subscription_canceled(self, event):
        mail_admins(
            'Subscription Canceled',
            f'Subscription {event.data.object.id} was canceled.'
        )
        # Call the original method if needed
        # super().subscription_canceled(event)

```

--------------------------------

### Django Template JS Bundle Reference (Webpack)

Source: https://docs.saaspegasus.com/llms-small

Illustrates how JavaScript bundle files were referenced in Django templates using the `static` tag in a Webpack setup.

```jinja
{% block page_js %}
 <script src="{% static 'js/app-bundle.js' %}" defer></script>
{% endblock %}
```

--------------------------------

### Install and Build Frontend Assets with npm

Source: https://docs.saaspegasus.com/deployment/production-checklist

This snippet demonstrates the commands to install project dependencies and build optimized front-end assets using npm. It's typically run as part of a CI/CD pipeline for production deployments. Ensure Node.js and npm are installed on the production server.

```bash
npm install && npm run build
```

--------------------------------

### Initialize Git Repository and Commit

Source: https://docs.saaspegasus.com/llms-full

Commands to initialize a new Git repository, add all project files, and make the initial commit. This is used when downloading the project as a zip file instead of using the GitHub integration.

```bash
git init
git add .Building
git commit -am "initial project creation"
```

--------------------------------

### Configure webpack.config.js for JavaScript Setup

Source: https://docs.saaspegasus.com/llms-small

This code demonstrates how to move JavaScript setup for chat functionality to the end of `module.exports` in `webpack.config.js`. This change is part of organizational updates aimed at improving code structure and maintainability within the project's frontend build process.

```javascript
// Moved chat JavaScript setup to the end of module.exports in webpack.config.js
// Example structure:
// module.exports = {
//   // ... other configurations
//   plugins: [
//     // ... other plugins
//   ],
//   // Chat JavaScript setup here
// };
```

--------------------------------

### Troubleshoot and Reboot Services with Kamal

Source: https://docs.saaspegasus.com/deployment/kamal

Commands to reboot individual services like PostgreSQL, Redis, or the proxy, and to rebuild or boot containers if setup fails. These commands help in troubleshooting deployment issues by isolating and restarting specific components. Ensure you have the necessary permissions to run these commands.

```bash
# rebuild the PostgreSQL container
kamal accessory reboot postgres
```

```bash
# rebuild the Redis container
kamal accessory reboot redis
```

```bash
# rebuild the proxy container
kamal proxy reboot
```

```bash
# build the proxy container (if it didn't succeed the first time)
kamal proxy boot
```

```bash
# deploy the app
kamal deploy
```

```bash
kamal app logs
```

--------------------------------

### Make dbshell Docker Command

Source: https://docs.saaspegasus.com/llms-small

A make command for Docker environments to easily access a database shell. This simplifies database management tasks within the containerized setup.

```makefile
dbshell:
	docker-compose run --rm web psql -h db -U postgres
```

--------------------------------

### Celery Scheduled Tasks Configuration

Source: https://docs.saaspegasus.com/llms-small

Python code example for configuring scheduled tasks in settings.py using crontab for Celery Beat, leveraging django-celery-beat for database storage.

```python
from celery.schedules import crontab

SCHEDULED_TASKS = {
    'example-task-every-morning': {
        'task': '{{ project_name }}.tasks.example_task',
        'schedule': crontab(hour=7, minute=0), # Run every day at 7:00 AM
    },
    'another-example-every-hour': {
        'task': '{{ project_name }}.tasks.another_example',
        's
```

--------------------------------

### Example React Frontend .env file for Development

Source: https://docs.saaspegasus.com/llms-full

This is an example of a `.env` file for the React frontend, used during development. It shows how to set the `VITE_APP_BASE_URL` variable. This file is essential for resolving 'URI malformed' errors if it's missing or incorrectly configured.

```env
VITE_APP_BASE_URL=http://localhost:8000
```

--------------------------------

### Navigate to Frontend Directory

Source: https://docs.saaspegasus.com/experimental/react-front-end

Change the current directory to the 'frontend' folder to begin setup.

```bash
cd frontend
```

--------------------------------

### Configure Email Backend with Django Anymail

Source: https://docs.saaspegasus.com/llms-small

Sets up Django to send emails using Anymail, with examples for Mailgun. Requires setting EMAIL_BACKEND and ANYMAIL settings in settings.py.

```python
EMAIL_BACKEND = 'anymail.backends.mailgun.EmailBackend'

ANYMAIL = {
    "MAILGUN_API_KEY": "key-****",
    "MAILGUN_SENDER_DOMAIN": 'mg.{{project_name}}.com',
    # For EU users:
    # 'MAILGUN_API_URL': 'https://api.eu.mailgun.net/v3',
}

SERVER_EMAIL = 'noreply@{{project_name}}.com'
DEFAULT_FROM_EMAIL = 'you@{{project_name}}.com'
ADMINS = [('Your Name', 'you@{{project_name}}.com'),]
```

--------------------------------

### Alpine.js Integration in Base Template

Source: https://docs.saaspegasus.com/llms-small

This example shows how Alpine.js is added as a top-level JavaScript dependency, included on all pages for frontend interactivity. It's typically linked in the base HTML template.

```html
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>SaaS Pegasus</title>
    <!-- Other head elements -->
</head>
<body>
    <!-- Page content -->

    <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.min.js"></script>
</body>
</html>

```

--------------------------------

### Run Django Deployment Checklist

Source: https://docs.saaspegasus.com/llms-small

Execute Django's built-in deployment checklist command on your production server to identify and address critical configuration issues. This helps ensure your site is secure and available.

```bash
python manage.py check --deploy
```

--------------------------------

### Django Settings Configuration for dj-stripe

Source: https://docs.saaspegasus.com/llms-small

Configuration settings for dj-stripe in Django's settings.py file. These settings are crucial for handling foreign keys and JSON field usage, especially when upgrading from previous installations. Adjustments might be needed based on whether it's a new installation or an existing one.

```python
DJSTRIPE_FOREIGN_KEY_TO_FIELD = 'id' # change to 'djstripe_id' if not a new installation
DJSTRIPE_USE_NATIVE_JSONFIELD = True # change to False if not a new installation
```

--------------------------------

### Add simple-datatables with JavaScript

Source: https://docs.saaspegasus.com/llms-small

This JavaScript code snippet demonstrates how to install and integrate the `simple-datatables` library into a Pegasus project. It shows how to import the DataTable class and initialize a new data table with specific configurations.

```bash
npm install simple-datatables
```

```javascript
import { DataTable } from 'simple-datatables';
window.DataTable = DataTable;
```

```javascript
// initialize the table with id "mytable"
const dataTable = new DataTable("#mytable", {
  searchable: true,
  fixedHeight: true,
});
```

--------------------------------

### Create Environment File

Source: https://docs.saaspegasus.com/experimental/react-front-end

Copy the example environment file to create a new .env file for custom configurations.

```bash
cp .env.example .env
```

--------------------------------

### Python Backend Check for Payment Exploits

Source: https://docs.saaspegasus.com/llms-small

Provides a conceptual example of a backend check within a payment processing system to prevent client-side exploits. This is crucial for maintaining the security and integrity of financial transactions.

```python
# Example in a Django view for handling payments
from django.http import HttpResponseBadRequest
from django.views.decorators.csrf import csrf_exempt

@csrf_exempt
def process_payment(request):
    if request.method == 'POST':
        # 1. Validate received payment data (amount, currency, user details, etc.)
        #    This should NEVER trust client-side input directly.
        expected_amount = calculate_expected_amount(request.user) # Logic to determine correct amount
        received_amount = float(request.POST.get('amount'))

        if received_amount != expected_amount:
            return HttpResponseBadRequest("Invalid payment amount.")

        # 2. Perform further security checks (e.g., token validation, nonce checks)
        if not is_payment_token_valid(request.POST.get('payment_token')):
            return HttpResponseBadRequest("Invalid payment token.")

        # 3. Process the payment using a secure payment gateway integration
        #    payment_gateway.charge(received_amount, ...)

        return HttpResponse("Payment successful!")
    else:
        return HttpResponseBadRequest("Invalid request method.")

def calculate_expected_amount(user):
    # Replace with actual logic to determine the correct amount based on user, subscription, etc.
    return 100.00

def is_payment_token_valid(token):
    # Replace with actual logic to validate a payment token or nonce
    return True
```

--------------------------------

### Configure Environment Variables

Source: https://docs.saaspegasus.com/llms-full

These commands set up your local environment by copying an example .env file, prompting you to update it with project-specific values (like passwords and keys), and then sourcing the updated file to load these variables into your shell session. This ensures subsequent commands use your project's configuration.

```bash
cp deploy/.env.google.example deploy/.env.google
source deploy/.env.google
```

--------------------------------

### Docker Environment File Management

Source: https://docs.saaspegasus.com/llms-full

This update describes a change in how environment files are managed for Docker builds. The example files `.env.dev.example` and `.env.production.example` have been renamed to `.env.dev` and `.env.production` respectively. This simplifies the initial setup by removing the need for manual copying when running Docker builds.

```bash
# Moved .env.dev.example to .env.dev
# Moved .env.production.example to .env.production
```

--------------------------------

### Create and Activate virtualenv Environment

Source: https://docs.saaspegasus.com/llms-small

Creates a Python virtual environment using the 'virtualenv' tool and then activates it. This allows for project-specific Python installations. Replace 'python3.12' with the desired Python version and '/path/to/environment' with the preferred directory.

```bash
virtualenv -p python3.12 /path/to/environment
source /path/to/environment/bin/activate
```

--------------------------------

### Django Template JS Asset Reference (Vite)

Source: https://docs.saaspegasus.com/llms-small

Demonstrates how to reference JavaScript assets in Django templates using the `vite_asset` tag in a Vite setup. This uses the source file path instead of the bundled file.

```jinja
{% block page_js %}
 {% vite_asset 'assets/javascript/app.js' %}
{% endblock %}
```

--------------------------------

### Celerybeat Configuration Example (YAML)

Source: https://docs.saaspegasus.com/release-notes

An example configuration for Celerybeat, demonstrating how to set up scheduled tasks out-of-the-box with Kamal deployments. This configuration is included in the built-in examples to facilitate the use of scheduled tasks.

```yaml
# Example Celerybeat configuration
celerybeat:
  image: your-celerybeat-image
  command: "celery -A your_project beat -l info --scheduler django_celery_beat.schedulers.DatabaseScheduler"
  depends_on:
    - redis
    - web
  environment:
    - DATABASE_URL=... # your database connection string
  volumes:
    - .:/app

```

--------------------------------

### Wagtail StreamField Migration Example

Source: https://docs.saaspegasus.com/llms-small

Demonstrates how to migrate existing RichTextField content to StreamField in Wagtail. This allows for more flexible content layout and the re-use of structured components. It involves creating a migration file to perform the conversion.

```python
from django.db import migrations, models
import wagtail.blocks as blocks
import wagtail.fields as fields


def convert_stream_fields(apps, schema_editor):
    # Placeholder for actual migration logic to convert RichTextField to StreamField
    pass

class Migration(migrations.Migration):

    dependencies = [
        ('your_app', '0001_initial'), # Replace with your actual dependency
    ]

    operations = [
        migrations.RunPython(convert_stream_fields),
        migrations.AddField(
            model_name='YourModelName', # Replace with your model name
            name='body',
            field=fields.StreamField([
                ('paragraph', blocks.RichTextBlock()),
                ('image', blocks.StructBlock([
                    ('image', blocks.ImageChooserBlock()),
                    ('caption', blocks.CharBlock(required=False))
                ]))
            ], use_json_field=True),
            preserve_default=False,
        ),
    ]
```

--------------------------------

### Configure Docker Multi-stage Build

Source: https://docs.saaspegasus.com/llms-small

This snippet illustrates the concept of a multi-stage Docker build. It allows for optimizing build times and improving cache utilization by separating build-time dependencies from runtime dependencies.

```docker
# Example Dockerfile with multi-stage build

# ---- Builder Stage ----
FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./ 
RUN npm install
COPY . .
RUN npm run build

# ---- Production Stage ----
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]
```

--------------------------------

### Update Python Packages in Dockerized Environment

Source: https://docs.saaspegasus.com/llms-small

Updates Python dependencies by rebuilding the requirements.txt file and then rebuilding and restarting the Docker containers. This process ensures that new or modified packages are correctly installed and reflected in the running application.

```bash
make requirements

```

--------------------------------

### Generate TypeScript-Fetch API Client Natively

Source: https://docs.saaspegasus.com/llms-small

Generates the TypeScript-fetch API client using OpenAPI Generator CLI. This process requires Node.js and Java to be installed. The client is generated by fetching the schema from a running Django server.

```bash
npm install @openapitools/openapi-generator-cli -g
openapi-generator-cli generate -i http://localhost:8000/api/schema/ -g typescript-fetch -o ./api-client/ "

```

--------------------------------

### Add or Remove Python Packages with uv

Source: https://docs.saaspegasus.com/llms-small

Commands to add or remove Python packages using uv. Updates `pyproject.toml`, `uv.lock`, and syncs the virtual environment for native installations. For Docker, requires rebuilding and restarting containers.

```bash
# native version
uv add <package_name>
uv remove <package_name>

# docker version
make uv add <package_name>
make uv remove <package_name>
```

```bash
# Docker rebuild and restart
make build
make restart
```

```bash
# Sync uv.lock and rebuild/restart Docker containers
make requirements
```

--------------------------------

### Render Blueprint Configuration Snippet

Source: https://docs.saaspegasus.com/llms-small

This YAML snippet shows how to configure the `preDeployCommand` within a `render.yaml` file. This command specifies a script to run before the main deployment process, allowing for tasks like database migrations.

```yaml
buildCommand: "./deploy/build.sh"
preDeployCommand: "./deploy/pre_deploy.sh"

```

--------------------------------

### Pre-commit Usage Examples

Source: https://docs.saaspegasus.com/llms-full

Demonstrates how to run pre-commit hooks against staged files or all files in the repository. This is useful for manual checks or in CI environments.

```bash
# run all hooks against currently staged files
pre-commit run
# run all the hooks against all the files. This is a useful invocation if you are using pre-commit in CI.
pre-commit run --all-files
```

--------------------------------

### Copy Secrets Example File

Source: https://docs.saaspegasus.com/deployment/kamal

This command copies the example secrets file to be used for actual secrets. This file should not be committed to source control. It contains environment variables needed for deployment.

```bash
cp .kamal/secrets.example .kamal/secrets
```

--------------------------------

### Promote User to Superuser in Django Admin (Native)

Source: https://docs.saaspegasus.com/llms-small

This command promotes a user to a superuser in a native Django development setup, enabling access to the Django admin panel. The user's email address must be provided as an argument.

```bash
python ./manage.py promote_user_to_superuser yourname@example.com
```

--------------------------------

### Generate TypeScript-Fetch API Client with Docker

Source: https://docs.saaspegasus.com/llms-small

Generates the TypeScript-fetch API client using Docker. This method avoids the need to install Java locally. It requires a running Django server and assumes a `make build-api-client` command is available.

```bash
make build-api-client

```

--------------------------------

### Bash Script for Pre-Deployment Database Migrations

Source: https://docs.saaspegasus.com/llms-small

This optional script, `pre_deploy.sh`, is designed to run database migrations during the pre-deploy phase on Render. It requires removing the migration commands from the standard `build.sh` and configuring `render.yaml`. This is not supported on Render's free tier.

```bash
#!/usr/bin/env bash
# exit on error
set -o errexit
export DJANGO_SETTINGS_MODULE={{cookiecutter.project_slug}}.settings_production
echo "Running database migrations"
python manage.py migrate

```

--------------------------------

### Install Project Dependencies with Pip

Source: https://docs.saaspegasus.com/llms-full

Installs all development dependencies required for the project using pip and a requirements file. Ensure pip is installed and accessible in your environment.

```bash
pip install -r dev-requirements.txt
```

--------------------------------

### Configure Django Production Settings

Source: https://docs.saaspegasus.com/llms-small

Ensure your Django site is accessible only via specified domains by setting ALLOWED_HOSTS in your production settings file. This prevents HTTP host header attacks. Example uses 'example.com' as a placeholder for your actual domain.

```python
ALLOWED_HOSTS = [
  'example.com', # use your app's domain here
]
```

--------------------------------

### Use Imported Bootstrap Modal in Django Template (JavaScript)

Source: https://docs.saaspegasus.com/llms-small

This example shows how to use an individually imported Bootstrap modal component within a Django template. Since 'Modal' is now a global variable, it can be instantiated directly without the `bootstrap.` prefix.

```javascript
const onLoadModal = new Modal(document.getElementById('landing-page-modal'));
```

--------------------------------

### Configuring CI for Code Formatting Checks

Source: https://docs.saaspegasus.com/llms-small

This describes a fix for a syntax error in 'render.yaml' affecting deployments and a change in CI setup for code formatting checks. The formatting checks are now exclusively run on pull requests, not on direct commits to a branch.

```yaml
# Example render.yaml snippet (illustrative)
services:
  app:
    type: web
    port: 8000
    env: python

```
Tokens:
Raw