+
+
+## Technology Stack and Features
+
+- โก [**FastAPI**](https://fastapi.tiangolo.com) for the Python backend API.
+ - ๐งฐ [SQLModel](https://sqlmodel.tiangolo.com) for the Python SQL database interactions (ORM).
+ - ๐ [Pydantic](https://docs.pydantic.dev), used by FastAPI, for the data validation and settings management.
+ - ๐พ [PostgreSQL](https://www.postgresql.org) as the SQL database.
+- ๐ [React](https://react.dev) for the frontend.
+ - ๐ Using TypeScript, hooks, Vite, and other parts of a modern frontend stack.
+ - ๐จ [Chakra UI](https://chakra-ui.com) for the frontend components.
+ - ๐ค An automatically generated frontend client.
+ - ๐งช [Playwright](https://playwright.dev) for End-to-End testing.
+ - ๐ฆ Dark mode support.
+- ๐ [Docker Compose](https://www.docker.com) for development and production.
+- ๐ Secure password hashing by default.
+- ๐ JWT (JSON Web Token) authentication.
+- ๐ซ Email based password recovery.
+- โ
Tests with [Pytest](https://pytest.org).
+- ๐ [Traefik](https://traefik.io) as a reverse proxy / load balancer.
+- ๐ข Deployment instructions using Docker Compose, including how to set up a frontend Traefik proxy to handle automatic HTTPS certificates.
+- ๐ญ CI (continuous integration) and CD (continuous deployment) based on GitHub Actions.
-[](https://travis-ci.org/tiangolo/full-stack-fastapi-postgresql)
+### Dashboard Login
-Generate a backend and frontend stack using Python, including interactive API documentation.
+[](https://github.com/fastapi/full-stack-fastapi-template)
-### Interactive API documentation
+### Dashboard - Admin
-[](https://github.com/tiangolo/full-stack-fastapi-postgresql)
+[](https://github.com/fastapi/full-stack-fastapi-template)
+### Dashboard - Create User
-### Alternative API documentation
+[](https://github.com/fastapi/full-stack-fastapi-template)
-[](https://github.com/tiangolo/full-stack-fastapi-postgresql)
+### Dashboard - Items
+[](https://github.com/fastapi/full-stack-fastapi-template)
-### Dashboard Login
+### Dashboard - User Settings
-[](https://github.com/tiangolo/full-stack-fastapi-postgresql)
+[](https://github.com/fastapi/full-stack-fastapi-template)
+### Dashboard - Dark Mode
-### Dashboard - Create User
+[](https://github.com/fastapi/full-stack-fastapi-template)
+
+### Interactive API Documentation
+
+[](https://github.com/fastapi/full-stack-fastapi-template)
+
+## How To Use It
+
+You can **just fork or clone** this repository and use it as is.
+
+โจ It just works. โจ
+
+### How to Use a Private Repository
-[](https://github.com/tiangolo/full-stack-fastapi-postgresql)
-
-## Features
-
-* Full **Docker** integration (Docker based).
-* Docker Swarm Mode deployment.
-* **Docker Compose** integration and optimization for local development
-* **Production ready** Python web server using Uvicorn and Gunicorn.
-* Python **[FastAPI](https://github.com/tiangolo/fastapi)** backend:
- * **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic).
- * **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
- * **Easy**: Designed to be easy to use and learn. Less time reading docs.
- * **Short**: Minimize code duplication. Multiple features from each parameter declaration.
- * **Robust**: Get production-ready code. With automatic interactive documentation.
- * **Standards-based**: Based on (and fully compatible with) the open standards for APIs: OpenAPI and JSON Schema.
- * [**Many other features**](https://github.com/tiangolo/fastapi) including automatic validation, serialization, interactive documentation, authentication with OAuth2 JWT tokens, etc.
-* **Secure password** hashing by default.
-* **JWT token** authentication.
-* **SQLAlchemy** models (independent of Flask extensions, so they can be used with Celery workers directly).
-* Basic starting models for users (modify and remove as you need).
-* **Alembic** migrations.
-* **CORS** (Cross Origin Resource Sharing).
-* **Celery** worker that can import and use models and code from the rest of the backend selectively (you don't have to install the complete app in each worker).
-* REST backend tests based on **Pytest**, integrated with Docker, so you can test the full API interaction, independent on the database. As it runs in Docker, it can build a new data store from scratch each time (so you can use ElasticSearch, MongoDB, CouchDB, or whatever you want, and just test that the API works).
-* Easy Python integration with **Jupyter Kernels** for remote or in-Docker development with extensions like Atom Hydrogen or Visual Studio Code Jupyter.
-* **Vue** frontend:
- * Generated with Vue CLI.
- * **JWT Authentication** handling.
- * Login view.
- * After login, main dashboard view.
- * Main dashboard with user creation and edition.
- * Self user edition.
- * **Vuex**.
- * **Vue-router**.
- * **Vuetify** for beautiful material design components.
- * **TypeScript**.
- * Docker server based on **Nginx** (configured to play nicely with Vue-router).
- * Docker multi-stage building, so you don't need to save or commit compiled code.
- * Frontend tests ran at build time (can be disabled too).
- * Made as modular as possible, so it works out of the box, but you can re-generate with Vue CLI or create it as you need, and re-use what you want.
-* **PGAdmin** for PostgreSQL database, you can modify it to use PHPMyAdmin and MySQL easily.
-* **Flower** for Celery jobs monitoring.
-* Load balancing between frontend and backend with **Traefik**, so you can have both under the same domain, separated by path, but served by different containers.
-* Traefik integration, including Let's Encrypt **HTTPS** certificates automatic generation.
-* GitLab **CI** (continuous integration), including frontend and backend testing.
-
-## How to use it
-
-Go to the directoy where you want to create your project and run:
+If you want to have a private repository, GitHub won't allow you to simply fork it as it doesn't allow changing the visibility of forks.
+
+But you can do the following:
+
+- Create a new GitHub repo, for example `my-full-stack`.
+- Clone this repository manually, set the name with the name of the project you want to use, for example `my-full-stack`:
```bash
-pip install cookiecutter
-cookiecutter https://github.com/tiangolo/full-stack-fastapi-postgresql
+git clone git@github.com:fastapi/full-stack-fastapi-template.git my-full-stack
```
-### Generate passwords
+- Enter into the new directory:
+
+```bash
+cd my-full-stack
+```
-You will be asked to provide passwords and secret keys for several components. Open another terminal and run:
+- Set the new origin to your new repository, copy it from the GitHub interface, for example:
```bash
-openssl rand -hex 32
-# Outputs something like: 99d3b1f01aa639e4a76f4fc281fc834747a543720ba4c8a8648ba755aef9be7f
+git remote set-url origin git@github.com:octocat/my-full-stack.git
```
-Copy the contents and use that as password / secret key. And run that again to generate another secure key.
+- Add this repo as another "remote" to allow you to get updates later:
+```bash
+git remote add upstream git@github.com:fastapi/full-stack-fastapi-template.git
+```
-### Input variables
+- Push the code to your new repository:
-The generator (cookiecutter) will ask you for some data, you might want to have at hand before generating the project.
+```bash
+git push -u origin master
+```
-The input variables, with their default values (some auto generated) are:
+### Update From the Original Template
+
+After cloning the repository, and after doing changes, you might want to get the latest changes from this original template.
+
+- Make sure you added the original repository as a remote, you can check it with:
+
+```bash
+git remote -v
+
+origin git@github.com:octocat/my-full-stack.git (fetch)
+origin git@github.com:octocat/my-full-stack.git (push)
+upstream git@github.com:fastapi/full-stack-fastapi-template.git (fetch)
+upstream git@github.com:fastapi/full-stack-fastapi-template.git (push)
+```
+
+- Pull the latest changes without merging:
+
+```bash
+git pull --no-commit upstream master
+```
+
+This will download the latest changes from this template without committing them, that way you can check everything is right before committing.
+
+- If there are conflicts, solve them in your editor.
+
+- Once you are done, commit the changes:
+
+```bash
+git merge --continue
+```
+
+### Configure
+
+You can then update configs in the `.env` files to customize your configurations.
+
+Before deploying it, make sure you change at least the values for:
-* `project_name`: The name of the project
-* `project_slug`: The development friendly name of the project. By default, based on the project name
-* `domain_main`: The domain in where to deploy the project for production (from the branch `production`), used by the load balancer, backend, etc. By default, based on the project slug.
-* `domain_staging`: The domain in where to deploy while staging (before production) (from the branch `master`). By default, based on the main domain.
+- `SECRET_KEY`
+- `FIRST_SUPERUSER_PASSWORD`
+- `POSTGRES_PASSWORD`
+
+You can (and should) pass these as environment variables from secrets.
+
+Read the [deployment.md](./deployment.md) docs for more details.
+
+### Generate Secret Keys
+
+Some environment variables in the `.env` file have a default value of `changethis`.
+
+You have to change them with a secret key, to generate secret keys you can run the following command:
+
+```bash
+python -c "import secrets; print(secrets.token_urlsafe(32))"
+```
+
+Copy the content and use that as password / secret key. And run that again to generate another secure key.
+
+## How To Use It - Alternative With Copier
+
+This repository also supports generating a new project using [Copier](https://copier.readthedocs.io).
+
+It will copy all the files, ask you configuration questions, and update the `.env` files with your answers.
+
+### Install Copier
+
+You can install Copier with:
+
+```bash
+pip install copier
+```
+
+Or better, if you have [`pipx`](https://pipx.pypa.io/), you can run it with:
+
+```bash
+pipx install copier
+```
+
+**Note**: If you have `pipx`, installing copier is optional, you could run it directly.
+
+### Generate a Project With Copier
+
+Decide a name for your new project's directory, you will use it below. For example, `my-awesome-project`.
+
+Go to the directory that will be the parent of your project, and run the command with your project's name:
+
+```bash
+copier copy https://github.com/fastapi/full-stack-fastapi-template my-awesome-project --trust
+```
+
+If you have `pipx` and you didn't install `copier`, you can run it directly:
+
+```bash
+pipx run copier copy https://github.com/fastapi/full-stack-fastapi-template my-awesome-project --trust
+```
+
+**Note** the `--trust` option is necessary to be able to execute a [post-creation script](https://github.com/fastapi/full-stack-fastapi-template/blob/master/.copier/update_dotenv.py) that updates your `.env` files.
+
+### Input Variables
+
+Copier will ask you for some data, you might want to have at hand before generating the project.
+
+But don't worry, you can just update any of that in the `.env` files afterwards.
+
+The input variables, with their default values (some auto generated) are:
-* `docker_swarm_stack_name_main`: The name of the stack while deploying to Docker in Swarm mode for production. By default, based on the domain.
-* `docker_swarm_stack_name_staging`: The name of the stack while deploying to Docker in Swarm mode for staging. By default, based on the domain.
+- `project_name`: (default: `"FastAPI Project"`) The name of the project, shown to API users (in .env).
+- `stack_name`: (default: `"fastapi-project"`) The name of the stack used for Docker Compose labels and project name (no spaces, no periods) (in .env).
+- `secret_key`: (default: `"changethis"`) The secret key for the project, used for security, stored in .env, you can generate one with the method above.
+- `first_superuser`: (default: `"admin@example.com"`) The email of the first superuser (in .env).
+- `first_superuser_password`: (default: `"changethis"`) The password of the first superuser (in .env).
+- `smtp_host`: (default: "") The SMTP server host to send emails, you can set it later in .env.
+- `smtp_user`: (default: "") The SMTP server user to send emails, you can set it later in .env.
+- `smtp_password`: (default: "") The SMTP server password to send emails, you can set it later in .env.
+- `emails_from_email`: (default: `"info@example.com"`) The email account to send emails from, you can set it later in .env.
+- `postgres_password`: (default: `"changethis"`) The password for the PostgreSQL database, stored in .env, you can generate one with the method above.
+- `sentry_dsn`: (default: "") The DSN for Sentry, if you are using it, you can set it later in .env.
-* `secret_key`: Backend server secret key. Use the method above to generate it.
-* `first_superuser`: The first superuser generated, with it you will be able to create more users, etc. By default, based on the domain.
-* `first_superuser_password`: First superuser password. Use the method above to generate it.
-* `backend_cors_origins`: Origins (domains, more or less) that are enabled for CORS (Cross Origin Resource Sharing). This allows a frontend in one domain (e.g. `https://dashboard.example.com`) to communicate with this backend, that could be living in another domain (e.g. `https://api.example.com`). It can also be used to allow your local frontend (with a custom `hosts` domain mapping, as described in the project's `README.md`) that could be living in `http://dev.example.com:8080` to cummunicate with the backend at `https://stag.example.com`. Notice the `http` vs `https` and the `dev.` prefix for local development vs the "staging" `stag.` prefix. By default, it includes origins for production, staging and development, with ports commonly used during local development by several popular frontend frameworks (Vue with `:8080`, React, Angular).
-* `smtp_port`: Port to use to send emails via SMTP. By default `587`.
-* `smtp_host`: Host to use to send emails, it would be given by your email provider, like Mailgun, Sparkpost, etc.
-* `smtp_user`: The user to use in the SMTP connection. The value will be given by your email provider.
-* `smtp_password`: The password to be used in the SMTP connection. The value will be given by the email provider.
-* `smtp_emails_from_email`: The email account to use as the sender in the notification emails, it would be something like `info@your-custom-domain.com`.
-
-* `postgres_password`: Postgres database password. Use the method above to generate it. (You could easily modify it to use MySQL, MariaDB, etc).
-* `pgadmin_default_user`: PGAdmin default user, to log-in to the PGAdmin interface.
-* `pgadmin_default_user_password`: PGAdmin default user password. Generate it with the method above.
-
-* `traefik_constraint_tag`: The tag to be used by the internal Traefik load balancer (for example, to divide requests between backend and frontend) for production. Used to separate this stack from any other stack you might have. This should identify each stack in each environment (production, staging, etc).
-* `traefik_constraint_tag_staging`: The Traefik tag to be used while on staging.
-* `traefik_public_network`: This assumes you have another separate publicly facing Traefik at the server / cluster level. This is the network that main Traefik lives in.
-* `traefik_public_constraint_tag`: The tag that should be used by stack services that should communicate with the public.
+## Backend Development
-* `flower_auth`: Basic HTTP authentication for flower, in the form`user:password`. By default: "`root:changethis`".
+Backend docs: [backend/README.md](./backend/README.md).
-* `sentry_dsn`: Key URL (DSN) of Sentry, for live error reporting. If you are not using it yet, you should, is open source. E.g.: `https://1234abcd:5678ef@sentry.example.com/30`.
+## Frontend Development
-* `docker_image_prefix`: Prefix to use for Docker image names. If you are using GitLab Docker registry it would be based on your code repository. E.g.: `git.example.com/development-team/my-awesome-project/`.
-* `docker_image_backend`: Docker image name for the backend. By default, it will be based on your Docker image prefix, e.g.: `git.example.com/development-team/my-awesome-project/backend`. And depending on your environment, a different tag will be appended ( `prod`, `stag`, `branch` ). So, the final image names used will be like: `git.example.com/development-team/my-awesome-project/backend:prod`.
-* `docker_image_celeryworker`: Docker image for the celery worker. By default, based on your Docker image prefix.
-* `docker_image_frontend`: Docker image for the frontend. By default, based on your Docker image prefix.
+Frontend docs: [frontend/README.md](./frontend/README.md).
-## How to deploy
+## Deployment
-This stack can be adjusted and used with several deployment options that are compatible with Docker Compose, but it is designed to be used in a cluster controlled with pure Docker in Swarm Mode with a Traefik main load balancer proxy handling automatic HTTPS certificates, using the ideas from DockerSwarm.rocks.
+Deployment docs: [deployment.md](./deployment.md).
-Please refer to DockerSwarm.rocks to see how to deploy such a cluster in 20 minutes.
+## Development
-## More details
+General development docs: [development.md](./development.md).
-After using this generator, your new project (the directory created) will contain an extensive `README.md` with instructions for development, deployment, etc. You can pre-read [the project `README.md` template here too](./{{cookiecutter.project_slug}}/README.md).
+This includes using Docker Compose, custom local domains, `.env` configurations, etc.
-## Sibling project generators
+## Release Notes
-* Based on Couchbase: [https://github.com/tiangolo/full-stack-fastapi-couchbase](https://github.com/tiangolo/full-stack-fastapi-couchbase).
+Check the file [release-notes.md](./release-notes.md).
## License
-This project is licensed under the terms of the MIT license.
+The Full Stack FastAPI Template is licensed under the terms of the MIT license.
diff --git a/backend/.dockerignore b/backend/.dockerignore
new file mode 100644
index 0000000000..c0de4abf73
--- /dev/null
+++ b/backend/.dockerignore
@@ -0,0 +1,8 @@
+# Python
+__pycache__
+app.egg-info
+*.pyc
+.mypy_cache
+.coverage
+htmlcov
+.venv
diff --git a/backend/.env.docker b/backend/.env.docker
new file mode 100644
index 0000000000..800a640e3b
--- /dev/null
+++ b/backend/.env.docker
@@ -0,0 +1,9 @@
+DOMAIN=${DOMAIN}
+FRONTEND_HOST=frontend:3000
+ENVIRONMENT=dev
+BACKEND_CORS_ORIGINS=*
+FIRST_SUPERUSER=admin
+POSTGRES_SERVER=db
+POSTGRES_PORT=5432
+POSTGRES_DB=treadeddb
+POSTGRES_USER=postgres
diff --git a/backend/.gitignore b/backend/.gitignore
new file mode 100644
index 0000000000..63f67bcd21
--- /dev/null
+++ b/backend/.gitignore
@@ -0,0 +1,8 @@
+__pycache__
+app.egg-info
+*.pyc
+.mypy_cache
+.coverage
+htmlcov
+.cache
+.venv
diff --git a/backend/Dockerfile b/backend/Dockerfile
new file mode 100644
index 0000000000..14367273b2
--- /dev/null
+++ b/backend/Dockerfile
@@ -0,0 +1,46 @@
+FROM python:3.12-slim
+
+# ensures that Python's output is sent directly to the console or log stream without buffering.
+# This makes logs appear in real-time, which is essential for debugging and monitoring applications
+# running in Docker containers.
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app/
+
+# Install uv
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#installing-uv
+COPY --from=ghcr.io/astral-sh/uv:0.5.11 /uv /uvx /bin/
+
+# Place executables in the environment at the front of the path
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#using-the-environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Compile bytecode
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#compiling-bytecode
+ENV UV_COMPILE_BYTECODE=1
+
+# uv Cache
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#caching
+ENV UV_LINK_MODE=copy
+
+# Install dependencies
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#intermediate-layers
+RUN --mount=type=cache,target=/root/.cache/uv \
+ --mount=type=bind,source=uv.lock,target=uv.lock \
+ --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+ uv sync --frozen --no-install-project
+
+ENV PYTHONPATH=/app
+
+COPY ./scripts /app/scripts
+
+COPY ./pyproject.toml ./uv.lock ./alembic.ini /app/
+
+COPY ./app /app/app
+
+# Sync the project
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#intermediate-layers
+RUN --mount=type=cache,target=/root/.cache/uv \
+ uv sync
+
+ENTRYPOINT scripts/entrypoint.sh
diff --git a/backend/README.md b/backend/README.md
new file mode 100644
index 0000000000..17210a2f2c
--- /dev/null
+++ b/backend/README.md
@@ -0,0 +1,172 @@
+# FastAPI Project - Backend
+
+## Requirements
+
+* [Docker](https://www.docker.com/).
+* [uv](https://docs.astral.sh/uv/) for Python package and environment management.
+
+## Docker Compose
+
+Start the local development environment with Docker Compose following the guide in [../development.md](../development.md).
+
+## General Workflow
+
+By default, the dependencies are managed with [uv](https://docs.astral.sh/uv/), go there and install it.
+
+From `./backend/` you can install all the dependencies with:
+
+```console
+$ uv sync
+```
+
+Then you can activate the virtual environment with:
+
+```console
+$ source .venv/bin/activate
+```
+
+Make sure your editor is using the correct Python virtual environment, with the interpreter at `backend/.venv/bin/python`.
+
+Modify or add SQLModel models for data and SQL tables in `./backend/app/models.py`, API endpoints in `./backend/app/api/`, CRUD (Create, Read, Update, Delete) utils in `./backend/app/crud.py`.
+
+## VS Code
+
+There are already configurations in place to run the backend through the VS Code debugger, so that you can use breakpoints, pause and explore variables, etc.
+
+The setup is also already configured so you can run the tests through the VS Code Python tests tab.
+
+## Docker Compose Override
+
+During development, you can change Docker Compose settings that will only affect the local development environment in the file `docker-compose.override.yml`.
+
+The changes to that file only affect the local development environment, not the production environment. So, you can add "temporary" changes that help the development workflow.
+
+For example, the directory with the backend code is synchronized in the Docker container, copying the code you change live to the directory inside the container. That allows you to test your changes right away, without having to build the Docker image again. It should only be done during development, for production, you should build the Docker image with a recent version of the backend code. But during development, it allows you to iterate very fast.
+
+There is also a command override that runs `fastapi run --reload` instead of the default `fastapi run`. It starts a single server process (instead of multiple, as would be for production) and reloads the process whenever the code changes. Have in mind that if you have a syntax error and save the Python file, it will break and exit, and the container will stop. After that, you can restart the container by fixing the error and running again:
+
+```console
+$ docker compose watch
+```
+
+There is also a commented out `command` override, you can uncomment it and comment the default one. It makes the backend container run a process that does "nothing", but keeps the container alive. That allows you to get inside your running container and execute commands inside, for example a Python interpreter to test installed dependencies, or start the development server that reloads when it detects changes.
+
+To get inside the container with a `bash` session you can start the stack with:
+
+```console
+$ docker compose watch
+```
+
+and then in another terminal, `exec` inside the running container:
+
+```console
+$ docker compose exec backend bash
+```
+
+You should see an output like:
+
+```console
+root@7f2607af31c3:/app#
+```
+
+that means that you are in a `bash` session inside your container, as a `root` user, under the `/app` directory, this directory has another directory called "app" inside, that's where your code lives inside the container: `/app/app`.
+
+There you can use the `fastapi run --reload` command to run the debug live reloading server.
+
+```console
+$ fastapi run --reload app/main.py
+```
+
+...it will look like:
+
+```console
+root@7f2607af31c3:/app# fastapi run --reload app/main.py
+```
+
+and then hit enter. That runs the live reloading server that auto reloads when it detects code changes.
+
+Nevertheless, if it doesn't detect a change but a syntax error, it will just stop with an error. But as the container is still alive and you are in a Bash session, you can quickly restart it after fixing the error, running the same command ("up arrow" and "Enter").
+
+...this previous detail is what makes it useful to have the container alive doing nothing and then, in a Bash session, make it run the live reload server.
+
+## Backend tests
+
+To test the backend run:
+
+```console
+$ bash ./scripts/test.sh
+```
+
+The tests run with Pytest, modify and add tests to `./backend/app/tests/`.
+
+If you use GitHub Actions the tests will run automatically.
+
+### Test running stack
+
+If your stack is already up and you just want to run the tests, you can use:
+
+```bash
+docker compose exec backend bash scripts/tests-start.sh
+```
+
+That `/app/scripts/tests-start.sh` script just calls `pytest` after making sure that the rest of the stack is running. If you need to pass extra arguments to `pytest`, you can pass them to that command and they will be forwarded.
+
+For example, to stop on first error:
+
+```bash
+docker compose exec backend bash scripts/tests-start.sh -x
+```
+
+### Test Coverage
+
+When the tests are run, a file `htmlcov/index.html` is generated, you can open it in your browser to see the coverage of the tests.
+
+## Migrations
+
+As during local development your app directory is mounted as a volume inside the container, you can also run the migrations with `alembic` commands inside the container and the migration code will be in your app directory (instead of being only inside the container). So you can add it to your git repository.
+
+Make sure you create a "revision" of your models and that you "upgrade" your database with that revision every time you change them. As this is what will update the tables in your database. Otherwise, your application will have errors.
+
+* Start an interactive session in the backend container:
+
+```console
+$ docker compose exec backend bash
+```
+
+* Alembic is already configured to import your SQLModel models from `./backend/app/models.py`.
+
+* After changing a model (for example, adding a column), inside the container, create a revision, e.g.:
+
+```console
+$ alembic revision --autogenerate -m "Add column last_name to User model"
+```
+
+* Commit to the git repository the files generated in the alembic directory.
+
+* After creating the revision, run the migration in the database (this is what will actually change the database):
+
+```console
+$ alembic upgrade head
+```
+
+If you don't want to use migrations at all, uncomment the lines in the file at `./backend/app/core/db.py` that end in:
+
+```python
+SQLModel.metadata.create_all(engine)
+```
+
+and comment the line in the file `scripts/prestart.sh` that contains:
+
+```console
+$ alembic upgrade head
+```
+
+If you don't want to start with the default models and want to remove them / modify them, from the beginning, without having any previous revision, you can remove the revision files (`.py` Python files) under `./backend/app/alembic/versions/`. And then create a first migration as described above.
+
+## Email Templates
+
+The email templates are in `./backend/app/email-templates/`. Here, there are two directories: `build` and `src`. The `src` directory contains the source files that are used to build the final email templates. The `build` directory contains the final email templates that are used by the application.
+
+Before continuing, ensure you have the [MJML extension](https://marketplace.visualstudio.com/items?itemName=attilabuti.vscode-mjml) installed in your VS Code.
+
+Once you have the MJML extension installed, you can create a new email template in the `src` directory. After creating the new email template and with the `.mjml` file open in your editor, open the command palette with `Ctrl+Shift+P` and search for `MJML: Export to HTML`. This will convert the `.mjml` file to a `.html` file and now you can save it in the build directory.
diff --git a/{{cookiecutter.project_slug}}/backend/app/alembic.ini b/backend/alembic.ini
similarity index 93%
rename from {{cookiecutter.project_slug}}/backend/app/alembic.ini
rename to backend/alembic.ini
index 61bc2fdcbf..24841c2bfb 100755
--- a/{{cookiecutter.project_slug}}/backend/app/alembic.ini
+++ b/backend/alembic.ini
@@ -2,7 +2,7 @@
[alembic]
# path to migration scripts
-script_location = alembic
+script_location = app/alembic
# template used to generate migration files
# file_template = %%(rev)s_%%(slug)s
@@ -35,9 +35,6 @@ script_location = alembic
# are written from script.py.mako
# output_encoding = utf-8
-sqlalchemy.url = postgresql://postgres:{{cookiecutter.postgres_password}}@db/app
-
-
# Logging configuration
[loggers]
keys = root,sqlalchemy,alembic
diff --git a/{{cookiecutter.project_slug}}/backend/app/app/__init__.py b/backend/app/__init__.py
similarity index 100%
rename from {{cookiecutter.project_slug}}/backend/app/app/__init__.py
rename to backend/app/__init__.py
diff --git a/backend/app/alembic/README b/backend/app/alembic/README
new file mode 100755
index 0000000000..2500aa1bcf
--- /dev/null
+++ b/backend/app/alembic/README
@@ -0,0 +1 @@
+Generic single-database configuration.
diff --git a/{{cookiecutter.project_slug}}/backend/app/alembic/env.py b/backend/app/alembic/env.py
similarity index 84%
rename from {{cookiecutter.project_slug}}/backend/app/alembic/env.py
rename to backend/app/alembic/env.py
index ae47ee586c..7f29c04680 100755
--- a/{{cookiecutter.project_slug}}/backend/app/alembic/env.py
+++ b/backend/app/alembic/env.py
@@ -1,7 +1,8 @@
-from __future__ import with_statement
+import os
+from logging.config import fileConfig
+
from alembic import context
from sqlalchemy import engine_from_config, pool
-from logging.config import fileConfig
# this is the Alembic Config object, which provides
# access to the values within the .ini file in use.
@@ -17,9 +18,10 @@
# target_metadata = mymodel.Base.metadata
# target_metadata = None
-from app.db.base import Base # noqa
+from app.models import SQLModel # noqa
+from app.core.config import settings # noqa
-target_metadata = Base.metadata
+target_metadata = SQLModel.metadata
# other values from the config, defined by the needs of env.py,
# can be acquired:
@@ -27,6 +29,10 @@
# ... etc.
+def get_url():
+ return str(settings.SQLALCHEMY_DATABASE_URI)
+
+
def run_migrations_offline():
"""Run migrations in 'offline' mode.
@@ -39,7 +45,7 @@ def run_migrations_offline():
script output.
"""
- url = config.get_main_option("sqlalchemy.url")
+ url = get_url()
context.configure(
url=url, target_metadata=target_metadata, literal_binds=True, compare_type=True
)
@@ -55,8 +61,10 @@ def run_migrations_online():
and associate a connection with the context.
"""
+ configuration = config.get_section(config.config_ini_section)
+ configuration["sqlalchemy.url"] = get_url()
connectable = engine_from_config(
- config.get_section(config.config_ini_section),
+ configuration,
prefix="sqlalchemy.",
poolclass=pool.NullPool,
)
diff --git a/{{cookiecutter.project_slug}}/backend/app/alembic/script.py.mako b/backend/app/alembic/script.py.mako
similarity index 94%
rename from {{cookiecutter.project_slug}}/backend/app/alembic/script.py.mako
rename to backend/app/alembic/script.py.mako
index 2c0156303a..217a9a8b7b 100755
--- a/{{cookiecutter.project_slug}}/backend/app/alembic/script.py.mako
+++ b/backend/app/alembic/script.py.mako
@@ -7,6 +7,7 @@ Create Date: ${create_date}
"""
from alembic import op
import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
${imports if imports else ""}
# revision identifiers, used by Alembic.
diff --git a/{{cookiecutter.project_slug}}/backend/app/alembic/versions/.keep b/backend/app/alembic/versions/.keep
similarity index 100%
rename from {{cookiecutter.project_slug}}/backend/app/alembic/versions/.keep
rename to backend/app/alembic/versions/.keep
diff --git a/backend/app/alembic/versions/1a31ce608336_add_cascade_delete_relationships.py b/backend/app/alembic/versions/1a31ce608336_add_cascade_delete_relationships.py
new file mode 100644
index 0000000000..10e47a1456
--- /dev/null
+++ b/backend/app/alembic/versions/1a31ce608336_add_cascade_delete_relationships.py
@@ -0,0 +1,37 @@
+"""Add cascade delete relationships
+
+Revision ID: 1a31ce608336
+Revises: d98dd8ec85a3
+Create Date: 2024-07-31 22:24:34.447891
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision = '1a31ce608336'
+down_revision = 'd98dd8ec85a3'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.alter_column('item', 'owner_id',
+ existing_type=sa.UUID(),
+ nullable=False)
+ op.drop_constraint('item_owner_id_fkey', 'item', type_='foreignkey')
+ op.create_foreign_key(None, 'item', 'user', ['owner_id'], ['id'], ondelete='CASCADE')
+ # ### end Alembic commands ###
+
+
+def downgrade():
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.drop_constraint(None, 'item', type_='foreignkey')
+ op.create_foreign_key('item_owner_id_fkey', 'item', 'user', ['owner_id'], ['id'])
+ op.alter_column('item', 'owner_id',
+ existing_type=sa.UUID(),
+ nullable=True)
+ # ### end Alembic commands ###
diff --git a/backend/app/alembic/versions/9c0a54914c78_add_max_length_for_string_varchar_.py b/backend/app/alembic/versions/9c0a54914c78_add_max_length_for_string_varchar_.py
new file mode 100755
index 0000000000..78a41773b9
--- /dev/null
+++ b/backend/app/alembic/versions/9c0a54914c78_add_max_length_for_string_varchar_.py
@@ -0,0 +1,69 @@
+"""Add max length for string(varchar) fields in User and Items models
+
+Revision ID: 9c0a54914c78
+Revises: e2412789c190
+Create Date: 2024-06-17 14:42:44.639457
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+
+
+# revision identifiers, used by Alembic.
+revision = '9c0a54914c78'
+down_revision = 'e2412789c190'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ # Adjust the length of the email field in the User table
+ op.alter_column('user', 'email',
+ existing_type=sa.String(),
+ type_=sa.String(length=255),
+ existing_nullable=False)
+
+ # Adjust the length of the full_name field in the User table
+ op.alter_column('user', 'full_name',
+ existing_type=sa.String(),
+ type_=sa.String(length=255),
+ existing_nullable=True)
+
+ # Adjust the length of the title field in the Item table
+ op.alter_column('item', 'title',
+ existing_type=sa.String(),
+ type_=sa.String(length=255),
+ existing_nullable=False)
+
+ # Adjust the length of the description field in the Item table
+ op.alter_column('item', 'description',
+ existing_type=sa.String(),
+ type_=sa.String(length=255),
+ existing_nullable=True)
+
+
+def downgrade():
+ # Revert the length of the email field in the User table
+ op.alter_column('user', 'email',
+ existing_type=sa.String(length=255),
+ type_=sa.String(),
+ existing_nullable=False)
+
+ # Revert the length of the full_name field in the User table
+ op.alter_column('user', 'full_name',
+ existing_type=sa.String(length=255),
+ type_=sa.String(),
+ existing_nullable=True)
+
+ # Revert the length of the title field in the Item table
+ op.alter_column('item', 'title',
+ existing_type=sa.String(length=255),
+ type_=sa.String(),
+ existing_nullable=False)
+
+ # Revert the length of the description field in the Item table
+ op.alter_column('item', 'description',
+ existing_type=sa.String(length=255),
+ type_=sa.String(),
+ existing_nullable=True)
diff --git a/backend/app/alembic/versions/d98dd8ec85a3_edit_replace_id_integers_in_all_models_.py b/backend/app/alembic/versions/d98dd8ec85a3_edit_replace_id_integers_in_all_models_.py
new file mode 100755
index 0000000000..37af1fa215
--- /dev/null
+++ b/backend/app/alembic/versions/d98dd8ec85a3_edit_replace_id_integers_in_all_models_.py
@@ -0,0 +1,90 @@
+"""Edit replace id integers in all models to use UUID instead
+
+Revision ID: d98dd8ec85a3
+Revises: 9c0a54914c78
+Create Date: 2024-07-19 04:08:04.000976
+
+"""
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision = 'd98dd8ec85a3'
+down_revision = '9c0a54914c78'
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ # Ensure uuid-ossp extension is available
+ op.execute('CREATE EXTENSION IF NOT EXISTS "uuid-ossp"')
+
+ # Create a new UUID column with a default UUID value
+ op.add_column('user', sa.Column('new_id', postgresql.UUID(as_uuid=True), default=sa.text('uuid_generate_v4()')))
+ op.add_column('item', sa.Column('new_id', postgresql.UUID(as_uuid=True), default=sa.text('uuid_generate_v4()')))
+ op.add_column('item', sa.Column('new_owner_id', postgresql.UUID(as_uuid=True), nullable=True))
+
+ # Populate the new columns with UUIDs
+ op.execute('UPDATE "user" SET new_id = uuid_generate_v4()')
+ op.execute('UPDATE item SET new_id = uuid_generate_v4()')
+ op.execute('UPDATE item SET new_owner_id = (SELECT new_id FROM "user" WHERE "user".id = item.owner_id)')
+
+ # Set the new_id as not nullable
+ op.alter_column('user', 'new_id', nullable=False)
+ op.alter_column('item', 'new_id', nullable=False)
+
+ # Drop old columns and rename new columns
+ op.drop_constraint('item_owner_id_fkey', 'item', type_='foreignkey')
+ op.drop_column('item', 'owner_id')
+ op.alter_column('item', 'new_owner_id', new_column_name='owner_id')
+
+ op.drop_column('user', 'id')
+ op.alter_column('user', 'new_id', new_column_name='id')
+
+ op.drop_column('item', 'id')
+ op.alter_column('item', 'new_id', new_column_name='id')
+
+ # Create primary key constraint
+ op.create_primary_key('user_pkey', 'user', ['id'])
+ op.create_primary_key('item_pkey', 'item', ['id'])
+
+ # Recreate foreign key constraint
+ op.create_foreign_key('item_owner_id_fkey', 'item', 'user', ['owner_id'], ['id'])
+
+def downgrade():
+ # Reverse the upgrade process
+ op.add_column('user', sa.Column('old_id', sa.Integer, autoincrement=True))
+ op.add_column('item', sa.Column('old_id', sa.Integer, autoincrement=True))
+ op.add_column('item', sa.Column('old_owner_id', sa.Integer, nullable=True))
+
+ # Populate the old columns with default values
+ # Generate sequences for the integer IDs if not exist
+ op.execute('CREATE SEQUENCE IF NOT EXISTS user_id_seq AS INTEGER OWNED BY "user".old_id')
+ op.execute('CREATE SEQUENCE IF NOT EXISTS item_id_seq AS INTEGER OWNED BY item.old_id')
+
+ op.execute('SELECT setval(\'user_id_seq\', COALESCE((SELECT MAX(old_id) + 1 FROM "user"), 1), false)')
+ op.execute('SELECT setval(\'item_id_seq\', COALESCE((SELECT MAX(old_id) + 1 FROM item), 1), false)')
+
+ op.execute('UPDATE "user" SET old_id = nextval(\'user_id_seq\')')
+ op.execute('UPDATE item SET old_id = nextval(\'item_id_seq\'), old_owner_id = (SELECT old_id FROM "user" WHERE "user".id = item.owner_id)')
+
+ # Drop new columns and rename old columns back
+ op.drop_constraint('item_owner_id_fkey', 'item', type_='foreignkey')
+ op.drop_column('item', 'owner_id')
+ op.alter_column('item', 'old_owner_id', new_column_name='owner_id')
+
+ op.drop_column('user', 'id')
+ op.alter_column('user', 'old_id', new_column_name='id')
+
+ op.drop_column('item', 'id')
+ op.alter_column('item', 'old_id', new_column_name='id')
+
+ # Create primary key constraint
+ op.create_primary_key('user_pkey', 'user', ['id'])
+ op.create_primary_key('item_pkey', 'item', ['id'])
+
+ # Recreate foreign key constraint
+ op.create_foreign_key('item_owner_id_fkey', 'item', 'user', ['owner_id'], ['id'])
diff --git a/backend/app/alembic/versions/e2412789c190_initialize_models.py b/backend/app/alembic/versions/e2412789c190_initialize_models.py
new file mode 100644
index 0000000000..7529ea91fa
--- /dev/null
+++ b/backend/app/alembic/versions/e2412789c190_initialize_models.py
@@ -0,0 +1,54 @@
+"""Initialize models
+
+Revision ID: e2412789c190
+Revises:
+Create Date: 2023-11-24 22:55:43.195942
+
+"""
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "e2412789c190"
+down_revision = None
+branch_labels = None
+depends_on = None
+
+
+def upgrade():
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.create_table(
+ "user",
+ sa.Column("email", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+ sa.Column("is_active", sa.Boolean(), nullable=False),
+ sa.Column("is_superuser", sa.Boolean(), nullable=False),
+ sa.Column("full_name", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+ sa.Column("id", sa.Integer(), nullable=False),
+ sa.Column(
+ "hashed_password", sqlmodel.sql.sqltypes.AutoString(), nullable=False
+ ),
+ sa.PrimaryKeyConstraint("id"),
+ )
+ op.create_index(op.f("ix_user_email"), "user", ["email"], unique=True)
+ op.create_table(
+ "item",
+ sa.Column("description", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+ sa.Column("id", sa.Integer(), nullable=False),
+ sa.Column("title", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+ sa.Column("owner_id", sa.Integer(), nullable=False),
+ sa.ForeignKeyConstraint(
+ ["owner_id"],
+ ["user.id"],
+ ),
+ sa.PrimaryKeyConstraint("id"),
+ )
+ # ### end Alembic commands ###
+
+
+def downgrade():
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.drop_table("item")
+ op.drop_index(op.f("ix_user_email"), table_name="user")
+ op.drop_table("user")
+ # ### end Alembic commands ###
diff --git a/backend/app/alembic/versions/ea8d60701d49_add_path_and_step_models.py b/backend/app/alembic/versions/ea8d60701d49_add_path_and_step_models.py
new file mode 100644
index 0000000000..9ed3b08944
--- /dev/null
+++ b/backend/app/alembic/versions/ea8d60701d49_add_path_and_step_models.py
@@ -0,0 +1,76 @@
+"""add path and step models
+
+Revision ID: ea8d60701d49
+Revises: 1a31ce608336
+Create Date: 2025-01-31 17:39:00.000000
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel.sql.sqltypes
+from sqlalchemy.dialects import postgresql
+
+
+# revision identifiers, used by Alembic.
+revision: str = 'ea8d60701d49'
+down_revision: Union[str, None] = '1a31ce608336'
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ # ### commands auto generated by Alembic - please adjust! ###
+
+ # Modify the user table to set default values
+ op.alter_column('user', 'is_active',
+ existing_type=sa.BOOLEAN(),
+ server_default=sa.true(),
+ existing_nullable=False)
+ op.alter_column('user', 'is_superuser',
+ existing_type=sa.BOOLEAN(),
+ server_default=sa.false(),
+ existing_nullable=False)
+
+ # Create path table with correct columns
+ op.create_table('path',
+ sa.Column('id', postgresql.UUID(as_uuid=True), nullable=False),
+ sa.Column('creator_id', postgresql.UUID(as_uuid=True), nullable=False),
+ sa.Column('title', sqlmodel.sql.sqltypes.AutoString(length=255), nullable=False),
+ sa.Column('path_summary', sqlmodel.sql.sqltypes.AutoString(length=255), nullable=True),
+ sa.Column('created_at', sa.DateTime(), nullable=False),
+ sa.Column('updated_at', sa.DateTime(), nullable=False),
+ sa.ForeignKeyConstraint(['creator_id'], ['user.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('id')
+ )
+
+ # Create step table
+ op.create_table('step',
+ sa.Column('id', sa.Integer(), nullable=False),
+ sa.Column('path_id', postgresql.UUID(as_uuid=True), nullable=False),
+ sa.Column('number', sa.Integer(), nullable=False),
+ sa.Column('role_prompt', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+ sa.Column('validation_prompt', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+ sa.Column('exposition_json', sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+ sa.ForeignKeyConstraint(['path_id'], ['path.id'], ondelete='CASCADE'),
+ sa.PrimaryKeyConstraint('id')
+ )
+ # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+ # ### commands auto generated by Alembic - please adjust! ###
+ op.drop_table('step')
+ op.drop_table('path')
+
+ # Remove default values from user table
+ op.alter_column('user', 'is_active',
+ existing_type=sa.BOOLEAN(),
+ server_default=None,
+ existing_nullable=False)
+ op.alter_column('user', 'is_superuser',
+ existing_type=sa.BOOLEAN(),
+ server_default=None,
+ existing_nullable=False)
+ # ### end Alembic commands ###
diff --git a/{{cookiecutter.project_slug}}/backend/app/app/api/__init__.py b/backend/app/api/__init__.py
similarity index 100%
rename from {{cookiecutter.project_slug}}/backend/app/app/api/__init__.py
rename to backend/app/api/__init__.py
diff --git a/backend/app/api/deps.py b/backend/app/api/deps.py
new file mode 100644
index 0000000000..c2b83c841d
--- /dev/null
+++ b/backend/app/api/deps.py
@@ -0,0 +1,57 @@
+from collections.abc import Generator
+from typing import Annotated
+
+import jwt
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jwt.exceptions import InvalidTokenError
+from pydantic import ValidationError
+from sqlmodel import Session
+
+from app.core import security
+from app.core.config import settings
+from app.core.db import engine
+from app.models import TokenPayload, User
+
+reusable_oauth2 = OAuth2PasswordBearer(
+ tokenUrl=f"{settings.API_V1_STR}/login/access-token"
+)
+
+
+def get_db() -> Generator[Session, None, None]:
+ with Session(engine) as session:
+ yield session
+
+
+SessionDep = Annotated[Session, Depends(get_db)]
+TokenDep = Annotated[str, Depends(reusable_oauth2)]
+
+
+def get_current_user(session: SessionDep, token: TokenDep) -> User:
+ try:
+ payload = jwt.decode(
+ token, settings.SECRET_KEY, algorithms=[security.ALGORITHM]
+ )
+ token_data = TokenPayload(**payload)
+ except (InvalidTokenError, ValidationError):
+ raise HTTPException(
+ status_code=status.HTTP_403_FORBIDDEN,
+ detail="Could not validate credentials",
+ )
+ user = session.get(User, token_data.sub)
+ if not user:
+ raise HTTPException(status_code=404, detail="User not found")
+ if not user.is_active:
+ raise HTTPException(status_code=400, detail="Inactive user")
+ return user
+
+
+CurrentUser = Annotated[User, Depends(get_current_user)]
+
+
+def get_current_active_superuser(current_user: CurrentUser) -> User:
+ if not current_user.is_superuser:
+ raise HTTPException(
+ status_code=403, detail="The user doesn't have enough privileges"
+ )
+ return current_user
diff --git a/backend/app/api/main.py b/backend/app/api/main.py
new file mode 100644
index 0000000000..14eaca2483
--- /dev/null
+++ b/backend/app/api/main.py
@@ -0,0 +1,15 @@
+from fastapi import APIRouter
+
+from app.api.routes import items, login, private, users, utils, paths, learn
+from app.core.config import settings
+
+api_router = APIRouter()
+api_router.include_router(login.router)
+api_router.include_router(users.router)
+api_router.include_router(utils.router)
+api_router.include_router(items.router)
+api_router.include_router(paths.router)
+api_router.include_router(learn.router)
+
+if settings.ENVIRONMENT == "local":
+ api_router.include_router(private.router)
diff --git a/{{cookiecutter.project_slug}}/backend/app/app/api/api_v1/__init__.py b/backend/app/api/routes/__init__.py
similarity index 100%
rename from {{cookiecutter.project_slug}}/backend/app/app/api/api_v1/__init__.py
rename to backend/app/api/routes/__init__.py
diff --git a/backend/app/api/routes/items.py b/backend/app/api/routes/items.py
new file mode 100644
index 0000000000..177dc1e476
--- /dev/null
+++ b/backend/app/api/routes/items.py
@@ -0,0 +1,109 @@
+import uuid
+from typing import Any
+
+from fastapi import APIRouter, HTTPException
+from sqlmodel import func, select
+
+from app.api.deps import CurrentUser, SessionDep
+from app.models import Item, ItemCreate, ItemPublic, ItemsPublic, ItemUpdate, Message
+
+router = APIRouter(prefix="/items", tags=["items"])
+
+
+@router.get("/", response_model=ItemsPublic)
+def read_items(
+ session: SessionDep, current_user: CurrentUser, skip: int = 0, limit: int = 100
+) -> Any:
+ """
+ Retrieve items.
+ """
+
+ if current_user.is_superuser:
+ count_statement = select(func.count()).select_from(Item)
+ count = session.exec(count_statement).one()
+ statement = select(Item).offset(skip).limit(limit)
+ items = session.exec(statement).all()
+ else:
+ count_statement = (
+ select(func.count())
+ .select_from(Item)
+ .where(Item.owner_id == current_user.id)
+ )
+ count = session.exec(count_statement).one()
+ statement = (
+ select(Item)
+ .where(Item.owner_id == current_user.id)
+ .offset(skip)
+ .limit(limit)
+ )
+ items = session.exec(statement).all()
+
+ return ItemsPublic(data=items, count=count)
+
+
+@router.get("/{id}", response_model=ItemPublic)
+def read_item(session: SessionDep, current_user: CurrentUser, id: uuid.UUID) -> Any:
+ """
+ Get item by ID.
+ """
+ item = session.get(Item, id)
+ if not item:
+ raise HTTPException(status_code=404, detail="Item not found")
+ if not current_user.is_superuser and (item.owner_id != current_user.id):
+ raise HTTPException(status_code=400, detail="Not enough permissions")
+ return item
+
+
+@router.post("/", response_model=ItemPublic)
+def create_item(
+ *, session: SessionDep, current_user: CurrentUser, item_in: ItemCreate
+) -> Any:
+ """
+ Create new item.
+ """
+ item = Item.model_validate(item_in, update={"owner_id": current_user.id})
+ session.add(item)
+ session.commit()
+ session.refresh(item)
+ return item
+
+
+@router.put("/{id}", response_model=ItemPublic)
+def update_item(
+ *,
+ session: SessionDep,
+ current_user: CurrentUser,
+ id: uuid.UUID,
+ item_in: ItemUpdate,
+) -> Any:
+ """
+ Update an item.
+ """
+ item = session.get(Item, id)
+ if not item:
+ raise HTTPException(status_code=404, detail="Item not found")
+ if not current_user.is_superuser and (item.owner_id != current_user.id):
+ raise HTTPException(status_code=400, detail="Not enough permissions")
+ update_dict = item_in.model_dump(exclude_unset=True)
+ item.sqlmodel_update(update_dict)
+ session.add(item)
+ session.commit()
+ session.refresh(item)
+ return item
+
+
+@router.delete("/{id}")
+def delete_item(
+ session: SessionDep, current_user: CurrentUser, id: uuid.UUID
+) -> Message:
+ """
+ Delete an item.
+ """
+ item = session.get(Item, id)
+ if not item:
+ raise HTTPException(status_code=404, detail="Item not found")
+ if not current_user.is_superuser and (item.owner_id != current_user.id):
+ raise HTTPException(status_code=400, detail="Not enough permissions")
+ session.delete(item)
+ session.commit()
+ return Message(message="Item deleted successfully")
diff --git a/backend/app/api/routes/learn.py b/backend/app/api/routes/learn.py
new file mode 100644
index 0000000000..fa73498e09
--- /dev/null
+++ b/backend/app/api/routes/learn.py
@@ -0,0 +1,211 @@
+from typing import Literal
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from app.api import deps
+from app.core.ai_client import ChatManager, AnthropicClient, OpenAIClient
+from app.core.config import settings
+import json
+
+router = APIRouter(prefix="/learn", tags=["learn"])
+
+# Store chat managers in memory for now
+active_chats: dict[str, ChatManager] = {}
+
+class ChatRequest(BaseModel):
+ """Request model for chat streaming endpoint."""
+ message: str
+ system_prompt: str | None = None
+ model: Literal["anthropic", "openai"] = "anthropic"
+
+class ChatResponse(BaseModel):
+ message: str
+
+class TestResponse(BaseModel):
+ anthropic_key_set: bool
+ openai_key_set: bool
+ anthropic_model: str
+ openai_model: str
+ test_message: str | None = None
+
+class ChatStreamResponse(BaseModel):
+ """Response model for individual stream messages."""
+ type: Literal["content"]
+ content: str
+
+class ChatMessageResponse(BaseModel):
+ """Response model for non-streaming chat messages."""
+ message: str
+
+class ChatStreamRequest(BaseModel):
+ """Request model for chat streaming endpoint."""
+ message: str
+ system_prompt: str | None = None
+ model: Literal["anthropic", "openai"] = "anthropic"
+
+ class Config:
+ schema_extra = {
+ 'example': {
+ 'message': 'Write a haiku about coding',
+ 'model': 'anthropic'
+ }
+ }
+
+@router.get("/test", response_model=TestResponse)
+async def test_configuration():
+ """Test the LLM configuration and basic functionality."""
+ response = TestResponse(
+ anthropic_key_set=bool(settings.ANTHROPIC_API_KEY),
+ openai_key_set=bool(settings.OPENAI_API_KEY),
+ anthropic_model=settings.ANTHROPIC_MODEL,
+ openai_model=settings.OPENAI_MODEL
+ )
+
+ # Test a simple message if keys are configured
+ if response.anthropic_key_set:
+ try:
+ client = AnthropicClient()
+ test_msg = await client.chat(
+ messages=[{"role": "user", "content": "Say 'API test successful' in exactly those words"}],
+ system="You must respond exactly as instructed"
+ )
+ response.test_message = test_msg
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Anthropic API test failed: {str(e)}")
+
+ return response
+
+@router.post("/chat", response_model=ChatMessageResponse)
+async def chat_general(
+ request: ChatRequest,
+ current_user = Depends(deps.get_current_user),
+):
+ """
+ Send a message to the AI and get a response.
+ """
+ chat_key = f"{current_user.id}_general"
+ if chat_key not in active_chats:
+ active_chats[chat_key] = ChatManager(client=request.model)
+
+ response = await active_chats[chat_key].send_message(
+ request.message,
+ system=request.system_prompt
+ )
+
+ return ChatMessageResponse(message=response)
+
+@router.post("/chat/stream",
+ response_class=StreamingResponse,
+ openapi_extra={
+ 'responses': {
+ '200': {
+ 'description': 'Streaming response',
+ 'headers': {
+ 'Transfer-Encoding': {
+ 'schema': {
+ 'type': 'string',
+ 'enum': ['chunked']
+ }
+ }
+ },
+ 'content': {
+ 'text/event-stream': {
+ 'schema': {
+ 'type': 'object',
+ 'properties': {
+ 'type': {'type': 'string', 'enum': ['content']},
+ 'content': {'type': 'string'}
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+)
+async def chat_stream(
+ request: ChatStreamRequest,
+ current_user = Depends(deps.get_current_user),
+) -> StreamingResponse:
+ """
+ Send a message to the AI and get a streaming response.
+ Returns a StreamingResponse with Server-Sent Events containing partial messages.
+
+ The stream will emit events in the format:
+ data: {"type": "content", "content": "partial message..."}
+ """
+ async def generate():
+ try:
+ chat_key = f"{current_user.id}_general"
+ if chat_key not in active_chats:
+ active_chats[chat_key] = ChatManager(client=request.model)
+
+ print("Starting stream generation...")
+ async for chunk in active_chats[chat_key].stream_message(
+ request.message,
+ system=request.system_prompt
+ ):
+ print(f"Yielding chunk: {chunk}")
+ yield f"data: {json.dumps({'type': 'content', 'content': chunk})}\n\n"
+
+ # Add explicit done event
+ print("Stream complete, sending done event")
+ yield f"data: {json.dumps({'type': 'done'})}\n\n"
+
+ except Exception as e:
+ print(f"Error in stream: {str(e)}")
+ yield f"data: {json.dumps({'type': 'error', 'content': str(e)})}\n\n"
+ yield f"data: {json.dumps({'type': 'done'})}\n\n"
+ finally:
+ # Ensure proper cleanup
+ print("Cleaning up stream connection")
+
+ return StreamingResponse(
+ generate(),
+ media_type='text/event-stream',
+ headers={
+ 'Cache-Control': 'no-cache',
+ 'Connection': 'keep-alive',
+ }
+ )
+
+@router.post("/{path_id}/chat/stream",
+ openapi_extra={
+ 'responses': {
+ '200': {
+ 'description': 'Streaming response',
+ 'content': {
+ 'text/event-stream': {
+ 'schema': {
+ 'type': 'object',
+ 'properties': {
+ 'type': {'type': 'string', 'enum': ['content']},
+ 'content': {'type': 'string'}
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+)
+async def path_chat_stream(
+ path_id: str,
+ request: ChatRequest,
+ current_user = Depends(deps.get_current_user),
+) -> StreamingResponse:
+ """
+ Path-specific chat endpoint that maintains conversation context for each path.
+ Returns a StreamingResponse with Server-Sent Events containing partial messages.
+ """
+ chat_key = f"{current_user.id}_{path_id}"
+ if chat_key not in active_chats:
+ active_chats[chat_key] = ChatManager(client=request.model)
+
+ return StreamingResponse(
+ active_chats[chat_key].stream_message(
+ request.message,
+ system=request.system_prompt
+ ),
+ media_type='text/event-stream'
+ )
diff --git a/backend/app/api/routes/login.py b/backend/app/api/routes/login.py
new file mode 100644
index 0000000000..980c66f86f
--- /dev/null
+++ b/backend/app/api/routes/login.py
@@ -0,0 +1,124 @@
+from datetime import timedelta
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import HTMLResponse
+from fastapi.security import OAuth2PasswordRequestForm
+
+from app import crud
+from app.api.deps import CurrentUser, SessionDep, get_current_active_superuser
+from app.core import security
+from app.core.config import settings
+from app.core.security import get_password_hash
+from app.models import Message, NewPassword, Token, UserPublic
+from app.utils import (
+ generate_password_reset_token,
+ generate_reset_password_email,
+ send_email,
+ verify_password_reset_token,
+)
+
+router = APIRouter(tags=["login"])
+
+
+@router.post("/login/access-token")
+def login_access_token(
+ session: SessionDep, form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
+) -> Token:
+ """
+ OAuth2 compatible token login, get an access token for future requests
+ """
+ user = crud.authenticate(
+ session=session, email=form_data.username, password=form_data.password
+ )
+ if not user:
+ raise HTTPException(status_code=400, detail="Incorrect email or password")
+ elif not user.is_active:
+ raise HTTPException(status_code=400, detail="Inactive user")
+ access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+ return Token(
+ access_token=security.create_access_token(
+ user.id, expires_delta=access_token_expires
+ )
+ )
+
+
+@router.post("/login/test-token", response_model=UserPublic)
+def test_token(current_user: CurrentUser) -> Any:
+ """
+ Test access token
+ """
+ return current_user
+
+
+@router.post("/password-recovery/{email}")
+def recover_password(email: str, session: SessionDep) -> Message:
+ """
+ Password Recovery
+ """
+ user = crud.get_user_by_email(session=session, email=email)
+
+ if not user:
+ raise HTTPException(
+ status_code=404,
+ detail="The user with this email does not exist in the system.",
+ )
+ password_reset_token = generate_password_reset_token(email=email)
+ email_data = generate_reset_password_email(
+ email_to=user.email, email=email, token=password_reset_token
+ )
+ send_email(
+ email_to=user.email,
+ subject=email_data.subject,
+ html_content=email_data.html_content,
+ )
+ return Message(message="Password recovery email sent")
+
+
+@router.post("/reset-password/")
+def reset_password(session: SessionDep, body: NewPassword) -> Message:
+ """
+ Reset password
+ """
+ email = verify_password_reset_token(token=body.token)
+ if not email:
+ raise HTTPException(status_code=400, detail="Invalid token")
+ user = crud.get_user_by_email(session=session, email=email)
+ if not user:
+ raise HTTPException(
+ status_code=404,
+ detail="The user with this email does not exist in the system.",
+ )
+ elif not user.is_active:
+ raise HTTPException(status_code=400, detail="Inactive user")
+ hashed_password = get_password_hash(password=body.new_password)
+ user.hashed_password = hashed_password
+ session.add(user)
+ session.commit()
+ return Message(message="Password updated successfully")
+
+
+@router.post(
+ "/password-recovery-html-content/{email}",
+ dependencies=[Depends(get_current_active_superuser)],
+ response_class=HTMLResponse,
+)
+def recover_password_html_content(email: str, session: SessionDep) -> Any:
+ """
+ HTML Content for Password Recovery
+ """
+ user = crud.get_user_by_email(session=session, email=email)
+
+ if not user:
+ raise HTTPException(
+ status_code=404,
+ detail="The user with this username does not exist in the system.",
+ )
+ password_reset_token = generate_password_reset_token(email=email)
+ email_data = generate_reset_password_email(
+ email_to=user.email, email=email, token=password_reset_token
+ )
+
+ return HTMLResponse(
+ content=email_data.html_content, headers={"subject:": email_data.subject}
+ )
diff --git a/backend/app/api/routes/paths.py b/backend/app/api/routes/paths.py
new file mode 100644
index 0000000000..d4c46d6c76
--- /dev/null
+++ b/backend/app/api/routes/paths.py
@@ -0,0 +1,195 @@
+import uuid
+from typing import Any
+from datetime import datetime
+
+from fastapi import APIRouter, HTTPException
+from sqlmodel import Session, select, func
+
+from app.api.deps import CurrentUser, SessionDep
+from app.models import (
+ Path, Step, PathCreate, PathPublic, PathInList, PathsPublic,
+ utc_now, YoutubeExposition, StepPublic
+)
+
+router = APIRouter(prefix="/paths", tags=["paths"])
+
+@router.get("/", response_model=PathsPublic)
+async def list_paths(
+ session: SessionDep,
+ current_user: CurrentUser,
+ skip: int = 0,
+ limit: int = 100,
+) -> Any:
+ """
+ Retrieve paths without loading steps.
+ """
+ # Get total count
+ count_statement = (
+ select(func.count())
+ .select_from(Path)
+ .where(Path.creator_id == current_user.id)
+ )
+ count = session.exec(count_statement).one()
+
+ # Get paths without loading steps
+ statement = (
+ select(Path)
+ .where(Path.creator_id == current_user.id)
+ .offset(skip)
+ .limit(limit)
+ )
+ paths = session.exec(statement).all()
+
+ # Convert to PathInList responses
+ path_responses = [
+ PathInList(
+ id=path.id,
+ title=path.title,
+ path_summary=path.path_summary,
+ created_at=path.created_at,
+ )
+ for path in paths
+ ]
+
+ return PathsPublic(data=path_responses, count=count)
+
+@router.get("/{path_id}", response_model=PathPublic)
+async def get_path(
+ *,
+ session: SessionDep,
+ current_user: CurrentUser,
+ path_id: uuid.UUID,
+) -> Any:
+ """
+ Get path by ID with all its steps.
+ """
+ # Use select to explicitly join with steps
+ statement = (
+ select(Path)
+ .where(Path.id == path_id)
+ .where(Path.creator_id == current_user.id)
+ )
+ path = session.exec(statement).first()
+
+ if not path:
+ raise HTTPException(status_code=404, detail="Path not found")
+
+ # Convert each step's exposition_json to exposition
+ steps = []
+ for step in path.steps:
+ step_dict = step.model_dump()
+ if step.exposition_json:
+ step_dict["exposition"] = YoutubeExposition.model_validate_json(step.exposition_json)
+ steps.append(StepPublic.model_validate(step_dict))
+
+ # Return PathPublic with converted steps
+ return PathPublic(
+ id=path.id,
+ title=path.title,
+ path_summary=path.path_summary,
+ steps=steps
+ )
+
+@router.post("/", response_model=PathPublic)
+async def create_path(
+ *,
+ session: SessionDep,
+ current_user: CurrentUser,
+ path_in: PathCreate,
+) -> Any:
+ """
+ Create a new path with its steps.
+ """
+ path = Path(
+ creator_id=current_user.id,
+ title=path_in.title,
+ path_summary=path_in.path_summary,
+ )
+ session.add(path)
+ session.flush() # This assigns the ID to the path
+
+ # Create steps with proper ordering
+ for step_data in path_in.steps:
+ # Convert YoutubeExposition to JSON if present
+ exposition_json = None
+ if step_data.exposition:
+ exposition_json = step_data.exposition.model_dump_json()
+
+ step = Step(
+ path_id=path.id,
+ number=step_data.number,
+ role_prompt=step_data.role_prompt,
+ validation_prompt=step_data.validation_prompt,
+ exposition_json=exposition_json,
+ )
+ session.add(step)
+
+ session.commit()
+ session.refresh(path)
+ return path
+
+@router.put("/{path_id}", response_model=PathPublic)
+async def update_path(
+ *,
+ session: SessionDep,
+ current_user: CurrentUser,
+ path_id: uuid.UUID,
+ path_in: PathCreate,
+) -> Any:
+ """
+ Update a path and all its steps. Steps will be completely replaced.
+ """
+ path = session.get(Path, path_id)
+ if not path:
+ raise HTTPException(status_code=404, detail="Path not found")
+ if path.creator_id != current_user.id:
+ raise HTTPException(status_code=403, detail="Not enough permissions")
+
+ # Update path fields
+ path.title = path_in.title
+ path.path_summary = path_in.path_summary
+ path.updated_at = utc_now()
+
+ # Delete existing steps
+ for step in path.steps:
+ session.delete(step)
+
+ # Create new steps
+ for step_data in path_in.steps:
+ # Convert YoutubeExposition to JSON if present
+ exposition_json = None
+ if step_data.exposition:
+ exposition_json = step_data.exposition.model_dump_json()
+
+ step = Step(
+ path_id=path.id,
+ number=step_data.number,
+ role_prompt=step_data.role_prompt,
+ validation_prompt=step_data.validation_prompt,
+ exposition_json=exposition_json,
+ )
+ session.add(step)
+
+ session.commit()
+ session.refresh(path)
+ return path
+
+@router.delete("/{path_id}")
+async def delete_path(
+ *,
+ session: SessionDep,
+ current_user: CurrentUser,
+ path_id: uuid.UUID,
+) -> Any:
+ """
+ Delete a path and all its steps.
+ """
+ path = session.get(Path, path_id)
+ if not path:
+ raise HTTPException(status_code=404, detail="Path not found")
+ if path.creator_id != current_user.id:
+ raise HTTPException(status_code=403, detail="Not enough permissions")
+
+ session.delete(path) # This will cascade delete steps due to relationship
+ session.commit()
+ return {"message": "Path deleted successfully"}
\ No newline at end of file
diff --git a/backend/app/api/routes/private.py b/backend/app/api/routes/private.py
new file mode 100644
index 0000000000..9f33ef1900
--- /dev/null
+++ b/backend/app/api/routes/private.py
@@ -0,0 +1,38 @@
+from typing import Any
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from app.api.deps import SessionDep
+from app.core.security import get_password_hash
+from app.models import (
+ User,
+ UserPublic,
+)
+
+router = APIRouter(tags=["private"], prefix="/private")
+
+
+class PrivateUserCreate(BaseModel):
+ email: str
+ password: str
+ full_name: str
+ is_verified: bool = False
+
+
+@router.post("/users/", response_model=UserPublic)
+def create_user(user_in: PrivateUserCreate, session: SessionDep) -> Any:
+ """
+ Create a new user.
+ """
+
+ user = User(
+ email=user_in.email,
+ full_name=user_in.full_name,
+ hashed_password=get_password_hash(user_in.password),
+ )
+
+ session.add(user)
+ session.commit()
+
+ return user
diff --git a/backend/app/api/routes/users.py b/backend/app/api/routes/users.py
new file mode 100644
index 0000000000..0e8b5a87f8
--- /dev/null
+++ b/backend/app/api/routes/users.py
@@ -0,0 +1,228 @@
+import uuid
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException
+from sqlmodel import col, delete, func, select
+
+from app import crud
+from app.api.deps import (
+ CurrentUser,
+ SessionDep,
+ get_current_active_superuser,
+)
+from app.core.config import settings
+from app.core.security import get_password_hash, verify_password
+from app.models import (
+ Item,
+ Message,
+ UpdatePassword,
+ User,
+ UserCreate,
+ UserPublic,
+ UserRegister,
+ UsersPublic,
+ UserUpdate,
+ UserUpdateMe,
+)
+from app.utils import generate_new_account_email, send_email
+
+router = APIRouter(prefix="/users", tags=["users"])
+
+
+@router.get(
+ "/",
+ dependencies=[Depends(get_current_active_superuser)],
+ response_model=UsersPublic,
+)
+def read_users(session: SessionDep, skip: int = 0, limit: int = 100) -> Any:
+ """
+ Retrieve users.
+ """
+
+ count_statement = select(func.count()).select_from(User)
+ count = session.exec(count_statement).one()
+
+ statement = select(User).offset(skip).limit(limit)
+ users = session.exec(statement).all()
+
+ return UsersPublic(data=users, count=count)
+
+
+@router.post(
+ "/", dependencies=[Depends(get_current_active_superuser)], response_model=UserPublic
+)
+def create_user(*, session: SessionDep, user_in: UserCreate) -> Any:
+ """
+ Create new user.
+ """
+ user = crud.get_user_by_email(session=session, email=user_in.email)
+ if user:
+ raise HTTPException(
+ status_code=400,
+ detail="The user with this email already exists in the system.",
+ )
+
+ user = crud.create_user(session=session, user_create=user_in)
+ if settings.emails_enabled and user_in.email:
+ email_data = generate_new_account_email(
+ email_to=user_in.email, username=user_in.email, password=user_in.password
+ )
+ send_email(
+ email_to=user_in.email,
+ subject=email_data.subject,
+ html_content=email_data.html_content,
+ )
+ return user
+
+
+@router.patch("/me", response_model=UserPublic)
+def update_user_me(
+ *, session: SessionDep, user_in: UserUpdateMe, current_user: CurrentUser
+) -> Any:
+ """
+ Update own user.
+ """
+
+ if user_in.email:
+ existing_user = crud.get_user_by_email(session=session, email=user_in.email)
+ if existing_user and existing_user.id != current_user.id:
+ raise HTTPException(
+ status_code=409, detail="User with this email already exists"
+ )
+ user_data = user_in.model_dump(exclude_unset=True)
+ current_user.sqlmodel_update(user_data)
+ session.add(current_user)
+ session.commit()
+ session.refresh(current_user)
+ return current_user
+
+
+@router.patch("/me/password", response_model=Message)
+def update_password_me(
+ *, session: SessionDep, body: UpdatePassword, current_user: CurrentUser
+) -> Any:
+ """
+ Update own password.
+ """
+ if not verify_password(body.current_password, current_user.hashed_password):
+ raise HTTPException(status_code=400, detail="Incorrect password")
+ if body.current_password == body.new_password:
+ raise HTTPException(
+ status_code=400, detail="New password cannot be the same as the current one"
+ )
+ hashed_password = get_password_hash(body.new_password)
+ current_user.hashed_password = hashed_password
+ session.add(current_user)
+ session.commit()
+ return Message(message="Password updated successfully")
+
+
+@router.get("/me", response_model=UserPublic)
+def read_user_me(current_user: CurrentUser) -> Any:
+ """
+ Get current user.
+ """
+ return current_user
+
+
+@router.delete("/me", response_model=Message)
+def delete_user_me(session: SessionDep, current_user: CurrentUser) -> Any:
+ """
+ Delete own user.
+ """
+ if current_user.is_superuser:
+ raise HTTPException(
+ status_code=403, detail="Super users are not allowed to delete themselves"
+ )
+ statement = delete(Item).where(col(Item.owner_id) == current_user.id)
+ session.exec(statement) # type: ignore
+ session.delete(current_user)
+ session.commit()
+ return Message(message="User deleted successfully")
+
+
+@router.post("/signup", response_model=UserPublic)
+def register_user(session: SessionDep, user_in: UserRegister) -> Any:
+ """
+ Create new user without the need to be logged in.
+ """
+ user = crud.get_user_by_email(session=session, email=user_in.email)
+ if user:
+ raise HTTPException(
+ status_code=400,
+ detail="The user with this email already exists in the system",
+ )
+ user_create = UserCreate.model_validate(user_in)
+ user = crud.create_user(session=session, user_create=user_create)
+ return user
+
+
+@router.get("/{user_id}", response_model=UserPublic)
+def read_user_by_id(
+ user_id: uuid.UUID, session: SessionDep, current_user: CurrentUser
+) -> Any:
+ """
+ Get a specific user by id.
+ """
+ user = session.get(User, user_id)
+ if user == current_user:
+ return user
+ if not current_user.is_superuser:
+ raise HTTPException(
+ status_code=403,
+ detail="The user doesn't have enough privileges",
+ )
+ return user
+
+
+@router.patch(
+ "/{user_id}",
+ dependencies=[Depends(get_current_active_superuser)],
+ response_model=UserPublic,
+)
+def update_user(
+ *,
+ session: SessionDep,
+ user_id: uuid.UUID,
+ user_in: UserUpdate,
+) -> Any:
+ """
+ Update a user.
+ """
+
+ db_user = session.get(User, user_id)
+ if not db_user:
+ raise HTTPException(
+ status_code=404,
+ detail="The user with this id does not exist in the system",
+ )
+ if user_in.email:
+ existing_user = crud.get_user_by_email(session=session, email=user_in.email)
+ if existing_user and existing_user.id != user_id:
+ raise HTTPException(
+ status_code=409, detail="User with this email already exists"
+ )
+
+ db_user = crud.update_user(session=session, db_user=db_user, user_in=user_in)
+ return db_user
+
+
+@router.delete("/{user_id}", dependencies=[Depends(get_current_active_superuser)])
+def delete_user(
+ session: SessionDep, current_user: CurrentUser, user_id: uuid.UUID
+) -> Message:
+ """
+ Delete a user.
+ """
+ user = session.get(User, user_id)
+ if not user:
+ raise HTTPException(status_code=404, detail="User not found")
+ if user == current_user:
+ raise HTTPException(
+ status_code=403, detail="Super users are not allowed to delete themselves"
+ )
+ statement = delete(Item).where(col(Item.owner_id) == user_id)
+ session.exec(statement) # type: ignore
+ session.delete(user)
+ session.commit()
+ return Message(message="User deleted successfully")
diff --git a/backend/app/api/routes/utils.py b/backend/app/api/routes/utils.py
new file mode 100644
index 0000000000..fc093419b3
--- /dev/null
+++ b/backend/app/api/routes/utils.py
@@ -0,0 +1,31 @@
+from fastapi import APIRouter, Depends
+from pydantic.networks import EmailStr
+
+from app.api.deps import get_current_active_superuser
+from app.models import Message
+from app.utils import generate_test_email, send_email
+
+router = APIRouter(prefix="/utils", tags=["utils"])
+
+
+@router.post(
+ "/test-email/",
+ dependencies=[Depends(get_current_active_superuser)],
+ status_code=201,
+)
+def test_email(email_to: EmailStr) -> Message:
+ """
+ Test emails.
+ """
+ email_data = generate_test_email(email_to=email_to)
+ send_email(
+ email_to=email_to,
+ subject=email_data.subject,
+ html_content=email_data.html_content,
+ )
+ return Message(message="Test email sent")
+
+
+@router.get("/health-check/")
+async def health_check() -> bool:
+ return True
diff --git a/{{cookiecutter.project_slug}}/backend/app/app/backend_pre_start.py b/backend/app/backend_pre_start.py
similarity index 57%
rename from {{cookiecutter.project_slug}}/backend/app/app/backend_pre_start.py
rename to backend/app/backend_pre_start.py
index 41b6b63219..c2f8e29ae1 100644
--- a/{{cookiecutter.project_slug}}/backend/app/app/backend_pre_start.py
+++ b/backend/app/backend_pre_start.py
@@ -1,8 +1,10 @@
import logging
+from sqlalchemy import Engine
+from sqlmodel import Session, select
from tenacity import after_log, before_log, retry, stop_after_attempt, wait_fixed
-from app.db.session import db_session
+from app.core.db import engine
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@@ -17,14 +19,19 @@
before=before_log(logger, logging.INFO),
after=after_log(logger, logging.WARN),
)
-def init():
- # Try to create session to check if DB is awake
- db_session.execute("SELECT 1")
+def init(db_engine: Engine) -> None:
+ try:
+ with Session(db_engine) as session:
+ # Try to create session to check if DB is awake
+ session.exec(select(1))
+ except Exception as e:
+ logger.error(e)
+ raise e
-def main():
+def main() -> None:
logger.info("Initializing service")
- init()
+ init(engine)
logger.info("Service finished initializing")
diff --git a/{{cookiecutter.project_slug}}/backend/app/app/api/api_v1/endpoints/__init__.py b/backend/app/core/__init__.py
similarity index 100%
rename from {{cookiecutter.project_slug}}/backend/app/app/api/api_v1/endpoints/__init__.py
rename to backend/app/core/__init__.py
diff --git a/backend/app/core/ai_client.py b/backend/app/core/ai_client.py
new file mode 100644
index 0000000000..c28f5a1e2c
--- /dev/null
+++ b/backend/app/core/ai_client.py
@@ -0,0 +1,108 @@
+from typing import AsyncGenerator, Dict, Protocol, Literal
+from typing import Literal, TypedDict
+from anthropic import AsyncAnthropic
+from openai import AsyncOpenAI
+from app.core.config import settings
+import json
+import logging
+
+logger = logging.getLogger(__name__)
+
+class Message(TypedDict):
+ role: Literal["user", "assistant", "system"]
+ content: str
+
+class BaseAIClient(Protocol):
+ async def chat(self, messages: list[Message], system: str | None = None) -> str:
+ raise NotImplementedError
+
+ async def chat_stream(self, messages: list[Message], system: str | None = None) -> AsyncGenerator[str, None]:
+ raise NotImplementedError
+
+class AnthropicClient(BaseAIClient):
+ def __init__(self):
+ self.client = AsyncAnthropic(api_key=settings.ANTHROPIC_API_KEY)
+ self.model = settings.ANTHROPIC_MODEL
+
+ async def chat(self, messages: list[Message], system: str | None = None) -> str:
+ response = await self.client.messages.create(
+ model=self.model,
+ max_tokens=settings.MAX_TOKENS,
+ temperature=settings.TEMPERATURE,
+ system=system,
+ messages=[{"role": m["role"], "content": m["content"]} for m in messages]
+ )
+ return response.content[0].text
+
+ async def chat_stream(self, messages: list[Message], system: str | None = None) -> AsyncGenerator[str, None]:
+ """Stream chat responses."""
+ request_params = {
+ 'messages': [{"role": m["role"], "content": m["content"]} for m in messages],
+ 'model': self.model,
+ 'max_tokens': settings.MAX_TOKENS,
+ 'temperature': settings.TEMPERATURE,
+ }
+ if system:
+ request_params['system'] = system
+
+ async with self.client.messages.stream(**request_params) as stream:
+ async for text in stream.text_stream:
+ yield f"data: {json.dumps({'type': 'content', 'content': text})}\n\n"
+
+ # Get the final message for history
+ message = await stream.get_final_message()
+ self.add_message("assistant", message.content) # Add to history
+ yield f"data: {json.dumps({'type': 'done', 'content': ''})}\n\n"
+
+class OpenAIClient(BaseAIClient):
+ def __init__(self):
+ self.client = AsyncOpenAI(api_key=settings.OPENAI_API_KEY)
+ self.model = settings.OPENAI_MODEL
+
+ async def chat(self, messages: list[Message], system: str | None = None) -> str:
+ if system:
+ messages = [{"role": "system", "content": system}, *messages]
+
+ response = await self.client.chat.completions.create(
+ model=self.model,
+ temperature=settings.TEMPERATURE,
+ max_tokens=settings.MAX_TOKENS,
+ messages=[{"role": m["role"], "content": m["content"]} for m in messages]
+ )
+ return response.choices[0].message.content
+
+ async def chat_stream(self, messages: list[Message], system: str | None = None) -> AsyncGenerator[str, None]:
+ """Stream chat responses."""
+ if system:
+ messages = [{"role": "system", "content": system}, *messages]
+
+ response = await self.client.chat.completions.create(
+ model=self.model,
+ temperature=settings.TEMPERATURE,
+ max_tokens=settings.MAX_TOKENS,
+ messages=[{"role": m["role"], "content": m["content"]} for m in messages],
+ stream=True
+ )
+ async for chunk in response:
+ if chunk.choices:
+ yield chunk.choices[0].delta.content
+
+class ChatManager:
+ def __init__(self, client: Literal["anthropic", "openai"] = "anthropic"):
+ self.history: list[Message] = []
+ self.client = AnthropicClient() if client == "anthropic" else OpenAIClient()
+
+ def add_message(self, role: Literal["user", "assistant", "system"], content: str):
+ self.history.append({"role": role, "content": content})
+
+ async def send_message(self, content: str, system: str | None = None) -> str:
+ self.add_message("user", content)
+ response = await self.client.chat(self.history, system)
+ self.add_message("assistant", response)
+ return response
+
+ async def stream_message(self, content: str, system: str | None = None) -> AsyncGenerator[str, None]:
+ """Stream a message response."""
+ self.add_message("user", content)
+ async for chunk in self.client.chat_stream(self.history, system):
+ yield chunk
diff --git a/backend/app/core/config.py b/backend/app/core/config.py
new file mode 100644
index 0000000000..d6a9949a0f
--- /dev/null
+++ b/backend/app/core/config.py
@@ -0,0 +1,133 @@
+import secrets
+import warnings
+from typing import Annotated, Any, Literal
+
+from pydantic import (
+ AnyUrl,
+ BeforeValidator,
+ HttpUrl,
+ PostgresDsn,
+ computed_field,
+ model_validator,
+)
+from pydantic_core import MultiHostUrl
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing_extensions import Self
+
+
+def parse_cors(v: Any) -> list[str] | str:
+ if isinstance(v, str) and not v.startswith("["):
+ return [i.strip() for i in v.split(",")]
+ elif isinstance(v, list | str):
+ return v
+ raise ValueError(v)
+
+
+class Settings(BaseSettings):
+ model_config = SettingsConfigDict(
+ # Use top level .env file (one level above ./backend/)
+ env_file="../.env",
+ env_ignore_empty=True,
+ extra="ignore",
+ )
+ API_V1_STR: str = "/api/v1"
+ SECRET_KEY: str = secrets.token_urlsafe(32)
+ # 60 minutes * 24 hours * 8 days = 8 days
+ ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8
+ FRONTEND_HOST: str = "http://localhost:5173"
+ ENVIRONMENT: Literal["local", "staging", "production"] = "local"
+
+ BACKEND_CORS_ORIGINS: Annotated[
+ list[AnyUrl] | str, BeforeValidator(parse_cors)
+ ] = []
+
+ @computed_field # type: ignore[prop-decorator]
+ @property
+ def all_cors_origins(self) -> list[str]:
+ return [str(origin).rstrip("/") for origin in self.BACKEND_CORS_ORIGINS] + [
+ self.FRONTEND_HOST
+ ]
+
+ PROJECT_NAME: str
+ SENTRY_DSN: HttpUrl | None = None
+ POSTGRES_SERVER: str
+ POSTGRES_PORT: int = 5432
+ POSTGRES_USER: str
+ POSTGRES_PASSWORD: str = ""
+ POSTGRES_DB: str = ""
+
+ @computed_field # type: ignore[prop-decorator]
+ @property
+ def SQLALCHEMY_DATABASE_URI(self) -> PostgresDsn:
+ return MultiHostUrl.build(
+ scheme="postgresql+psycopg",
+ username=self.POSTGRES_USER,
+ password=self.POSTGRES_PASSWORD,
+ host=self.POSTGRES_SERVER,
+ port=self.POSTGRES_PORT,
+ path=self.POSTGRES_DB,
+ )
+
+ SMTP_TLS: bool = True
+ SMTP_SSL: bool = False
+ SMTP_PORT: int = 587
+ SMTP_HOST: str | None = None
+ SMTP_USER: str | None = None
+ SMTP_PASSWORD: str | None = None
+ # TODO: update type to EmailStr when sqlmodel supports it
+ EMAILS_FROM_EMAIL: str | None = None
+ EMAILS_FROM_NAME: str | None = None
+
+ # LLM API Configuration
+ ANTHROPIC_API_KEY: str
+ ANTHROPIC_MODEL: str = "claude-3-5-haiku-20241022"
+
+ OPENAI_API_KEY: str
+ OPENAI_MODEL: str = "gpt-4o-mini-2024-07-18"
+
+ # Common LLM settings
+ MAX_TOKENS: int = 4096
+ TEMPERATURE: float = 0.7
+
+ @model_validator(mode="after")
+ def _set_default_emails_from(self) -> Self:
+ if not self.EMAILS_FROM_NAME:
+ self.EMAILS_FROM_NAME = self.PROJECT_NAME
+ return self
+
+ EMAIL_RESET_TOKEN_EXPIRE_HOURS: int = 48
+
+ @computed_field # type: ignore[prop-decorator]
+ @property
+ def emails_enabled(self) -> bool:
+ return bool(self.SMTP_HOST and self.EMAILS_FROM_EMAIL)
+
+ # TODO: update type to EmailStr when sqlmodel supports it
+ EMAIL_TEST_USER: str = "test@example.com"
+ # TODO: update type to EmailStr when sqlmodel supports it
+ FIRST_SUPERUSER: str
+ FIRST_SUPERUSER_PASSWORD: str
+
+ def _check_default_secret(self, var_name: str, value: str | None) -> None:
+ if value == "changethis":
+ message = (
+ f'The value of {var_name} is "changethis", '
+ "for security, please change it, at least for deployments."
+ )
+ if self.ENVIRONMENT == "local":
+ warnings.warn(message, stacklevel=1)
+ else:
+ raise ValueError(message)
+
+ @model_validator(mode="after")
+ def _enforce_non_default_secrets(self) -> Self:
+ self._check_default_secret("SECRET_KEY", self.SECRET_KEY)
+ self._check_default_secret("POSTGRES_PASSWORD", self.POSTGRES_PASSWORD)
+ self._check_default_secret(
+ "FIRST_SUPERUSER_PASSWORD", self.FIRST_SUPERUSER_PASSWORD
+ )
+
+ return self
+
+
+settings = Settings() # type: ignore
diff --git a/backend/app/core/db.py b/backend/app/core/db.py
new file mode 100644
index 0000000000..ba991fb36d
--- /dev/null
+++ b/backend/app/core/db.py
@@ -0,0 +1,33 @@
+from sqlmodel import Session, create_engine, select
+
+from app import crud
+from app.core.config import settings
+from app.models import User, UserCreate
+
+engine = create_engine(str(settings.SQLALCHEMY_DATABASE_URI))
+
+
+# make sure all SQLModel models are imported (app.models) before initializing DB
+# otherwise, SQLModel might fail to initialize relationships properly
+# for more details: https://github.com/fastapi/full-stack-fastapi-template/issues/28
+
+
+def init_db(session: Session) -> None:
+ # Tables should be created with Alembic migrations
+ # But if you don't want to use migrations, create
+ # the tables un-commenting the next lines
+ # from sqlmodel import SQLModel
+
+ # This works because the models are already imported and registered from app.models
+ # SQLModel.metadata.create_all(engine)
+
+ user = session.exec(
+ select(User).where(User.email == settings.FIRST_SUPERUSER)
+ ).first()
+ if not user:
+ user_in = UserCreate(
+ email=settings.FIRST_SUPERUSER,
+ password=settings.FIRST_SUPERUSER_PASSWORD,
+ is_superuser=True,
+ )
+ user = crud.create_user(session=session, user_create=user_in)
diff --git a/backend/app/core/security.py b/backend/app/core/security.py
new file mode 100644
index 0000000000..7aff7cfb32
--- /dev/null
+++ b/backend/app/core/security.py
@@ -0,0 +1,27 @@
+from datetime import datetime, timedelta, timezone
+from typing import Any
+
+import jwt
+from passlib.context import CryptContext
+
+from app.core.config import settings
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+ALGORITHM = "HS256"
+
+
+def create_access_token(subject: str | Any, expires_delta: timedelta) -> str:
+ expire = datetime.now(timezone.utc) + expires_delta
+ to_encode = {"exp": expire, "sub": str(subject)}
+ encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=ALGORITHM)
+ return encoded_jwt
+
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+ return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password: str) -> str:
+ return pwd_context.hash(password)
diff --git a/backend/app/crud.py b/backend/app/crud.py
new file mode 100644
index 0000000000..905bf48724
--- /dev/null
+++ b/backend/app/crud.py
@@ -0,0 +1,54 @@
+import uuid
+from typing import Any
+
+from sqlmodel import Session, select
+
+from app.core.security import get_password_hash, verify_password
+from app.models import Item, ItemCreate, User, UserCreate, UserUpdate
+
+
+def create_user(*, session: Session, user_create: UserCreate) -> User:
+ db_obj = User.model_validate(
+ user_create, update={"hashed_password": get_password_hash(user_create.password)}
+ )
+ session.add(db_obj)
+ session.commit()
+ session.refresh(db_obj)
+ return db_obj
+
+
+def update_user(*, session: Session, db_user: User, user_in: UserUpdate) -> Any:
+ user_data = user_in.model_dump(exclude_unset=True)
+ extra_data = {}
+ if "password" in user_data:
+ password = user_data["password"]
+ hashed_password = get_password_hash(password)
+ extra_data["hashed_password"] = hashed_password
+ db_user.sqlmodel_update(user_data, update=extra_data)
+ session.add(db_user)
+ session.commit()
+ session.refresh(db_user)
+ return db_user
+
+
+def get_user_by_email(*, session: Session, email: str) -> User | None:
+ statement = select(User).where(User.email == email)
+ session_user = session.exec(statement).first()
+ return session_user
+
+
+def authenticate(*, session: Session, email: str, password: str) -> User | None:
+ db_user = get_user_by_email(session=session, email=email)
+ if not db_user:
+ return None
+ if not verify_password(password, db_user.hashed_password):
+ return None
+ return db_user
+
+
+def create_item(*, session: Session, item_in: ItemCreate, owner_id: uuid.UUID) -> Item:
+ db_item = Item.model_validate(item_in, update={"owner_id": owner_id})
+ session.add(db_item)
+ session.commit()
+ session.refresh(db_item)
+ return db_item
diff --git a/backend/app/email-templates/build/new_account.html b/backend/app/email-templates/build/new_account.html
new file mode 100644
index 0000000000..344505033b
--- /dev/null
+++ b/backend/app/email-templates/build/new_account.html
@@ -0,0 +1,25 @@
+
|
|
|
| Full name | +Role | +Status | +Actions | +|
|---|---|---|---|---|
|
+ |
+ ))}
+ ||||
|
+ {user.full_name || "N/A"}
+ {currentUser?.id === user.id && (
+ |
+ + {user.email} + | +{user.is_superuser ? "Superuser" : "User"} | +
+ |
+
+ |
+
| ID | +Title | +Description | +Actions | +
|---|---|---|---|
|
+ |
+ ))}
+ |||
| {item.id} | ++ {item.title} + | ++ {item.description || "N/A"} + | +
+ |
+