+
+
+## 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.com/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)
-### Alternative API documentation
+### Dashboard - Create User
-[](https://github.com/tiangolo/full-stack-fastapi-postgresql)
+[](https://github.com/fastapi/full-stack-fastapi-template)
-### Dashboard Login
+### Dashboard - Items
-[](https://github.com/tiangolo/full-stack-fastapi-postgresql)
+[](https://github.com/fastapi/full-stack-fastapi-template)
-### Dashboard - Create User
+### Dashboard - User Settings
+
+[](https://github.com/fastapi/full-stack-fastapi-template)
+
+### Dashboard - Dark Mode
+
+[](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** 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** 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.
-* 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.
- * It's also easy to remove it if you have an API-only app, check the instructions in the generated `README.md`.
-* **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 directory 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
-* `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.
+After cloning the repository, and after doing changes, you might want to get the latest changes from this original template.
-* `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.
+- Make sure you added the original repository as a remote, you can check it with:
-* `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 communicate 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_constraint_tag`: The tag that should be used by stack services that should communicate with the public.
+```bash
+git remote -v
-* `flower_auth`: Basic HTTP authentication for flower, in the form`user:password`. By default: "`admin:changethis`".
+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)
+```
-* `sentry_dsn`: Key URL (DSN) of Sentry, for live error reporting. You can use the open source version or a free account. E.g.: `https://1234abcd:5678ef@sentry.example.com/30`.
+- Pull the latest changes without merging:
-* `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.
+```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.
-## How to deploy
+- If there are conflicts, solve them in your editor.
-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.
+- Once you are done, commit the changes:
-Please refer to DockerSwarm.rocks to see how to deploy such a cluster in 20 minutes.
+```bash
+git merge --continue
+```
-## More details
+### Configure
-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).
+You can then update configs in the `.env` files to customize your configurations.
-## Sibling project generators
+Before deploying it, make sure you change at least the values for:
-* Full Stack FastAPI Couchbase: [https://github.com/tiangolo/full-stack-fastapi-couchbase](https://github.com/tiangolo/full-stack-fastapi-couchbase).
+- `SECRET_KEY`
+- `FIRST_SUPERUSER_PASSWORD`
+- `POSTGRES_PASSWORD`
-## Release Notes
+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.
-### Latest Changes
+## How To Use It - Alternative With Copier
-* Update issue-manager. PR [#211](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/211).
-* Add [GitHub Sponsors](https://github.com/sponsors/tiangolo) button. PR [#201](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/201).
-* Add consistent errors for env vars not set. PR [#200](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/200).
-* Upgrade Traefik to version 2, keeping in sync with DockerSwarm.rocks. PR [#199](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/199).
-* Add docs about reporting test coverage in HTML. PR [#161](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/161).
-* Run tests with `TestClient`. PR [#160](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/160).
-* Refactor backend:
- * Simplify configs for tools and format to better support editor integration.
- * Add mypy configurations and plugins.
- * Add types to all the codebase.
- * Update types for SQLAlchemy models with plugin.
- * Update and refactor CRUD utils.
- * Refactor DB sessions to use dependencies with `yield`.
- * Refactor dependencies, security, CRUD, models, schemas, etc. To simplify code and improve autocompletion.
- * Change from PyJWT to Python-JOSE as it supports additional use cases.
- * Fix JWT tokens using user email/ID as the subject in `sub`.
- * PR [#158](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/158).
-* Add docs about removing the frontend, for an API-only app. PR [#156](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/156).
-* Simplify scripts and development, update docs and configs. PR [#155](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/155).
-* Simplify `docker-compose.*.yml` files, refactor deployment to reduce config files. PR [#153](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/153).
-* Simplify env var files, merge to a single `.env` file. PR [#151](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/151).
+This repository also supports generating a new project using [Copier](https://copier.readthedocs.io).
-### 0.5.0
+It will copy all the files, ask you configuration questions, and update the `.env` files with your answers.
-* Make the Traefik public network a fixed default of `traefik-public` as done in DockerSwarm.rocks, to simplify development and iteration of the project generator. PR [#150](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/150).
-* Update to PostgreSQL 12. PR [#148](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/148). by [@RCheese](https://github.com/RCheese).
-* Use Poetry for package management. Initial PR [#144](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/144) by [@RCheese](https://github.com/RCheese).
-* Fix Windows line endings for shell scripts after project generation with Cookiecutter hooks. PR [#149](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/149).
-* Upgrade Vue CLI to version 4. PR [#120](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/120) by [@br3ndonland](https://github.com/br3ndonland).
-* Remove duplicate `login` tag. PR [#135](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/135) by [@Nonameentered](https://github.com/Nonameentered).
-* Fix showing email in dashboard when there's no user's full name. PR [#129](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/129) by [@rlonka](https://github.com/rlonka).
-* Format code with Black and Flake8. PR [#121](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/121) by [@br3ndonland](https://github.com/br3ndonland).
-* Simplify SQLAlchemy Base class. PR [#117](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/117) by [@airibarne](https://github.com/airibarne).
-* Update CRUD utils for users, handling password hashing. PR [#106](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/106) by [@mocsar](https://github.com/mocsar).
-* Use `.` instead of `source` for interoperability. PR [#98](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/98) by [@gucharbon](https://github.com/gucharbon).
-* Use Pydantic's `BaseSettings` for settings/configs and env vars. PR [#87](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/87) by [@StephenBrown2](https://github.com/StephenBrown2).
-* Remove `package-lock.json` to let everyone lock their own versions (depending on OS, etc).
-* Simplify Traefik service labels PR [#139](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/139).
-* Add email validation. PR [#40](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/40) by [@kedod](https://github.com/kedod).
-* Fix typo in README. PR [#83](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/83) by [@ashears](https://github.com/ashears).
-* Fix typo in README. PR [#80](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/80) by [@abjoker](https://github.com/abjoker).
-* Fix function name `read_item` and response code. PR [#74](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/74) by [@jcaguirre89](https://github.com/jcaguirre89).
-* Fix typo in comment. PR [#70](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/70) by [@daniel-butler](https://github.com/daniel-butler).
-* Fix Flower Docker configuration. PR [#37](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/37) by [@dmontagu](https://github.com/dmontagu).
-* Add new CRUD utils based on DB and Pydantic models. Initial PR [#23](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/23) by [@ebreton](https://github.com/ebreton).
-* Add normal user testing Pytest fixture. PR [#20](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/20) by [@ebreton](https://github.com/ebreton).
+### Install Copier
-### 0.4.0
+You can install Copier with:
-* Fix security on resetting a password. Receive token as body, not query. PR [#34](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/34).
+```bash
+pip install copier
+```
-* Fix security on resetting a password. Receive it as body, not query. PR [#33](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/33) by [@dmontagu](https://github.com/dmontagu).
+Or better, if you have [`pipx`](https://pipx.pypa.io/), you can run it with:
-* Fix SQLAlchemy class lookup on initialization. PR [#29](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/29) by [@ebreton](https://github.com/ebreton).
+```bash
+pipx install copier
+```
-* Fix SQLAlchemy operation errors on database restart. PR [#32](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/32) by [@ebreton](https://github.com/ebreton).
+**Note**: If you have `pipx`, installing copier is optional, you could run it directly.
-* Fix locations of scripts in generated README. PR [#19](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/19) by [@ebreton](https://github.com/ebreton).
+### Generate a Project With Copier
-* Forward arguments from script to `pytest` inside container. PR [#17](https://github.com/tiangolo/full-stack-fastapi-postgresql/pull/17) by [@ebreton](https://github.com/ebreton).
+Decide a name for your new project's directory, you will use it below. For example, `my-awesome-project`.
-* Update development scripts.
+Go to the directory that will be the parent of your project, and run the command with your project's name:
-* Read Alembic configs from env vars. PR #9 by @ebreton.
+```bash
+copier copy https://github.com/fastapi/full-stack-fastapi-template my-awesome-project --trust
+```
-* Create DB Item objects from all Pydantic model's fields.
+If you have `pipx` and you didn't install `copier`, you can run it directly:
-* Update Jupyter Lab installation and util script/environment variable for local development.
+```bash
+pipx run copier copy https://github.com/fastapi/full-stack-fastapi-template my-awesome-project --trust
+```
-### 0.3.0
+**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.
-* PR #14:
- * Update CRUD utils to use types better.
- * Simplify Pydantic model names, from `UserInCreate` to `UserCreate`, etc.
- * Upgrade packages.
- * Add new generic "Items" models, crud utils, endpoints, and tests. To facilitate re-using them to create new functionality. As they are simple and generic (not like Users), it's easier to copy-paste and adapt them to each use case.
- * Update endpoints/*path operations* to simplify code and use new utilities, prefix and tags in `include_router`.
- * Update testing utils.
- * Update linting rules, relax vulture to reduce false positives.
- * Update migrations to include new Items.
- * Update project README.md with tips about how to start with backend.
+### Input Variables
-* Upgrade Python to 3.7 as Celery is now compatible too. PR #10 by @ebreton.
+Copier will ask you for some data, you might want to have at hand before generating the project.
-### 0.2.2
+But don't worry, you can just update any of that in the `.env` files afterwards.
-* Fix frontend hijacking /docs in development. Using latest https://github.com/tiangolo/node-frontend with custom Nginx configs in frontend. PR #6.
+The input variables, with their default values (some auto generated) are:
-### 0.2.1
+- `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.
-* Fix documentation for *path operation* to get user by ID. PR #4 by @mpclarkson in FastAPI.
+## Backend Development
-* Set `/start-reload.sh` as a command override for development by default.
+Backend docs: [backend/README.md](./backend/README.md).
-* Update generated README.
+## Frontend Development
-### 0.2.0
+Frontend docs: [frontend/README.md](./frontend/README.md).
-**PR #2**:
+## Deployment
-* Simplify and update backend `Dockerfile`s.
-* Refactor and simplify backend code, improve naming, imports, modules and "namespaces".
-* Improve and simplify Vuex integration with TypeScript accessors.
-* Standardize frontend components layout, buttons order, etc.
-* Add local development scripts (to develop this project generator itself).
-* Add logs to startup modules to detect errors early.
-* Improve FastAPI dependency utilities, to simplify and reduce code (to require a superuser).
+Deployment docs: [deployment.md](./deployment.md).
-### 0.1.2
+## Development
-* Fix path operation to update self-user, set parameters as body payload.
+General development docs: [development.md](./development.md).
-### 0.1.1
+This includes using Docker Compose, custom local domains, `.env` configurations, etc.
-Several bug fixes since initial publication, including:
+## Release Notes
-* Order of path operations for users.
-* Frontend sending login data in the correct format.
-* Add https://localhost variants to CORS.
+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/SECURITY.md b/SECURITY.md
new file mode 100644
index 0000000000..0045fb8182
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,29 @@
+# Security Policy
+
+Security is very important for this project and its community. π
+
+Learn more about it below. π
+
+## Versions
+
+The latest version or release is supported.
+
+You are encouraged to write tests for your application and update your versions frequently after ensuring that your tests are passing. This way you will benefit from the latest features, bug fixes, and **security fixes**.
+
+## Reporting a Vulnerability
+
+If you think you found a vulnerability, and even if you are not sure about it, please report it right away by sending an email to: security@tiangolo.com. Please try to be as explicit as possible, describing all the steps and example code to reproduce the security issue.
+
+I (the author, [@tiangolo](https://twitter.com/tiangolo)) will review it thoroughly and get back to you.
+
+## Public Discussions
+
+Please restrain from publicly discussing a potential security vulnerability. π
+
+It's better to discuss privately and try to find a solution first, to limit the potential impact as much as possible.
+
+---
+
+Thanks for your help!
+
+The community and I thank you for that. π
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/.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..fc672e525f
--- /dev/null
+++ b/backend/Dockerfile
@@ -0,0 +1,44 @@
+FROM python:3.10
+
+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
+COPY ./tests /app/tests
+
+# Sync the project
+# Ref: https://docs.astral.sh/uv/guides/integration/docker/#intermediate-layers
+RUN --mount=type=cache,target=/root/.cache/uv \
+ uv sync
+
+CMD ["fastapi", "run", "--workers", "4", "app/main.py"]
diff --git a/backend/README.md b/backend/README.md
new file mode 100644
index 0000000000..c217000fc2
--- /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/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 98%
rename from {{cookiecutter.project_slug}}/backend/app/alembic.ini
rename to backend/alembic.ini
index 921aaf17b8..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
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 82%
rename from {{cookiecutter.project_slug}}/backend/app/alembic/env.py
rename to backend/app/alembic/env.py
index 3ba3420643..7f29c04680 100755
--- a/{{cookiecutter.project_slug}}/backend/app/alembic/env.py
+++ b/backend/app/alembic/env.py
@@ -1,10 +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.
@@ -20,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:
@@ -31,11 +30,7 @@
def get_url():
- user = os.getenv("POSTGRES_USER", "postgres")
- password = os.getenv("POSTGRES_PASSWORD", "")
- server = os.getenv("POSTGRES_SERVER", "db")
- db = os.getenv("POSTGRES_DB", "app")
- return f"postgresql://{user}:{password}@{server}/{db}"
+ return str(settings.SQLALCHEMY_DATABASE_URI)
def run_migrations_offline():
@@ -69,7 +64,9 @@ def run_migrations_online():
configuration = config.get_section(config.config_ini_section)
configuration["sqlalchemy.url"] = get_url()
connectable = engine_from_config(
- configuration, prefix="sqlalchemy.", poolclass=pool.NullPool,
+ configuration,
+ prefix="sqlalchemy.",
+ poolclass=pool.NullPool,
)
with connectable.connect() as connection:
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/{{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..eac18c8e8f
--- /dev/null
+++ b/backend/app/api/main.py
@@ -0,0 +1,14 @@
+from fastapi import APIRouter
+
+from app.api.routes import items, login, private, users, utils
+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)
+
+
+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/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/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..6429818458
--- /dev/null
+++ b/backend/app/api/routes/users.py
@@ -0,0 +1,226 @@
+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"
+ )
+ 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 68%
rename from {{cookiecutter.project_slug}}/backend/app/app/backend_pre_start.py
rename to backend/app/backend_pre_start.py
index 3363a41542..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 SessionLocal
+from app.core.db import engine
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@@ -17,11 +19,11 @@
before=before_log(logger, logging.INFO),
after=after_log(logger, logging.WARN),
)
-def init() -> None:
+def init(db_engine: Engine) -> None:
try:
- db = SessionLocal()
- # Try to create session to check if DB is awake
- db.execute("SELECT 1")
+ 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
@@ -29,7 +31,7 @@ def init() -> None:
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/config.py b/backend/app/core/config.py
new file mode 100644
index 0000000000..6a8ca50bb1
--- /dev/null
+++ b/backend/app/core/config.py
@@ -0,0 +1,119 @@
+import secrets
+import warnings
+from typing import Annotated, Any, Literal
+
+from pydantic import (
+ AnyUrl,
+ BeforeValidator,
+ EmailStr,
+ HttpUrl,
+ PostgresDsn,
+ computed_field,
+ model_validator,
+)
+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(",") if i.strip()]
+ 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 PostgresDsn.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
+ EMAILS_FROM_EMAIL: EmailStr | None = None
+ EMAILS_FROM_NAME: EmailStr | None = None
+
+ @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)
+
+ EMAIL_TEST_USER: EmailStr = "test@example.com"
+ FIRST_SUPERUSER: EmailStr
+ 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/{{cookiecutter.project_slug}}/backend/app/app/core/security.py b/backend/app/core/security.py
similarity index 58%
rename from {{cookiecutter.project_slug}}/backend/app/app/core/security.py
rename to backend/app/core/security.py
index 6c6ee8bc30..7aff7cfb32 100644
--- a/{{cookiecutter.project_slug}}/backend/app/app/core/security.py
+++ b/backend/app/core/security.py
@@ -1,7 +1,7 @@
-from datetime import datetime, timedelta
-from typing import Any, Union
+from datetime import datetime, timedelta, timezone
+from typing import Any
-from jose import jwt
+import jwt
from passlib.context import CryptContext
from app.core.config import settings
@@ -12,15 +12,8 @@
ALGORITHM = "HS256"
-def create_access_token(
- subject: Union[str, Any], expires_delta: timedelta = None
-) -> str:
- if expires_delta:
- expire = datetime.utcnow() + expires_delta
- else:
- expire = datetime.utcnow() + timedelta(
- minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES
- )
+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
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 @@
+
|
|
|
|
|
|
A password recovery email will be sent to the registered account
-Enter your new password below
-